HPX V0.9.0: Release Notes

File MD5 Hash
zip (5.1M) c9a3164259d509572227ea44c0658d7a
gz (3.7M) 9a08cccc1148c1fd22193118a577e059
bz2 (2.9M) 12ad24cdc9181c3a79131d47bf12ed22
7z (2.7M) 3f89c7160064da632761328692c0b600

If you would like to access the code, please clone the git repository here: http://github.com/STEllAR-GROUP/hpx. Please refer to the file README.rst in the root directory inside the downloaded archives or to the documentation for more information about how to get started.

Bug reports via email (gopx@cct.lsu.edu) are welcome. No further releases in
the 0.9.0 series are planned at this time but point releases will be made if
needed.

We have had roughly 500 commits since the last release, closed approximately 80 tickets (bugs, feature requests, etc.).

Major Features

  • Significant improvements made to the usability of HPX in large-scale, distributed environments.
  • Made a lot of API changes aligning the HPX threading API with the corresponding API┬ádefined by the C++11 Standard (hpx::thread, hpx::future, hpx::promise, etc.)
  • Added support for sequential and logic composition of hpx::future's. The member function hpx::lcos::future::when() allows to sequentially compose futures, while the helper functions hpx::wait_all, hpx::wait_any, and hpx::wait_n can be used to wait for more than one future at a time.
  • HPX now exposes hpx::apply() and hpx::async() as the preferred way of creating (or invoking) any deferred work. These functions are usable with various types of functions, function objects, and actions and provide a uniform way to spawn deferred tasks. Actions can now be invoked using hpx::apply(), hpx::async(), or using the operator() implemented on actions. Actions themselves can now be cheaply instantiated as they do not have any members anymore.
  • HPX now allows to utilize hpx::util::bind to (partially) bind not only local functions and function objects, but also actions. Remote bound actions can have placeholders as well. Reworked the lazy action invocation API. Actions can now be directly bound using hpx::util::bind() by passing an action instance as the first argument.
  • HPX continuations are now fully polymorphic.
  • HPX threads support now cancellation.
  • Added performance counters exposing the number of component instances which are alive on a given locality and new counters exposing the number of messages sent and received, the number of parcels sent and received, the number of bytes sent and received, the overall time required to send and receive data, and the overall time required to serialize and deserialize the data.
  • Added a new component: hpx::components::binpacking_factory which is equivalent to the existing hpx::components::distributing_factory component, except that it equalizes the overall population of the components to create. It exposes two factory methods, one based on the number of existing instances of the component type to create, and one based on an arbitrary performance counter which will be queried for all relevant localities.

Included Applications

  • Graph500 performance benchmark.
  • GTC (Gyrokinetic Toroidal Code): a skeleton for particle in cell type codes.
  • Random Memory Access: an example demonstrating random memory accesses in a large array.
  • ShenEOS example, demonstrating partitioning of large read-only data structures and exposing an interpolation API.
  • Sine performance counter demo.
  • Accumulator examples demonstrating how to write and use HPX components.
  • Quickstart examples (like hello_world, fibonacci, quicksort, factorial, etc.) demonstrating simple HPX concepts which introduce some of the concepts in HPX.
  • Load balancing and work stealing demos.
  • Async I/O example demonstrating how to integrate HPX code with external asynchronous operations.
  • An example demonstrating how to implement action cancellation.

Bug Fixes (Closed Tickets)

Here is a list of the important tickets we closed for this release:

  • #71 – GIDs that are not serialized via handle_gid<>should raise an exception
  • #105 – Allow for hpx::util::functions to be registered in the AGAS symbolic namespace
  • #107 – Nasty threadmanger race condition (reproducible in sheneos_test)
  • #108 – Add millisecond resolution to HPXlogs on Linux
  • #110 – Shutdown hang in distributed with release build
  • #116 – Don’t use TSS for the applier and runtime pointers
  • #162 – Move local synchronous execution shortcut from hpx::function to the applier
  • #172 – Cache sources in CMake and check if they change manually
  • #178 – Add an INI option to turn off ranged-based AGAS caching
  • #187 – Support for disabling performance counter deployment
  • #202 – Support for sending performance counter data to a specific file
  • #218 – boost.coroutines allows different stack sizes, but stack pool is unaware of this
  • #231 – Implement movable boost::bind
  • #232 – Implement movable boost::function
  • #236 – Allow binding hpx::util::functionsto actions
  • #239 – Replace hpx::function with hpx::util::function
  • #240 – Can’t specify RemoteResult with lcos::async
  • #242 – REGISTER_TEMPLATE support for plain actions
  • #243 – handle_gid<> support for hpx::util::function
  • #245 – *_c_cache codethrows an exception if the queried GID is not in the local cache
  • #246 – Undefined references in dataflow/adaptive1d example
  • #252 – Problems configuring sheneos with CMake
  • #254 – Lifetime of components doesn’t end when client goes out of scope
  • #259 – CMake does not detect that MSVC10 has lambdas
  • #260 – io_service_pool segfault
  • #261 – Late parcel executed outside of pxthread
  • #263 – Cannot select allocator with CMake
  • #264 – Fix allocator select
  • #267 – Runtime error for hello_world
  • #269 – pthread_affinity_np test fails to compile
  • #270 – Compiler noise due to -Wcast-qual
  • #275 – Problem with configuration tests/include paths on Gentoo
  • #325 – Sheneos is 200-400 times slower than the fortran equivalent
  • #331 – hpx::init()and hpx_main() should not depend on program_options
  • #333 – Add doxygen support to CMake for doc toolchain
  • #340 – Performance counters for parcels
  • #346 – Component loading error when running hello_world in distributed on MSVC2010
  • #362 – Missing initializer error
  • #363 – Parcel port serialization error
  • #366 – Parcel buffering leads to types incompatible exception
  • #368 – Scalable alternative to rand() needed for HPX
  • #369 – IB over IP is substantially slower than just using standard TCP/IP
  • #374 – hpx::lcos::waitshould work with dataflows and arbitrary classes meeting the future interface
  • #375 – Conflicting/ambiguous overloads of hpx::lcos::wait
  • #376 – Find_HPX.cmake should set CMake variable HPX_FOUND for out of tree builds
  • #377 – ShenEOS interpolate bulk and interpolate_one_bulk are broken
  • #379 – Add support for distributed runs under SLURM
  • #382 – _Unwind_Word not declared in boost.backtrace
  • #387 – Doxygen should look only at list of specified files
  • #388 – Running make installon an out-of-tree application is broken
  • #391 – Out-of-tree application segfaults when running in qsub
  • #392 – Remove HPX_NO_INSTALL option from cmake build system
  • #396 – Pragma related warnings when compiling with older gcc versions
  • #399 – Out of tree component build problems
  • #400 – Out of source builds on Windows: linker should not receive compiler flags
  • #401 – Out of source builds on Windows: components need to be linked with hpx_serialization
  • #404 – gfortran fails to link automatically when fortran files are present
  • #405 – Inability to specify linking order for external libraries
  • #406 – Adapt action limits such that dataflow applications work without additional defines
  • #415 – locality_results is not a member of hpx::components::server
  • #425 – Breaking changes to traits::result wrt std::vector<id_type>
  • #426 – AUTOGLOB needs to be updated to support Fortran
GD Star Rating
loading...

    Leave a Reply

    Your email address will not be published. Required fields are marked *