Issue #14328 has been updated by ahorek (Pavel Rosick).


@naruse I saw your blank implementation, impressive
https://github.com/ruby/ruby/commit/e6bc209abf81d53c2e3374dc52c2a128570c6055

the complexity for a hand written simd code is probably too high. Ruby supports a lot of platforms, so we have to duplicate the code (compatibility paths) or make a portable interface for it.

here's also an interesting implementation of "strip" method
https://github.com/lemire/despacer

I don't like the idea of exposing simd types like NArray to the developer, but some languages did it this way (like Dart)

The best solution is to teach JIT how to vertorize at least basic loops like
```
for (int i = 0; i < N; ++i)
  A[i] = B[i] + C[i];

->

for (int i = 0; i < N/8; ++i)
  VECTOR_ADD(A + i, B + i, C + i);
```
unfortunatelly it's not always as simple as this example

----------------------------------------
Feature #14328: SIMD vectorization
https://bugs.ruby-lang.org/issues/14328#change-72966

* Author: ahorek (Pavel Rosick)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Hello,
in order to make ruby faster, I'd like to propose an optional SIMD optimization for some cases. I want to target SSE2 which is available in all modern x86 processors. (Pentium 4, Athlon 64 and newer).

this is usually automatically handled by GCC during compilation time, but because of dynamic nature of ruby, redefinitions etc. It's very hard to preoptimize it before the actual execution.

## use auto-vectorization provided by JIT ( https://bugs.ruby-lang.org/issues/12589 )
```
GCC can do that, but I'm not sure how reliable and effective it is today

Pros:
we don't have to do anything, let GCC do the job
bigger scope for optimizations

Cons:
slower compilation
```
* gcc docs:
* https://gcc.gnu.org/projects/tree-ssa/vectorization.html

* pypy has this feature implemented for some time now:
* https://morepypy.blogspot.cz/2015/10/pypy-400-released-jit-with-simd.html


## specialize known bottlenecks by hand
```
Pros:
predictable performace
without increased compilation time

Cons:
code complexity
```

unfortunatelly using SIMD isn't for free, there's an overhead, it needs a large data set to be effective. It's useful mainly for math operations, sum, min, max, arrays, matrixes, string manipulations etc. There probably won't be any significant benefit for appliactions like Rails.

what do you think about it?



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>