SLEEF Documentation - Other tools included in the package

Table of contents

Libm tester

SLEEF libm has two kinds of testers, and each kind of testers has its own role.

The first kind of testers consist of a tester and an IUT (which stands for Implementation Under Test.) Those two are built as separate executables, and communicate with each other using a pipe. The role for this tester is to perform a perfunctory set of tests to check if the build is correct. It is also performs regression tests. Since the tester executable and the iut executable are separated, the iut can be implemented with an exotic languages. It is also possible to perform a test over the network.

The second kind of testers are designed to run continuously. It repeats randomly generating arguments for each function, and comparing the results of each function to the results calculated with the corresponding function in libmpfr. This tester is expected to find bugs if it is run for sufficiently long time.

DFT tester

SLEEF DFT has three kinds of testers. The first ones, named naivetest, compare the results computed by SLEEF DFT with that from a naive DFT implementation. These testers cannot be built with MSVC since complex data types are not supported. The second testers, named fftwtest, compare the results of computation between SLEEF DFT and FFTW. Rigorous testing is possible with the second testers, but obviously it requires FFTW to run. The third testers, named roundtriptest, executes a forward transform followed by a backward transform. Then, it compares the results with the original data. An advantage of the third testers is that it does not require external library and it runs on all environment, but there could be many cases that this testing does not find flaw. The third testers are used only if FFTW is not available.


Gencoef is a small tool for generating the coefficients for polynomial approximation used in the kernels.

In order to change the configurations, please edit gencoefdp.c. In the beginning of the file, specifications of the parameters for generating coefficients are listed. Enable one of them by changing #if. Then, run make to compile the source code. Run the gencoef, and it will show the generated coefficients in a few minutes. It may take longer time depending on the settings.

There are two phases of the program. The first phase is the regression for minimizing the maximum relative error. This problem can be reduced to a linear programming problem, and the Simplex method is used in this implementation. This requires multi-precision calculation, and the implementation uses the MPFR library to do this. In this phase, it uses only a small number of values (specified by macro S, usually less than 100) within the input domain of the kernel function to approximate the function. The function to approximate is given by FRFUNC function. Specifying higher values for S does not always give better results.

The second phase is to optimize the coefficients so that it gives good accuracy with double precision calculation. In this phase, it checks 10000 points (specified by macro Q) within the specified argument range to see if the polynomial gives good error bounds. In some cases, the last few terms have to be calculated in higher precision in order to achieve 1 ULP or less overall accuracy, and this implementation can take care of that. The L parameter specifies the number of high precision coefficients.

In some cases, it is desirable to fix the last few coefficients to values like 1 or 0.5. This can be specified if you define FIXCOEF0 macro.

Finding a set of good parameters is not a straightforward process.

Benchmarking tool

SLEEF has a tool for measuring and plotting execution time of each function in the library. It consists of an executable for measurements, a makefile for driving measurement and plotting, and a couple of scripts.

In order to start a measurement, you need to first build the executable for measurement. CMake builds the executable along with the library. Please refer to compiling and installing the library for this.

Then, change directory to sleef-3.X/src/libm-benchmarks/. You also need to set the build directory to BUILDDIR environment variable.

$ export BUILDDIR=$PATH:`pwd`/../../build

Type "make measure". After compiling the tools, it will prompt a label for measurement. After you input a label, measurement begins. After a measurement finishes, you can repeat measurements under different configurations. If you want to measure on a different computer, please copy the entire directory on to that computer and continue measurements. If you have Intel Compiler installed on your computer, you can type "make measureSVML" to measure the computation time of SVML functions.

$ make measure
./ benchsleef
Enter label of measurement(e.g. My desktop PC) : Skylake
Measurement in progress. This may take several minutes.

Now, you can plot the results of measurement by 'make plot'.
You can do another measurement by 'make measure'.
You can start over by 'make restart'.

$ make plot
java ProcessData *dptrig*.out
gnuplot script.out
mv output.png trigdp.png
java ProcessData *dpnontrig*.out
gnuplot script.out
mv output.png nontrigdp.png
java ProcessData *sptrig*.out
gnuplot script.out
mv output.png trigsp.png
java ProcessData *spnontrig*.out
gnuplot script.out
mv output.png nontrigsp.png
$ █

Then type "make plot" to generate graphs. You need to have JDK and gnuplot installed on your computer. Four graphs are generated : trigdp.png, nontrigdp.png, trigsp.png and nontrigsp.png. Please see our benchmark results for an example of generated graphs by this tool.