sum. This reducer is built into Cilk++ and Cilk Plus: // Compute ∑ foo(i) for i from 0 to N, in parallel. cilk::reducer_opadd<float> result(0); cilk_for (int i = 0; i < N; i++) result += foo(i); Other reducers can be used to construct linked lists or strings, and programmers can define custom reducers. A limitation of hyperobjects is that they provide only limited determinacy. Burckhardt et al. point out that even the sum reducer can result in non-deterministic behavior, showing a program that may produce either or depending on the scheduling order: void add1(cilk::reducer_opadd<int> &r) { r++; } // ... cilk::reducer_opadd<int> r(0); cilk_spawn add1(r); if (r == 0) { r++; } cilk_sync; output(r.get_value()); Array notation Intel Cilk Plus adds notation to express high-level operations on entire arrays or sections of arrays; e.g., an axpy-style function that is ordinarily written // y ← α x + y void axpy(int n, float alpha, const float *x, float *y) { for (int i = 0; i < n; i++) { y[i] += alpha * x[i]; } } can in Cilk Plus be expressed as y[0:n] += alpha * x[0:n]; This notation helps the compiler to effectively vectorize the application. Intel Cilk Plus allows C/C++ operations to be applied to multiple array elements in parallel, and also provides a set of built-in functions that can be used to perform vectorized shifts, rotates, and reductions. Similar functionality exists in Fortran 90; Cilk Plus differs in that it never allocates temporary arrays, so memory usage is easier to predict. Elemental functions In Cilk Plus, an elemental function is a regular function which can be invoked either on scalar arguments or on array elements in parallel. They are similar to the kernel functions of OpenCL. #pragma simd This pragma gives the compiler permission to vectorize a loop even in cases where auto-vectorization might fail. It is the simplest way to manually apply vectorization. Work-stealing The Cilk scheduler uses a policy called "work-stealing" to divide procedure execution efficiently among multiple processors. Again, it is easiest to understand if we look first at how Cilk code is executed on a single-processor machine. The processor maintains a stack on which it places each frame that it has to suspend in order to handle a procedure call. If it is executing fib(2), and encounters a recursive call to fib(1), it will save fib(2)'s state, including its variables and where the code