## Friday, January 30, 2015

### Finding zeros in an array

A common thing to want to do is to find zero values in an array. This is obviously necessary for string length. So we'll start out with a test harness and a simple implementation:

```#include "timing.h"

unsigned int len(char* array)
{
unsigned int length = 0;
while( array[length] ) { length++; }
return length;
}

#define COUNT 100000
void main()
{
char array[ COUNT ];
for (int i=1; i<COUNT; i++)
{
array[i-1] = 'a';
array[i] = 0;
if ( i != len(array) ) { printf( "Error at %i\n", i ); }
}
starttime();
for (int i=1; i<COUNT; i++)
{
array[i-1] = 'a';
array[i] = 0;
len(array);
}
endtime(COUNT);
}
```

A chap called Alan Mycroft came up with a very neat algorithm to simultaneously examine multiple bytes and determine whether there is a zero in them. His algorithm starts off with the idea that there are two conditions that need to be true if a byte contains the value zero. First of all the upper bit of the byte must be zero, this is true for zero and all values less than 128, so on its own it is not sufficient. The second characteristic is that if one is subtracted from the value, then the upper bit must be one. This is true for zero and all values greater than 128. Although both conditions are individually satisfied by multiple values, the only value that satisfies both conditions is zero.

The following code uses the Mycroft test for a string length implementation. The code contains a pre-loop to get to an eight byte aligned address.

```unsigned int len2(char* array)
{
unsigned int length = 0;
// Handle misaligned data
while ( ( (unsigned long long) & array[length] ) &7 )
{
if ( array[length] == 0 ) { return length; }
length++;
}

unsigned long long * p = (unsigned long long *) & array[length];
unsigned long long v8, v7;
do
{
v8 = *p;
v7 = v8 - 0x0101010101010101;
v7 = (v7 & ~v8) & 0x8080808080808080;
p++;
}
while ( !v7 );
length = (char*)p - array-8;
while ( array[length] ) { length++; }
return length;
}
```

The algorithm has one weak point. It does not always report exactly which byte is zero, just that there is a zero byte somewhere. Hence the final loop where we work out exactly which byte is zero.

It is a trivial extension to use this to search for a byte of any value. If we XOR the input vector with a vector of bytes containing the target value, then we get a zero byte where the target value occurs, and a non-zero byte everywhere else.

It is also easy to extend the code to search for other zero bit patterns. For example, if we want to find zero nibbles (ie 4 bit values), then we can change the constants to be 0x1111111111111111 and 0x8888888888888888.

## Thursday, January 29, 2015

### Bit manipulation: Population Count

Population count is one of the more esoteric instructions. It's the operation to count the number of set bits in a register. It comes up with sufficient frequency that most processors have a hardware instruction to do it. However, for this example, we're going to look at coding it in software. First of all we'll write a baseline version of the code:

```int popc(unsigned long long value)
{
unsigned long long bit = 1;
int popc = 0;
while ( bit )
{
if ( value & bit ) { popc++; }
bit = bit << 1;
}
return popc;
}
```

The above code examines every bit in the input and counts the number of set bits. The number of iterations is proportional to the number of bits in the register.

Most people will immediately recognise that we could make this a bit faster using the code we discussed previously that clears the last set bit, whist there are set bits keep clearing them, otherwise you're done. The advantage of this approach is that you only iterate once for every set bit in the value. So if there are no set bits, then you do not do any iterations.

```int popc2( unsigned long long value )
{
int popc = 0;
while ( value )
{
popc++;
value = value & (value-1);
}
return popc;
}
```

The next thing to do is to put together a test harness that confirms that the new code produces the same results as the old code, and also measures the performance of the two implementations.

```#define COUNT 1000000
void main()
{
// Correctness test
for (unsigned long long i = 0; i<COUNT; i++ )
{
if (popc( i + (i<<32) ) != popc2( i + (i<<32) ) )
{
printf(" Mismatch popc2 input %llx: %u!= %u\n",
i+(i<<32), popc(i+(i<<32)), popc2(i+(i<<32)));
}
}

// Performance test
starttime();
for (unsigned long long i = 0; i<COUNT; i++ )
{
popc(i+(i<<32));
}
endtime(COUNT);
starttime();
for (unsigned long long i = 0; i<COUNT; i++ )
{
popc2(i+(i<<32));
}
}
```

The new code is about twice as fast as the old code. However, the new code still contains a loop, and this can be a bit of a problem.

Branch mispredictions

The trouble with loops, and with branches in general, is that processors don't know the next instruction that will be executed after the branch until the branch has been reached, but the processor needs to have already fetched instruction after the branch well before this. The problem is nicely summarised by Holly in Red Dwarf:

"Look, I'm trying to navigate at faster than the speed of light, which means that before you see something, you've already passed through it."

So processors use branch prediction to guess whether a branch is taken or not. If the prediction is correct there is no break in the instruction stream, but if the prediction is wrong, then the processor needs to throw away all the incorrectly predicted instructions, and fetch the instructions from correct address. This is a significant cost, so ideally you don't want mispredicted branches, and the best way of ensuring that is to not have branches at all!

The following code is a branchless sequence for computing population count

```unsigned int popc3(unsigned long long value)
{
unsigned long long v2;
v2     = value &t;< 1;
v2    &= 0x5555555555555555;
value &= 0x5555555555555555;
value += v2;
v2     = value << 2;
v2    &= 0x3333333333333333;
value &= 0x3333333333333333;
value += v2;
v2     = value << 4;
v2    &= 0x0f0f0f0f0f0f0f0f;
value &= 0x0f0f0f0f0f0f0f0f;
value += v2;
v2     = value << 8;
v2    &= 0x00ff00ff00ff00ff;
value &= 0x00ff00ff00ff00ff;
value += v2;
v2     = value << 16;
v2    &= 0x0000ffff0000ffff;
value &= 0x0000ffff0000ffff;
value += v2;
v2     = value << 32;
value += v2;
return (unsigned int) value;
}
```

This instruction sequence computes the population count by initially adding adjacent bits to get a two bit result of 0, 1, or 2. It then adds the adjacent pairs of bits to get a 4 bit result of between 0 and 4. Next it adds adjacent nibbles to get a byte result, then adds pairs of bytes to get shorts, then adds shorts to get a pair of ints, which it adds to get the final value. The code contains a fair amount of AND operations to mask out the bits that are not part of the result.

This bit manipulation version is about two times faster than the clear-last-bit-set version, making it about four times faster than the original code. However, it is worth noting that this is a fixed cost. The routine takes the same amount of time regardless of the input value. In contrast the clear -last-bit-set version will exit early if there are no set bits. Consequently the performance gain for the code will depend on both the input value and the cost of mispredicted branches.

## Wednesday, January 28, 2015

### Tracking application resource use

One question you might ask is "how much memory is my application consuming?". Obviously you can use prstat (`prstat -cp <pid>` or `prstat -cmLp <pid>`) to examine the behaviour of a process. But how about programmatically finding that information.

OTN has just published an article where I demonstrate how to find out about the resource use of a process, and incidentally how to put that functionality into a library that reports resource use over time.

### Inline functions in C

Functions declared as `inline` are slightly more complex than might be expected. Douglas Walls has provided a chapter-and-verse write up. But the issue bears further explanation.

When a function is declared as `inline` it's a hint to the compiler that the function could be inlined. It is not a command to the compiler that the function must be inlined. If the compiler chooses not to inline the function, then the function will be left with a function call that needs to be resolved, and at link time it will be necessary for a function definition to be provided. Consider this example:

```#include <stdio.h>

inline void foo()
{
printf(" In foo\n");
}

void main()
{
foo();
}
```

The code provides an inline definition of foo(), so if the compiler chooses to inline the function it will use this definition. However, if it chooses not to inline the function, you will get a link time error when the linker is unable to find a suitable definition for the symbol `foo`:

```\$ cc -o in in.c
Undefined                       first referenced
symbol                             in file
foo                                 in.o
ld: fatal: symbol referencing errors. No output written to in
```

This can be worked around by adding either "static" or "extern" to the definition of the inline function.

If the function is declared to be a `static inline` then, as before the compiler may choose to inline the function. In addition the compiler will emit a locally scoped version of the function in the object file. There can be one static version per object file, so you may end up with multiple definitions of the same function, so this can be very space inefficient. Since all the functions are locally scoped, there is are no multiple definitions.

Another approach is to declare the function as `extern inline`. In this case the compiler may generate inline code, and will also generate a global instance of the function. Although multiple global instances of the function might be generated in all the object files, only one will be remain in the executable after linking. So declaring functions as `extern inline` is more space efficient.

This behaviour is defined by the standard. However, gcc takes a different approach, which is to treat `inline` functions by generating a global function and potentially inlining the code. Unfortunately this can cause multiply-defined symbol errors at link time, where the same `extern inline` function is declared in multiple files. For example, in the following code both in.c and in2.c include in.h which contains the definition of `extern inline foo() {...}`.

```\$ gcc -o in in.c in2.c
ld: fatal: symbol 'foo' is multiply-defined:
```

The gcc behaviour for functions declared as `extern inline` is also different. It does not emit an external definition for these functions, leading to unresolved symbol errors at link time.

For gcc, it is best to either declare the functions as `extern inline` and, in additional module, provide a global definition of the function, or to declare the functions as `static inline` and live with the multiple local symbol definitions that this produces.

So for convenience it is tempting to use `static inline` for all compilers. This is a good work around (ignoring the issue of duplicate local copies of functions), except for an issue around unused code.

The keyword `static` tells the compiler to emit a locally-scoped version of the function. Solaris Studio emits that function even if the function does not get called within the module. If that function calls a non-existent function, then you may get a link time error. Suppose you have the following code:

```void error_message();

static inline unused()
{
error_message();
}

void main()
{
}
```

Compiling this we get the following error message:

```\$ cc -O i.c
"i.c", line 3: warning: no explicit type given
Undefined                       first referenced
symbol                             in file
error_message                       i.o
```

Even though the function call exists in code that is not used, there is a link error for the undefined function `error_message()`. The same error would occur if `extern inline` was used as this would cause a global version of the function to be emitted. The problem would not occur if the function were just declared as `inline` because in this case the compiler would not emit either a global or local version of the function. The same code compiles with gcc because the unused function is not generated.

So to summarise the options:

• Declare everything `static inline`, and ensure that there are no undefined functions, and that there are no functions that call undefined functions.
• Declare everything `inline` for Studio and `extern inline` for gcc. Then provide a global version of the function in a separate file.

### Improving performance through bit manipulation: clear last set bit

Bit manipulation is one of those fun areas where you can get a performance gain from recoding a routine to use logical or arithmetic instructions rather than a more straight-forward code.

Of course, in doing this you need to avoid the pit fall of premature optimisation - where you needlessly make the code more obscure with no benefit, or a benefit that disappears as soon as you run your code on a different machine. So with that caveat in mind, let's take a look at a simple example.

Clear last set bit

This is a great starting point because it nicely demonstrates how we can sometimes replace a fair chunk of code with a much simpler set of instructions. Of course, the algorithm that uses fewer instructions is harder to understand, but in some situations the performance gain is worth it.

We'll start off with some classic code to solve the problem. The reason for this is two-fold. First of all we want to clearly understand the problem we're solving. Secondly, we want a reference version that we can test against to ensure that our fiendishly clever code is actually correct. So here's our starting point:

```unsigned long long clearlastbit( unsigned long long value )
{
int bit=1;
if ( value== 0 ) { return 0; }
while ( !(value & bit) )
{
bit = bit << 1;
}
value = value ^ bit;
return value;
}
```

But before we start trying to improve it we need a timing harness to find out how fast it runs. The following harness uses the Solaris call gethrtime() to return a timestamp in nanoseconds.

```#include <stdio.h>
#include <sys/time.h>

static double s_time;

void starttime()
{
s_time = 1.0 * gethrtime();
}

void endtime(unsigned long long its)
{
double e_time = 1.0 * gethrtime();
printf( "Time per iteration %5.2f ns\n", (e_time-s_time) / (1.0*its) );
s_time = 1.0 * gethrtime();
}
```

The next thing we need is a workload to test the current implementation. The workload iterates over a range of numbers and repeatedly calls clearlastbit() until all the bits in the current number have been cleared.

```#define COUNT 1000000
void main()
{
starttime();
for (unsigned long long i = 0; i < COUNT; i++ )
{
unsigned long long value = i;
while (value) { value = clearlastbit(value); }
}
endtime(COUNT);
}
```

Big O notation

So let's take a break at this point to discuss big O notation. If we look at the code for clearlastbit() we can see that it contains a loop. We'll iterate around the loop once for each bit in the input value, so for a N bit number we might iterate up to N times. We say that this computation is "order N", meaning that the cost the calculation is somehow proportional to the number of bits in the input number. This is written as O(N).

The order N description is useful because it gives us some idea of the cost of calling the routine. From it we know that the routine will typically take twice as long if coded for 8 byte inputs than if we used 4 byte inputs. Order N is not too bad as costs go, the ones to look out for are order N squared, or cubed etc. For these higher orders the run time to complete a computation can become huge for even comparatively small values of N.

If we look at the test harness, we are iterating over the function COUNT times, so effectively the entire program is O(COUNT*N), and we're exploiting the fact that this is effectively an O(N^2) cost to provide a workload that has a reasonable duration.

So let's return to the problem of clearing the last set bit. One obvious optimisation would be to record the last bit that was cleared, and then start the next iteration of the loop from that point. This is potentially a nice gain, but does not fundamentally change the algorithm. A better approach is to take advantage of bit manipulation so that we can avoid the loop altogether.

```unsigned long long clearlastbit2( unsigned long long value )
{
return (value & (value-1) );
}
```

Ok, if you look at this code it is not immediately apparent what it does - most people would at first sight say "How can that possibly do anything useful?". The easiest way to understand it is to take an example. Suppose we pass the value ten into this function. In binary ten is encoded as 1010b. The first operation is the subtract operation which produces the result of nine, which is encoded as 1001b. We then take the AND of these two to get the result of 1000b or eight. We've cleared the last set bit because the subtract either removed the one bit (if it was set) or broke down the next largest set bit. The AND operation just keeps the bits to the left of the last set bit.

What is interesting about this snippet of code is that it is just three instructions. There's no loop and no branches - so most processors can execute this code very quickly. To demonstrate how much faster this code is, we need a test harness. The test harness should have two parts to it. The first part needs to validate that the new code produces the same result as the existing code. The second part needs to time the old and new code.

```#define COUNT 1000000
void main()
{
// Correctness test
for (unsigned long long i = 0; i<COUNT; i++ )
{
unsigned long long value = i;
while (value)
{
unsigned long long v2 = value;
value = clearlastbit(value);
if (value != clearlastbit2(v2))
{
printf(" Mismatch input %llx: %llx!= %llx\n", v2, value, clearlastbit2(v2));
}
}
}

// Performance test
starttime();
for (unsigned long long i = 0; i<COUNT; i++ )
{
unsigned long long value = i;
while (value) { value = clearlastbit(value); }
}
endtime(COUNT);

starttime();
for (unsigned long long i = 0; i<COUNT; i++ )
{
unsigned long long value = i;
while (value) { value = clearlastbit2(value); }
}
endtime(COUNT);
}
```

The final result is that the bit manipulation version of this code is about 3x faster than the original code - on this workload. Of course one of the interesting things is that the performance does depend on the input values. For example, if there are no set bits, then both codes will run in about the same amount of time.

## Tuesday, January 13, 2015

### Missing semi-colon

Thought I'd highlight this error message:

```class foo
{
foo();
}

foo::foo()
{ }
```
```\$ CC -c c.cpp
"c.cpp", line 6: Error: A constructor may not have a return type specification.
1 Error(s) detected.
```

The problem is that the class definition is not terminated with a semi-colon. It should be:

```class foo
{
foo();
};  // Semi-colon

foo::foo()
{ }
```

## Wednesday, January 7, 2015

### Behaviour of std::list::splice in the 2003 and 2011 C++ standards

There's an interesting corner case in the behaviour of std::list::splice. In the C++98/C++03 standards it is defined such that iterators referring to the spliced element(s) are invalidated. This behaviour changes in the C++11 standard, where iterators remain valid.

The text of the 2003 standard (section 23.2.2.4, p2, p7, p12) describes the splice operation as "destructively" moving elements from one list to another. If one list is spliced into another, then all iterators and references to that list become invalid. If an element is spliced into a list, then any iterators and references to that element become invalid, similarly if a range of elements is spliced then iterators and references to those elements become invalid.

This is changed in the 2011 standard (section 23.3.5.5, p2, p4, p7, p12) where the operation is still described as being destructive, but all the iterators and references to the spliced element(s) remain valid.

The following code demonstrates the problem:

```#include <list>
#include <iostream>

int main()
{
std::list<int> list;
std::list<int>::iterator i;

i=list.begin();
list.insert(i,5);
list.insert(i,10);
list.insert(i,3);
list.insert(i,4); // i points to end
// list contains 5 10 3 4
i--; // i points to 4
i--; // i points to 3
i--; // i points to 10

std::cout << " List contains: ";
for (std::list<int>::iterator l=list.begin(); l!=list.end(); l++)
{
std::cout << " >" << *l << "< ";
}
std::cout << "\n element at i = " << *i << "\n";

std::list<int>::iterator element;
element = list.begin();
element++; // points to 10
element++; // points to 3
std::cout << " element at element = " << *element << "\n";

list.splice(i,list,element); // Swap 10 and 3

std::cout << " List contains :";
for (std::list<int>::iterator l=list.begin(); l!=list.end(); l++)
{
std::cout << " >" << *l << "< ";
}

std::cout << "\n element at element = " << *element << '\n';
std::cout << " element at element = " << *element << '\n';
}
```

When compiled to the 2011 standard the code is expected to work and produce output like:

``` List contains:  >5<  >10<  >3<  >4<
element at i = 10
element at element = 3
List contains : >5<  >3<  >10<  >4<
element at element = 3
element at element = 10
```

However, the behaviour when compiled to the 2003 standard is indeterminate. It might work - if the iterator happens to remain valid, but it could also fail:

``` List contains:  >5<  >10<  >3<  >4<
element at i = 10
element at element = 3
List contains : >5<  >3<  >10<  >4<
element at element = 3
element at element = Segmentation Fault (core dumped)
```

## Tuesday, January 6, 2015

### New articles about Solaris Studio

We've started posting new articles directly into the communities section of the Oracle website. If you're not familiar with this location, it's also where you can post questions on languages or tools.

With the change it should be easier to find articles relevant to developers, and it should be easy to comment on them. So hopefully this works out well. There's currently three articles listed on the content page. I've already posted about the article on the Performance Analyzer Overview screen, so I'll quickly highlight the other two:

• In Studio 12.4 we've introducedfiner control over debug information. This allows you to reduce object file size by excluding debug info that you don't need. There's substantial control, but probably the easiest new option is `-g1` which includes a minimal set debug info.
• A change in Studio 12.4 is in the default way that C++ handles templates. The summary is that the compiler's default mode is inline with the way that other compilers work - you need to include template definitions in the source file being compiled. Previously the compiler would try to find the definitions in external files. This old behaviour could be confusing, so it's good that the default has changed. But it's possible that you may encounter code that was written with the expectation that the Studio compiler behaved in the old way, in this case you'll need to modify the source, or tell the compiler to revert to the older behaviour. Hopefully, most people won't even notice the change, but it's worth knowing the signs in case you encounter a problem.

### The Performance Analyzer Overview screen

A while back I promised a more complete article about the Performance Analyzer Overview screen introduced in Studio 12.4. Well, here it is!

Just to recap, the Overview screen displays a summary of the contents of the experiment. This enables you to pick the appropriate metrics to display, so quickly allows you to find where the time is being spent, and then to use the rest of the tool to drill down into what is taking the time.