[rfs02]

Very late to the game at this point.

With inspiration from the previous replies (and using both Parallel and unsafe)

Spoiler

        static unsafe int CountCharactersOptimized(string str, char c)
        {
            int partitions = 100;
            int partitionSize = str.Length / partitions;
            int total = 0;

            fixed (char* psz = str)
            {
                char* start = psz;
                Parallel.For<int>(0, partitions, () => 0, (i, loop, subtotal) =>
                {
                    char* low = start + i * partitionSize;
                    int len = partitionSize / 2;

                    while (len-- > 0)
                    {
                        if (*low++ == c) subtotal++;
                        if (*low++ == c) subtotal++;
                    }

                    return subtotal;
                }, (x) => Interlocked.Add(ref total, x));
            }
            return total;
        }

[Skydiver]

Won't that code miss some characters if the string length cannot be evenly divided by the number of partitions?

This post has been edited by Skydiver: 01 October 2012 - 08:36 AM

[Momerath]

The challenge requires strings of 10,000 characters. Yes, it's optimized specifically for this challenge, but that's the challenge

[CasiOo]

Momerath, on 01 October 2012 - 04:55 PM, said:

The challenge requires strings of 10,000 characters. Yes, it's optimized specifically for this challenge, but that's the challenge

I think you should change the stride of your example to str.Length / Enviroment.ProcessorCount, that would prevent the need to start many unnecessary threads while still making every thread work 100%

[rfs02]

CasiOo, on 01 October 2012 - 12:42 PM, said:

Momerath, on 01 October 2012 - 04:55 PM, said:

The challenge requires strings of 10,000 characters. Yes, it's optimized specifically for this challenge, but that's the challenge

I think you should change the stride of your example to str.Length / Enviroment.ProcessorCount, that would prevent the need to start many unnecessary threads while still making every thread work 100%

Agreed, you just need to make sure 10,000 is divisible by your number of processors. I did test it and it is about 5-10% faster than running with 100 threads.

[Skydiver]

Momerath, on 01 October 2012 - 09:55 AM, said:

The challenge requires strings of 10,000 characters. Yes, it's optimized specifically for this challenge, but that's the challenge

Not quite. Quoting from the OP:

Quote

The Challenge
In this challenge you have to optimize a very basic method which is called ten thousand times. The method counts how many times one character appears in a string.

It's the function call that maybe called 10,000 times according to the challenge. It just happened that the test string was a 10,000 random character string, but the string could easily have been a 100 character string or a 123456 character string.