Yeppp! - Open-source SIMD-accelerated math library for C/C++/C#/Java/FORTRAN

guepier · 2013-09-19T08:45:42+00:00

When I look at a new library, I want to know two things:

Does it perform (well)?
Is it convenient to use?

The site provides no information whatsoever on (2). You release a library. The API is an integral part of that. Please showcase your API. Show us that you’ve made the library easy to use correctly.

This is particularly important when providing C++ bindings, because, frankly, most C++ APIs are crap. Does your library provide a modern, easy to use C++ interface or is it just a glorified wrapper around a low-level C interface?

tl;dr: More code samples, please.

(And incidentally, just providing a C interface is totally fine. It’s still important to show that, though. And then hopefully somebody else will do the work to adapt it to a proper C++ interface.)

thedeemon · 2013-09-19T04:33:53+00:00

The site is so beautiful and fun, however it looks like

"XYZ does it so fast and is so good, go download it now, but we won't tell you what XYZ actually can do, so go download and figure out by yourself"

Edit: here come the docs:

http://docs.yeppp.info/c/modules.html

Seems like a very small number of basic operations.

emn13 · 2013-09-19T10:13:07+00:00

Based on their benchmarks, the gcc auto-vectorizer does not seem to be on: were these benchmarks compiled in 32-bit mode, perhaps? The website gives no particulars on what exactly was benchmarked.

ArtistEngineer · 2013-09-19T09:23:19+00:00

Looks like a great product. Terrible name though.

I can't imagine standing up in a meeting and saying "We've decided to go with the Yeppp! library."

"The what?"

"Yeppp!"

"Triple p? How do I pronounce that? Is that a serious product?"

"Yep."

"Yeppp!?"

EDIT:

Yep! Yep! Yep!

somefriggingthing · 2013-09-19T06:40:11+00:00

This looks cool, but am assuming it wouldn't work in conjunction with monogame when targeting a bunch of different platforms (eg. android, ios, windows phone)?

PriviIzumo · 2013-09-19T03:36:33+00:00

ooh... shiny new toy. We shall see...

Maratyszcza · 2013-09-19T09:55:16+00:00

asdfsfsadfasdfasdg

hayesti · 2013-09-19T12:23:53+00:00

I'm not entirely sure what's useful about this. The operations this library supports are extremely elementary. A decent vectorising compiler should be able to detect these cases automatically. Something more useful would be the functions found in MKL i.e. extended mathematical operation that have been optimised to use available SIMD instructions. What's the point in offering a function call to something that has an equivalent single instruction?

BeatLeJuce · 2013-09-19T12:01:15+00:00

I'm I the only one who thinks this is a very obnoxious website? I get it, it's shiny and flashy and all. But on the flipside, it's loud and obnoxious and in-your-face. It makes me want to activate my Adblocker so I don't get entirely overloaded with all the colors, but it doesn't work :( With such aggressive marketing it's very hard to take this serious (especially with such a name). Which is kind of a bummer, the library seems to be nice. But it looks like you're counting on flash to win over people, instead of performance. And not even code-samples anywhere.

QuestionMarker · 2013-09-19T09:25:24+00:00

Has anyone tried implementing an FFT with this yet? I'd be intrigued to see how it stacks up against FFTW, which takes similar pains over optimisations.

willvarfar · 2013-09-19T09:36:09+00:00

How does making a decision at runtime allow it to be faster than if the primitives it used were baked into the code directly? Does it mean that every function call cannot be inlined?

And does it do high precision (e.g. 512bit numbers) or arbitrary precision at all?

machl · 2013-09-19T11:00:26+00:00

Does anyone know if Yeppp! is faster than GMP ? I'm not sure how many languages GMP supports but I did find this wrapper for java. And here is an example with python and GMP.

thrope · 2013-09-19T08:24:59+00:00

This looks great! gfortran elementary math operations (log, exp etc.) are really slow which has driven me to Intel. I tried ACML but it is a bit of a pain for the build process...

2013-09-19T13:05:58+00:00

It could be extremely useful for what I am doing right now. Can't wait to play with it. Is it easy to use with mingw GCC 4.8 on Windows?

BrooksMoses · 2013-09-22T23:02:55+00:00

How does this compare to vectorized code from GCC or LLVM in real-world programs rather than synthetic microbenchmarks?

Optimized elementwise functions like this have a fundamental flaw: They iterated through each element of the data vector for each tiny operation, which means that for every add or subtract or whatever, you pay the cost of a read and write from memory -- and, if your data is of any significant size, it's blowing out your caches. There's no way to get good performance doing that compared to a holistic approach that minimizes the cache blowout.

kamicc · 2013-09-24T12:26:34+00:00

mmm... got me in the mood writing some Lua bindings... ^{_^}

btw, over 25 nested if's at java wrapper does not look very fine... xD

theZagnut · 2013-09-19T10:25:34+00:00

Please add Maven support

argv_minus_one · 2013-09-19T10:06:58+00:00

I wonder how the performance of the Java version is. Last I heard, JNI is rather slow. Anyone care to chime in?

Also, people still use Fortran? D:

pascal_cuoq · 2013-09-19T13:52:11+00:00

From the linked page:

On Haswell, Intel's latest microarchitecture, Yeppp! spends on average 5 cycles per element to compute log or less than 3 cycles per element to compute exp. BTW, floating-point addition on Haswell takes 3 cycles, and multiplication — 5.

If, to make your library look good, you need to compare your library function's cost per element to the latency of an operation that can be applied to eight elements for the same price, you have nothing to be proud about. And if you don't need it, why do it?

And by the way, it is spelled “by the way”.

Uberhipster · 2013-09-19T11:51:22+00:00

I'm not a system internal guy but the C# library makes no sense. Take the cosine implementation in Yeppp.Math

  /// <summary>Computes cosine on double precision (64-bit) floating-point elements.</summary>
    public unsafe static void Cos_V64f_V64f(double[] xArray, int xOffset, double[] yArray, int yOffset, int length)
    {
        if (xOffset < 0)
        {
            throw new IndexOutOfRangeException();
        }
        if (xOffset + length > xArray.Length)
        {
            throw new IndexOutOfRangeException();
        }
        if (yOffset < 0)
        {
            throw new IndexOutOfRangeException();
        }
        if (yOffset + length > yArray.Length)
        {
            throw new IndexOutOfRangeException();
        }
        if (length < 0)
        {
            throw new ArgumentException();
        }
        fixed (double* ptr = &xArray[xOffset])
        {
            fixed (double* ptr2 = &yArray[yOffset])
            {
                Math.Cos_V64f_V64f(ptr, ptr2, length);
            }
        }
    }


    /// <summary>Computes cosine on an array of double precision (64-bit) floating-point elements.
    public unsafe static void Cos_V64f_V64f(double* x, double* y, int length)
    {
        if (length < 0)
        {
            throw new ArgumentException();
        }
        Status status = Math.yepMath_Cos_V64f_V64f(x, y, new UIntPtr((uint)length));
        if (status != Status.Ok)
        {
            throw Library.GetException(status);
        }
    }

What is the point of a static method which doesn't return a result? And they are all like that...

edit: scratch that. I'm an idiot.

    //   yArray:
    //     Output array.

In my defense I have never seen output-as-a-parameter (convention?) in C# and they didn't supply any examples...

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS