Comments on: What I learned from my first c coding challenge

By: Rubén Romero

Rubén Romero — Wed, 19 Sep 2012 21:21:52 +0000

Maybe the Varnish Modules overview should be updated now that you have a winner?

And… Congrats to the winnng code: https://github.com/vimeo/libvmod-boltsor

By: Dieter

Dieter — Tue, 18 Sep 2012 12:21:27 +0000

Great writeup Jason, hope to join in next time!
I don’t quite understand the “Testing for zero” part. So, if I understand correctly, these are the two approaches:
A) given number X, subtract numbers y1, y2, …y5 to arrive at Y, then check whether Y == 0
B) check whether X == Y (with Y already given, and equaling y1+y2+ … +y5)
(5 is an example and denotes amount of loop iterations)

you’re saying A is faster? this is weird because it has 5 subtractions and a comparision to 0.
B compares two arbitrary ints, and if that is so slow, the compiler could turn it into one subtraction and comparison to 0: (X-Y) == 0

By: Gordon

Gordon — Sat, 15 Sep 2012 18:03:07 +0000

Perhaps this could help you get a few more obscure optimizations?
http://graphics.stanford.edu/~seander/bithacks.html

By: sv

sv — Fri, 14 Sep 2012 16:51:46 +0000

I think a lot of what you ran into is cases where the optimizations you thought would work only work when dealing with things on a larger scale, e.g. the url’s involve only had a handful of query parameters. If there were thousands of parameters involved, qsort would have kicked your insertion sort’s butt.

And loop unrolling is most effective when what is done what is done in the loop is trivial compared to the loop overhead and when you don’t introduce any additional branching.

By: Dan Sutton

Dan Sutton — Fri, 14 Sep 2012 16:15:17 +0000

Interesting. Just for the sake of it, here it is in C#: .Net gives us a few things which come in handy… I know all you C purists are going to get at me for not writing my own code but using the built-in .Net stuff instead… however, it works: the point here is that sometimes C just isn’t the right language if you want a decent development time:

private string Format(string Url)
{
string[] Sects = Url.Split(‘?’);
try
{
string[] Parms = Sects[1].Split(‘&’);
Array.Sort(Parms);
return Sects[0] + ‘?’ + String.Join(“&”, Parms);
}
catch { return Url; }
}

By: indrora

indrora — Fri, 14 Sep 2012 15:43:12 +0000

On the topic of optimizations, I’ve seen some evil things done by compilers. The problem is that Loop unrolling causes great performance on x86 (since it uses nothing but a program counter and some memory for what its worth) but the entire point of loop unrolling becomes blown apart on the world of ARM.

Why? because ARM likes small code sizes. Its actually optimized for small code sizes, as it uses a L1 cache that tries to look-ahead just a bit. GCC will add bust-out lines in unrolled loops so that if something happens (e.g. you increment by too much) it can bail. Duff’s Devices are cool and all, but they still fail on devices like ARM.

I found this out while writing a CRC (I know, its CRC) algorithm for an ARM chip I’m working with.

By: lol

lol — Wed, 05 Sep 2012 09:59:07 +0000

How do you do the benchmark timing? Have you excluded the I/O time? It seems you are using stdio with a small buffer, which takes quite some time.

By: Edwin Martin

Edwin Martin — Wed, 05 Sep 2012 08:49:43 +0000

I think the loop unrolling has no effect is not due to better compiler optimizations, but better processors. Processors use branche prediction and know to jump to the top of the loop instead of the next instruction below.

By: Wayne

Wayne — Wed, 05 Sep 2012 01:31:40 +0000

Interesting work.

I am not sure about the compiler and platform for test. If it is gcc, the “likely” macro might help with branch predictor. But I haven’t profiled it personally.

Example from :

const char *home;

home = getenv (“HOME”);
if (likely (home))
printf (“Your home directory is %s\n”, home);
else
fprintf (stderr, “Environment variable HOME not set!\n”);

By: Nico

Nico — Tue, 04 Sep 2012 22:34:53 +0000

I know sorting was the challenge, but knowing what it’s going to be used for, is it really necessary to sort it? Maybe you could have a hash function such that hash(“b=b&c=bb&a=3&a=4″) == hash(“a=3&a=4&b=b&c=bb”). I guess that’s exactly what sorting does, but I wonder if there might be faster functions that have the same property, without necessarily having to sort.