Get your copy: http://multicorebsp.com/downloads/c/2.0 … r-C.tar.xz

The quick-start guide has had an overhaul to correspond to the new v2 series of MulticoreBSP. Check it out: http://multicorebsp.com/documentation/quickC/

New features:

• checkpointing support,

• initial support for accelerators,

• improved pinning support for hyperthreaded machines,

• speed improvements,

• machine benchmarking suite and more example codes,

• flexible APIs (no more need to recompile for compatibility mode),

• new compilation modes: debug and profiling.

Objects compiled in various modes can be mixed freely-- that is, if you suspect a bug in one part of a large project, only the suspect part can be compiled in debug mode. That way full error checking (and corresponding overheads) are only incurred on the suspect code. The same is true for profiling or compatibility codes, altough the former has minor caveats (see the changelog).

No distributed-memory support was added. Multi-BSP programming is available separately. See http://multicorebsp.com/download/c/ for full details.

It is my pleasure to announce the third update to the MulticoreBSP for C library. Version 1.2 brings improved pinning support for nested BSP runs, which benefits code explicitly following the Multi-BSP model (as opposed to flat BSP). C++ support has been extended by the addition of templated BSPlib primitives, which provides escape from having to deal explicitly with byte sizes and byte offsets.
Smaller improvements consider documentation, internal data structures, and compilation support; the latter now include release-testing using the clang LLVM compiler, next to GCC and the Intel C++ Compiler. Several bugs from version 1.1.0 have been resolved as well; I like to thank Jing Fan and Joshua Moerman for reporting some of these. As always, the changelog contains more details.

Version 1.2.0 can be downloaded from the following URL: http://multicorebsp.com/download/c/

Roadmap

Version 1.3:
Explicitly writing parallel programs using the Multi-BSP model can be done using nested SPMD sections in MulticoreBSP for C. This is not a straightforward effort, and can easily lead to codes written for specific architectures. This hurts portability, reduces productivity, and negatively affects the ease of use BSP libraries are otherwise commonly known for. It is also at odds with the intention of (Multi-)BSP as an abstract bridging model.
To enable the implementation of Multi-BSP codes such that the produced codes are (1) valid for all Multi-BSP computers, (2) clearly and transparently structured, and (3) compatible with existing BSPlib code fragments, version 1.3 will support C++ extensions allowing for explicit Multi-BSP programming.

Version 2.0:
Many have requested that MulticoreBSP for C be deployable over distributed-memory architectures. The original plan was to handle this problem simultaneously with the addition of automatic global barrier avoidance, pipelined communication, and fault-tolerance. It remains, however, unclear in what time-frame I will be able to address these important issues. From version 2.0 on, I will hence first make MulticoreBSP for C a fully hybrid systems, such that any BSP program automatically uses MPI for inter-node process coordination, while using PThreads for intra-node threading. These extensions will remain adhering to the updated BSPlib standard as published with the introduction of MulticoreBSP for C; in particular, nested BSP runs will remain possible, which in turn allows the Multi-BSP C++ extensions that will be introduced in Version 1.3 to be deployable over any MPI-supporting cluster or supercomputer.
A secondary target is to not interfere with existing threading and parallel programming interfaces; advanced users of version 2.0 of MulticoreBSP for C will be able to mix their (Multi-)BSP codes with any existing MPI, OpenMP, or Cilk Plus codes that they may already have.

• A new BSP primitive: the bsp_hpsend,

• Improved communication speed,

• Improved synchronisation speed (on machines with a large number of cores),

• New possibilities for advanced control of thread affinities as required on NUMA architectures,

• Compilation support for Windows;

• ... and see the changelog for other new additions and bugfixes!

This release accompanies a new introductory paper to MulticoreBSP for C, which describes the BSP model, defines the updated BSPlib interface, and presents two BSP applications with performance evaluations on machines with highly non-uniform memory access (NUMA):

A. N. Yzelman, R. H. Bisseling, D. Roose, and K. Meerbergen, MulticoreBSP for C: a high-performance library for shared-memory parallel programming, technical report TW624, KU Leuven, 2013 (submitted for publication).

Version 1.1 of MulticoreBSP for C is ready for download, and the corresponding documentation has been updated. As always, we welcome your feedback, and wish you many pleasant BSP programming sessions!

See the changelog for more details (and on other changes), and pick up the new version here.

The library is completely compatible with existing BSP codes based on the Oxford BSP library (BSPlib) when MulticoreBSP for C is used in compatibility mode. In normal operation, it updates the BSPlib standard. In both cases it implements the new MulticoreBSP bsp_direct_get primitive. All communication primitives work directly on raw memory regions, instead of taking an object-oriented approach as with MulticoreBSP for Java; initial experiments show a great increase in efficiency of computationally intensive codes. An upcoming paper will thoroughly describe the updates of the BSPlib standard, and will feature an in-depth performance comparison for various applications from scientific computing. The updated MulticoreBSP.com website features a guide on how to quickly get started with this new library.

MulticoreBSP for C is written in ANSI C'99, further relying on the POSIX Threads and POSIX realtime extensions only, and has tested successfully under GCC 4.4 and the Intel C++ Compiler 12.1. This included running unit tests available with the library, as well as successfully compiling & running the original C-based BSP educational package.

This release is made possible with support from KU Leuven and the Flanders ExaScience Laboratory, Intel Labs Europe, and heavily relies on earlier research done at Utrecht University.

and

An adapted version for use with MulticoreBSP for Java is used to asses the use of the BSP model on shared-memory architectures; a paper detailing this is forthcoming. This adapted BSPedupack for Java is now released as well.