When is a loop “non-trivial”?

Question

Is it correct to call a loop that you do not know the limit at compile time "non-trivial"?

If you know that you will be using a value from a class that will be in a range e.g. between 0-1000, is that still non-trivial?

e.g. Where ISomeInterface.MAX_LIMIT is always between 1-1000:

public bool someMethod(Type someType, int someId, int someVariable)
{
    bool returnFlag = false;
    int maxLimit = (Activator.CreateInstance(someType) as ISomeInterface).MAX_LIMIT;

    for (int i = 0; i < maxLimit; i++) //is this a non-trivial loop?
    {
        if (_someSerivce.SomeOtherMethod(someType, someId, someVariable, i))
        {
            returnFlag= true;
        }
    }
    return returnFlag;
}

---

Edit: Was uncertain as to whether this was a meaningful piece of terminology.

I originally read it in one of Jon Skeet's pieces from yoda.arachsys: http://www.yoda.arachsys.com/csharp/stringbuilder.html (see the section headed Rules Of Thumb).

Do you use this as technical terminology at all?

Answer 1

When I've used the term it's usually been in relation to compiler optimizations ... in that context a trivial loop was one that the compiler could fully unroll without creating adverse conditions (ie increasing the block count, removing the ability to inline other code etc) ...

So we generally meant loops with a small number of instructions or few number of iterations (the later being the more common meaning).

With that said, it's definitely a non-standard term without a solid technical definition.

Answer 2

It's not a standard term. Personally, I'd consider a loop trivial if the test condition (2nd part) is a simple comparison of a value that changes only due to the counting expression (3rd part of for loop).

Here, the test condition is i < maxLimit (simple comparison on i) and the counting expression is i++ (same variable i). So, yes, trivial.

Answer 3

I can't be sure, but trivial or non-trivial for loops have nothing to do with the range, but rather the increment. A for loop is "trivial" if it is executed at increments of 1, i.e., i++ in your case. The same loop is "non-trivial" if it is not executed at increments of 1, such as executing at every even iteration, etc.

Answer 4

A loop is trivial if executing it takes up a trivial part of your program's execution time.

Answer 5

for( int i = 0, k = 1, l=things.size(); i < k && l >= 0 ; --l )
{
   if( things[i] == things[k] )
   {
      things.doit();
      ++i;
   }
}

This is a non-trivial loop. It's harder to understand than most common ways to write it.

That said, here it's obviously obfuscated. I don't have real world example at hand.

Answer 6

First of all, in a broader sense, I would colloquially define non-trivial code by code whose implementation and execution has a significant impact on the nature of the project as a whole. This is obviously somewhat situational, making the term an imprecise one. Context is a big factor in relation to the meaning of non-trivial when talking about a specific piece of code, whether it is a loop or any other structure. There are a few possible scenarios:

• Performance
• Design
• Maintainability
• Portability

In each of these cases, a code block can be non-trivial, and it means something different in every case.

For your example, you seem to be talking about performance. In the context of performance, I believe a good metric for non-trivial would be its Big-O performance. In your example, the loop is O(n), which in many scenarios is a perfectly acceptable performance, and is the Big-O of a large percentage of for loops.

In the context of performance, one might also say code is non-trivial if its execution time is very large with respect to the total execution time of the whole program.

Answer 7

It's not a well-defined piece of technical jargon or a common term of art. Skeet is just using it in the ordinary English language sense: "non-trivial" means "not meaningless."

In that article, "in a non-trivial loop" means "in a loop that takes a meaningful length of time."