StarPU Handbook
|
One of the StarPU developers being a Debian Developer, the packages are well integrated and very uptodate. To see which packages are available, simply type:
$ apt-cache search starpu
To install what you need, type:
$ sudo apt-get install libstarpu-1.1 libstarpu-dev
StarPU can be built and installed by the standard means of the GNU autotools. The following chapter is intended to briefly remind how these tools can be used to install StarPU.
The hwloc
topology discovery library is not mandatory to use StarPU but strongly recommended. It allows for topology aware scheduling, which improves performance. hwloc
is available in major free operating system distributions, and for most operating systems.
If hwloc
is not available on your system, the option --without-hwloc should be explicitely given when calling the configure
script. If hwloc
is installed with a pkg-config
file, no option is required, it will be detected automatically, otherwise --with-hwloc should be used to specify the location of hwloc
.
StarPU's sources can be obtained from the download page of the StarPU website.
All releases and the development tree of StarPU are freely available on INRIA's gforge under the LGPL license. Some releases are available under the BSD license.
The latest release can be downloaded from the INRIA's gforge or directly from the StarPU download page.
The latest nightly snapshot can be downloaded from the StarPU gforge website.
$ wget http://starpu.gforge.inria.fr/testing/starpu-nightly-latest.tar.gz
And finally, current development version is also accessible via svn. It should be used only if you need the very latest changes (i.e. less than a day!). Note that the client side of the software Subversion can be obtained from http://subversion.tigris.org. If you are running on Windows, you will probably prefer to use TortoiseSVN.
$ svn checkout svn://scm.gforge.inria.fr/svn/starpu/trunk StarPU
Running autogen.sh
is not necessary when using the tarball releases of StarPU. If you are using the source code from the svn repository, you first need to generate the configure scripts and the Makefiles. This requires the availability of autoconf
, automake
>= 2.60.
$ ./autogen.sh
You then need to configure StarPU. Details about options that are useful to give to ./configure
are given in Compilation Configuration.
$ ./configure
If configure
does not detect some software or produces errors, please make sure to post the content of config.log
when reporting the issue.
By default, the files produced during the compilation are placed in the source directory. As the compilation generates a lot of files, it is advised to to put them all in a separate directory. It is then easier to cleanup, and this allows to compile several configurations out of the same source tree. For that, simply enter the directory where you want the compilation to produce its files, and invoke the configure
script located in the StarPU source directory.
$ mkdir build $ cd build $ ../configure
By default, StarPU will be installed in /usr/local/bin
, /usr/local/lib
, etc. You can specify an installation prefix other than /usr/local
using the option –prefix
, for instance:
$ ../configure --prefix=$HOME/starpu
$ make
Once everything is built, you may want to test the result. An extensive set of regression tests is provided with StarPU. Running the tests is done by calling make check
. These tests are run every night and the result from the main profile is publicly available.
$ make check
In order to install StarPU at the location that was specified during configuration:
$ make install
Libtool interface versioning information are included in libraries names (libstarpu-1.1.so
, libstarpumpi-1.1.so
and libstarpufft-1.1.so
).
StarPU provides a pkg-config executable to obtain relevant compiler and linker flags. Compiling and linking an application against StarPU may require to use specific flags or libraries (for instance CUDA
or libspe2
). To this end, it is possible to use the tool pkg-config
.
If StarPU was not installed at some standard location, the path of StarPU's library must be specified in the environment variable PKG_CONFIG_PATH
so that pkg-config
can find it. For example if StarPU was installed in $prefix_dir
:
$ PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$prefix_dir/lib/pkgconfig
The flags required to compile or link against StarPU are then accessible with the following commands:
$ pkg-config --cflags starpu-1.1 # options for the compiler $ pkg-config --libs starpu-1.1 # options for the linker
Note that it is still possible to use the API provided in the version 0.9 of StarPU by calling pkg-config
with the libstarpu
package. Similar packages are provided for libstarpumpi
and libstarpufft
.
Make sure that pkg-config –libs starpu-1.1
actually produces some output before going further: PKG_CONFIG_PATH
has to point to the place where starpu-1.1.pc
was installed during make install
.
Also pass the option –static
if the application is to be linked statically.
It is also necessary to set the environment variable LD_LIBRARY_PATH
to locate dynamic libraries at runtime.
$ LD_LIBRARY_PATH=$prefix_dir/lib:$LD_LIBRARY_PATH
When using a Makefile, the following lines can be added to set the options for the compiler and the linker:
CFLAGS += $$(pkg-config --cflags starpu-1.1) LDFLAGS += $$(pkg-config --libs starpu-1.1)
Basic examples using StarPU are built in the directory examples/basic_examples/
(and installed in $prefix_dir/lib/starpu/examples/
). You can for example run the example vector_scal
.
$ ./examples/basic_examples/vector_scal BEFORE: First element was 1.000000 AFTER: First element is 3.140000
When StarPU is used for the first time, the directory $STARPU_HOME/.starpu/
is created, performance models will be stored in that directory (STARPU_HOME).
Please note that buses are benchmarked when StarPU is launched for the first time. This may take a few minutes, or less if hwloc
is installed. This step is done only once per user and per machine.
StarPU automatically binds one thread per CPU core. It does not use SMT/hyperthreading because kernels are usually already optimized for using a full core, and using hyperthreading would make kernel calibration rather random.
Since driving GPUs is a CPU-consuming task, StarPU dedicates one core per GPU.
While StarPU tasks are executing, the application is not supposed to do computations in the threads it starts itself, tasks should be used instead.
TODO: add a StarPU function to bind an application thread (e.g. the main thread) to a dedicated core (and thus disable the corresponding StarPU CPU worker).
When both CUDA and OpenCL drivers are enabled, StarPU will launch an OpenCL worker for NVIDIA GPUs only if CUDA is not already running on them. This design choice was necessary as OpenCL and CUDA can not run at the same time on the same NVIDIA GPU, as there is currently no interoperability between them.
To enable OpenCL, you need either to disable CUDA when configuring StarPU:
$ ./configure --disable-cuda
or when running applications:
$ STARPU_NCUDA=0 ./application
OpenCL will automatically be started on any device not yet used by CUDA. So on a machine running 4 GPUS, it is therefore possible to enable CUDA on 2 devices, and OpenCL on the 2 other devices by doing so:
$ STARPU_NCUDA=2 ./application
Some interesting benchmarks are installed among examples in $prefix_dir/lib/starpu/examples/
. Make sure to try various schedulers, for instance STARPU_SCHED=dmda
.
This benchmark gives a glimpse into how long a task should be (in µs) for StarPU overhead to be low enough to keep efficiency. Run tasks_size_overhead.sh
, it will generate a plot of the speedup of tasks of various sizes, depending on the number of CPUs being used.
local_pingpong
performs a ping-pong between the first two CUDA nodes, and prints the measured latency.
sgemm
and dgemm
perform a blocked matrix-matrix multiplication using BLAS and cuBLAS. They output the obtained GFlops.
cholesky_*
perform a Cholesky factorization (single precision). They use different dependency primitives.
lu_*
perform an LU factorization. They use different dependency primitives.