undefined | Better HN

0 pointsraiph8y ago0 comments

i.e. SIMD i.e. something like:

    @array = 1, 2 ... 1,000,000 ;
    @array>>++ ;

where the `>>++` operation increments each of a million integers with the workload distributed across multiple real CPUs?

0 comments

2 comments · 1 top-level

joosters8y ago· 1 in thread

Yes, or perhaps more generally, any loop where the compiler/runtime can infer that each iteration of the loop is independent of the others, and so they could theoretically run on multiple cores.

It's SIMD, exactly as you say, but potentially on much larger blocks of code than single arithmetic operations. A compiler that can pick where to use SIMD is doing the same kind of analysis. The difficulty in doing it at compile time is knowing whether or not it will be worth the cost.

In your example, the compiler could see that the array has a million entries and so spreading the work across threads might be a win. But in general, the compiler probably can't tell roughly how many iterations a loop is going to have, so it doesn't know where to thread and where not to.

raiphOP8y ago

Right.

In P6 (potential) parallelism is explicit. You have to use an explicit construct such as the `<<` or `>>` meta operators.

I used a simple arithmetic operation but it can be any code. Of course, it had better be parallel safe.

The code-gen at compile time makes an AOT call on whether to attempt parallelization. If the JIT thinks that's not working out during a particular run it may decide to de-optimize.

> more generally, any loop where ... each iteration of the loop is independent of the others

Right. The `<<` and `>>` meta operators aren't the only relevant features. For example there's a `.race` method that not only (potentially) parallelizes a map, grep or whatever, but provides further explicit control such as batching size.

j / k navigate · click thread line to collapse