DEV Community

5 (Extreme) Performance Tips in C# 🔥

ByteHide on September 09, 2021

This article is transcribed from Bartosz Adamczewski’s video on LevelUp’s Youtube channel about 5 (Extreme) Performance Tips in C#. This transcrip...

Read full post

Comment hidden by post author - thread only accessible via permalink

Bartosz Adamczewski • Sep 11 '21

This article is copied wholesale from my youtube video: youtube.com/watch?v=Tb2Fx9qku_o

If you're going to copy all of the things 1to1, then at least you should credit the author.

Ken Rogoway • Sep 10 '21

Overall a good article, but the example code has a lot of bugs. So it is hard to know if what is shown was used for your performance tests. If it was then your speed improvements may have more to do with optimizations for invariants. For instance in #3 you add to “counter”, but return the sum of counterA and counterB which are both zero. Similar issue in #4, and it also uses the wrong value for the B portion (you’re using p[0] for both A and B sums.

Denis Vlah • Sep 11 '21

Found how to eliminate multiplication. It makes the code just a little bit faster compared to SumOdd_BranchFree but this technique performs worse than multiplication methods with parallel execution.
The code is the following:

private static int SumOdd_BranchFree_NoMultiply(int[] array)
        {
            int mask = -1; // in binary format is 11111111111111111111111111111111
            int counter = 0;
            for (int i = 0; i < array.Length; i++)
            {
                var element = array[i];
                var odd = element & 1;
                var elementMask = ~(mask + odd); // will cause int overflow if odd == 1 
                counter += (element & elementMask);
            }
            return counter;
        }

cantak • Sep 10 '21 • Edited

Here's one more option to consider. It's twice as fast as the best one above and uses the bitwise step in actual parallel processing. It probably could have further optimizations from above incorporated into it also. With this you'd call ParallelLoop(array, numberOfTasksYouWantForYourMachine).

Also, I had never thought of bit checking before and have always used mod. I will certainly use this in the future. Nice article!

private static long AddViaGap(long[] array, int gap, int offset) {
long counter = 0;
for (int i = offset; i < array.Length; i += gap) {
var element = array[i];
var odd = element & 1;
counter += (odd * element);
}
return counter;
}

private static long ParallelLoop(long[] array, int taskCount) {
var tasks = new Task[taskCount];
for (var counter = 0; counter < taskCount; counter++) {
var currentCounter = counter;
tasks[counter] = Task.Run(() => AddViaGap(array, taskCount, currentCounter));
}
Task.WaitAll(tasks);
return tasks.Sum(o => o.Result);
}

rosskillen • Sep 10 '21

Good tips, thanks. Not strong on C# myself but surely you've introduced a bug at stage 3, e.g. if your array has an odd length? I.e. elementB won't exist.