Is it possible to me to improve a simple O(n) algorithm with Cilk Plus?

Hi everybody!

I have a simple algorithm to print the very first unique ASCII character from a stream. In the worst case the algorithm scans through the stream twice, doing some comparisons and increments. So, roughly, my algorithm is O(n).

The algorithm⁰ do two main things:

1. It scans all the characters through the stream, counting the number of their occurrences with the help of an array. The character itself is used as the index of this array, since ASCII characters are numbers from 0 to 127 (or 255, if we consider its extended version);
2. After having filled the array that relates the characters in the stream with how many times they have appeared in it, the algorithm scans through the array, again, but this time it checks if the number of occurrence is equal to 1: if it is, then this is the first unique character; if not, it continues the search until the end of the stream is reached.

The first task runs¹ in linear time: a₁n + b₁. So as the second task: a₂n + b₂. Roughly, the whole algorithm runs in a₃n + b₃. Where a₃ = a₁ + a₂, and b₃ = b₁ + b₂.

My idea² is to try to improve its performance by splitting the first task in two using parallelism provided by Cilk Plus: I would have half of my stream being read by one function³ f₁(), and the other half by f₂() at the same time. With this approach, I would expect⁴ the first task to be executed, roughly, in (a₁n + b₁)/2, so that I could improve the overall performance of my algorithm even if it is just a little.

I would like to know if you think it is possible to accomplish that using Cilk Plus. If it is, I just would like to do it even if the speedup was worthless.

Cheers,

Roní.

===========================================================================================================

[0] I have attached my original code just in case I have not been clear enough in the explanation.

[1] I'm just a student and I'm not really experienced with calculating running times... However, I think I am superficially right about those claims.

[2] Again, the idea is simple and superficial. It has no rigor, by now.

[3] These two functions would operate in two different arrays to avoid competition and, then, in the end they would be joined. And I hope the time consumed by the joining the two arrays is small enough to make the splitting feasable.

[4] I know the improvement would be less than 2 because of many other factors. It is just a loose reasoning, I think.