Celerity Runtime Versions Save

Right on time for the holidays we bring you a new major release with several new features, quality of life improvements and debugging facilities.

Thanks to everybody who contributed to this release: @fknorr, @GagaLP, @PeterTh, @psalz!

HIGHLIGHTS

• The distr_queue::fence and buffer_snapshot APIs introduced in Celerity 0.4.0 are now stable (#225).
• It some situations it may be necessary to prevent kernels from being split in a certain way (for example to prevent overlapping writes); this can now be achieved using the new experimental::constrain_split API (#212).
• Speaking of splits, the new experimental:hint API can be used to control how a kernel is split across worker nodes (#227).
• Celerity now warns at runtime when a task declares reads from uninitialized buffers or writes with overlapping ranges between nodes (#224).
• The accessor out-of-bounds detection first introduced in Celerity 0.4.0 now also supports host tasks (#211).

Changelog

We recommend using the following SYCL versions with this release:

• DPC++: 61e51015 or newer
• hipSYCL: d2bd9fc7 or newer

Added

• Add new environment variable CELERITY_PRINT_GRAPHS to control whether task and command graphs are logged (#197, #236)
• Introduce new experimental for_each_item utility to iterate over a celerity range (#199)
• Add new environment variables CELERITY_HORIZON_STEP and CELERITY_HORIZON_MAX_PARALLELISM to control Horizon generation (#199)
• Add support for out-of-bounds checking for host accessors (also enabled via CELERITY_ACCESSOR_BOUNDARY_CHECK) (#211)
• Add new debug::set_task_name utility for naming tasks to aid debugging (#213)
• Add new experimental::constrain_split API to limit how a kernel can be split (#212)
• Add GDB pretty-printers for common Celerity types (#207)
• distr_queue::fence and buffer_snapshot are now stable, subsuming the experimental:: APIs of the same name (#225)
• Celerity now warns at runtime when a task declares reads from uninitialized buffers or writes with overlapping ranges between nodes (#224)
• Introduce new experimental::hint API for providing the runtime with additional information on how to execute a task (#227)
• Introduce new experimental::hints::split_1d and experimental::hints::split_2d task hints for controlling how a task is split into chunks (#227)

Changed

• Horizons can now also be triggered by graph breadth. This improves performance in some scenarios, and prevents programs with many independent tasks from running out of task queue space (#199)

Fixed

• In edge cases, command graph generation would fail to generate await-push commands when re-distributing reduction results (#223)
• Command graph generation was missing an anti-dependency between push-commands of partial reduction results and the final reduction command (#223)
• Don't create multiple smaller push-commands instead of a single large one in some rare situations (#229)
• Unit tests that inspect logs contained a race that would cause spurious failures (#234)

Internal

• Improve command graph testing infrastructure (#198)
• Overhaul internal grid region and box representation, remove AllScale dependency (#204)

This is a small bugfix release primarily restoring Celerity's compatibility with the most recent versions of hipSYCL and DPC++.

Changelog

We recommend using the following SYCL versions with this release:

• DPC++: 61e51015 or newer
• hipSYCL: d2bd9fc7 or newer

See our platform support guide for a complete list of all officially supported configurations.

Fixed

• Fix the behavior of dry runs (CELERITY_DRY_RUN_NODES) in the presence of fences or graph horizons (#196, 069f5029)
• Compatibility with recent hipSYCL >= d2bd9fc7 (#200, b174df7d)
• Compatibility with recent versions of Intel oneAPI and Arc-series dedicated GPUs (requires deactivating mimalloc, #203, c1519624)
• Work around a bug in DPC++ that breaks selection of the non-default device (#210, 2b652f8)

Removed

• Remove outdated workarounds for unsupported SYCL versions (#200, 85b7479c)

We are back with a major release that touches all aspects of Celerity, bringing considerable improvements to its APIs, usability and performance.

Thanks to everybody who contributed to this release: @almightyvats @BlackMark29A @facuMH @fknorr @PeterTh @psalz!

HIGHLIGHTS

• Celerity 0.4.0 uses a fully distributed scheduling model replacing the old master-worker approach. This improves the scheduling complexity of applications with all-to-all communication from O(N^2) to O(N), solving a central scaling bottleneck for many Celerity applications (#186).
• Objects shared between multiple host_tasks, such as file handles for I/O operations, can now be explicitly managed by the runtime through a new experimental declarative API: A host_object encapsulates arbitrary host-side objects, while side_effects are used to read and/or mutate them, analogously to buffer and accessor. Embracing this new pattern will guarantee correct lifetimes and synchronization around these objects. (#68).
• The new experimental fence API allows accessing buffer and host-object data from the main thread without manual synchronization and reimagines SYCL's host accessors in a way that is more compatible with Celerity's asynchronous execution model (#151).
• The new CMake option CELERITY_ACCESSOR_BOUNDARY_CHECK can be set to enable out-of-bounds buffer access detection at runtime inside device kernels to detect errors such as incorrectly-specified range-mappers, at the cost of some runtime overhead. This check is enabled by default for debug builds of Celerity (#178).
• Celerity now expects buffers (and the new host-objects) to be captured by reference into command group functions, where it previously required by-value captures. This is in accordance with SYCL 2020 and removes one common source of user errors (#173).
• Last but not least, several significant performance improvements make Celerity even more competitive for real-world HPC applications (#100, #111, #112, #115, #133, #137, #138, #145, #184).

Changelog

We recommend using the following SYCL versions with this release:

• DPC++: 61e51015 or newer
• hipSYCL: 24980221 or newer

See our platform support guide for a complete list of all officially supported configurations.

Added

• Introduce new experimental host_object and side_effect APIs to express non-buffer dependencies between host tasks (#68, 7a5326a4c5edf348deedd6f9a7f6e9360ea22684)
• Add new CELERITY_GRAPH_PRINT_MAX_VERTS config options (#80, d3dd722c984e5a4c897f056774dd1863552dd128)
• Named threads for better debugging (#98, 25d769db67f16fa4c6ab5ae57046003a71638135, #131, ff5fbecfb7bf65ae63c325d28085d7f646657555)
• Add support for passing device selectors to distr_queue constructor (#113, 556b6f2b28d794006f76b28c544abb0a8ea2f1cb)
• Add new CELERITY_DRY_RUN_NODES environment variable to simulate the scheduling of an application on a large number of nodes (without execution or data transfers) (#125, 299ebbf3661574dc260510ac02686e)
• Add ability to name buffers for debugging (#132, 107652248e4676f7a1f55962ac2a0e734c8a4d58)
• Introduce experimental fence API for accessing buffer and host-object data from the main thread (#151, 6b803f8140cbf294b77b6def621b4004ecc18786)
• Introduce backend system for vendor-specific code paths (#162, 750f32aafc23190fc07c48ff4704bfa4515a6b92)
• Add CELERITY_USE_MIMALLOC CMake configuration option to use the mimalloc allocator (enabled by default) (#170, 234e3d23f328944225a5aefd0c50ba20a9b09c8b)
• Support 0-dimensional buffers, accessors and kernels (#163, 0685d944768bde29239c31066eb6d4fa1329e2cf)
• Introduce new diagnostics utility for detecting erroneous reference captures into kernel functions, as well as unused accessors (#173, ff7ed0266c79df13f3ccf59ab9f2c2a092db50e3)
• Introduce CELERITY_ACCESSOR_BOUNDARY_CHECK CMake option to detect out-of-bounds buffer accesses inside device kernels (enabled by default for debug builds) (#178, 2c738c846a70aee034c568782fbdf349be2)
• Print more helpful error message when buffer allocations exceed available device memory (#179, 79f97c2b2b5b1442fec2668cfbf813aa50cb0225)

Changed

• Update spdlog to 1.9.2 (#80, a178828d62cae411256e25ab04329aaed836b3f5)
• Overhaul logging mechanism (#80, 1b19bfc52e3f72f339e733f220ca057e2688b729)
• Improve graph dependency tracking performance (#100, c9dab180738737402a29081cee1c78e50a7ee8d9)
• Improve task lookup performance (#112, 5139256499e1f52acde28fdf59f3befe07e4015b)
• Introduce epochs as a mechanism for in-graph synchronization (#86, 61dd07ec37ba306095414a30a263daec542e452f)
• Miscellaneous performance improvements (#115, 9a099d2d0a7a1d0838998ec491e32522ff02433b, #137, b0254fd754d26b9bbd836c719d81edeab05d1456, #138, 02258c07932a6d68f3d0fc4c0d59dfaf88b92ecf, #145, f0b53ce9a90)
• Improve scheduler performance by reducing lock contention (#111, 4547b5fec64c05549aa6d9faabb56c8185433b91)
• Improve graph generation and printing performance (#133, 81227986b7faa9b2869edda51871f072880ca092)
• Use libenvpp to validate all CELERITY_* environment variables (#158, b2ced9b3b72eedb72141cf4526269efe6c64c273)
• Use native ("USM") pointers instead of SYCL buffers for backing buffer allocations (#162, 44497b3164ef80277d05139ecb777f87cbe29f00)
• Implement range and id types instead of aliasing SYCL types (#163, 0685d944768bde29239c31066eb6d4fa1329e2cf)
• Disallow in-source builds (#176, 0a96d156ef3bd217b5faa03fea1eb7442096f0c4)
• Lift restrictions on reductions for DPC++ (#175, efff21b95e5e6394ba459ea26dcd112af2333a79)
• Remove multi-pass mechanism to allow reference capture of buffers and host-objects into command group functions, in alignment with the SYCL 2020 API (#173, 0a743c7bec9091f2c85eb87bedfca7104e33db9a)
• Drastically improve performance of buffer data location tracking (#184, adff79e50c926a8ecae1e7982bc5843ded215f7f)
• Switch to distributed scheduling model (#186, 0970bff0b132620b32e79ba2c44b0f6d19ed234d)

Deprecated

• Passing sycl::device to distr_queue constructor (use a device selector instead) (#113, 556b6f2b28d794006f76b28c544abb0a8ea2f1cb)
• Capturing buffers and host objects by value into command group functions (capture by reference instead) (#173, 0a743c7bec9091f2c85eb87bedfca7104e33db9a)
• allow_by_ref is no longer required to capture references into command group functions (#173, 0a743c7bec9091f2c85eb87bedfca7104e33db9a)

Removed

• Removed support for ComputeCpp (discontinued) (#167, 68367dd7c581219f09f944705837b69d19561a5a)
• Removed deprecated host_memory_layout (use buffer_allocation_window instead) (#187, f5e6510ac3bbde7fe882d9dbb7fa1e9043ef5a50)
• Removed deprecated kernel dimension template parameter on one_to_one, fixed and all range mappers (#187, 40a12a4004c7a5fcca2f30af4b443356aa728500)
• Kernels can no longer receive sycl::item (use celerity::item instead), this was already broken in 0.3.2 (#163, 67ccacce703553d1056bfaf3ae2ddb342372bf88)

Fixed

• Improve performance for buffer transfers on IBM Spectrum MPI (#114, c60527f67736505f2d9293ed983103e231d69991)
• Increase size limit on individual buffer transfer operations from 2 GiB to 128 GiB (#153, 972682f3cfc7bd9819c28ade2258c98664ba1da7)
• Fix race between creating collective groups and submitting host tasks (#152, 0a4fca5831ad0dfe4691368cace8f96c300ab9f2)
• Align read-accessor operator[] with SYCL 2020 spec by returning const-reference instead of value (#156, 5011dedfe0f8c60103d972d316d4aae7fadf772d)

Internal

• Add microbenchmark suite (#100, c2853ca403a7cb24a67d2594a577e27bbedef7e8, #107, 51f5bc5de48126cf2328cd93e34113b5d454c568)
• Update Catch2 to v3.3 (#102, 9a6f19dd6c7dc23064da1537cb7125f071126b32, #129, 0d1e36a039de54a3f32185933158c9a546b6218d, #162, 5aa33d6a5b04e9cb0a1cf1db66a4af990a6cffb2)
• Add all_tests unit test executable (#104, c12b052c37343e010a14019e186320c3e942ff92)
• Add custom CSV and Markdown reporters (#109, ba3af8b91ece654aa67bb4e57fc29e7e411d8018)
• Introduce automatic clang-tidy checks for CI (#128, ca94beef454e52348016bbb8358c81b4e5184c5a)

This release fixes several bugs discovered since the v0.3.1 release. It also improves SYCL backend support and adds minor debugging features.

Added

• Add support for ComputeCpp 2.7.0 and 2.8.0 with stable and experimental compilers. (2831b2a)
• Add support for using local memory with ComputeCpp. (8e2fce4)
• Print Celerity version upon runtime startup. (0681c16)
• Print warning when too few logical cores are available. (113e688)

Fixed

• Fix race condition around reference-capture in matmul example. (76f49c9)
• Reduce hardware requirements for maximum work-group size in tests. (008a868, f0cf3f42)
• Update Catch2 submodule to v2.13.8 as a bugfix. (26ca0895)
• Do not create empty chunks when splitting tasks with a small execution range in dimension 0. (15fa9293)
• Correctly handle empty buffers and buffer requirements with empty ranges. (ad99522b)
• Suppress unhelpful deprecation warnings around sycl::atomic from DPC++. (39dacdf5)
• Throw when submitting compute tasks with an empty execution range instead of accepting SYCL misbehavior. (baa242ad)

This release contains several fixes for bugs discovered since the v0.3.0 release.

Fixed

• Remove blanket-statement error message upon early buffer deallocation, which in many cases is now legal. (6851145)
• Properly apply horizons to collective host task order-dependencies. (4488724)
• Avoid race between horizon task generation and horizon command execution. (f670868)
• Fix data race in task_manager::notify_horizon_executed (only in debug builds). (f641bcb)
• Don't rely on static destruction order for user_benchmarker. (d1c9e51)
• Restructure wave_sim example to avoid host side race condition for certain --sample-rate configurations. (d226b95)
• Hard-code paths for CMake dependencies in installed Celerity config to avoid mismatches. (4e88657)

The 0.3.0 release brings with it many new features and improvements, including several changes that further align Celerity with the new SYCL 2020 API.

See the changelog for a full summary of all changes.

HIGHLIGHTS

• Intel's DPC++ joins hipSYCL and ComputeCpp as the third SYCL implementation that is officially supported by Celerity.
• Celerity now has support for SYCL 2020-style scalar reductions! See our documentation for more information on how to get started.
• Changes in the SYCL 2020 API allow us to finally support nd-range parallel_for alongside local_accessor and group functions.
• We are introducing aliases or custom implementations into the celerity namespace for most supported SYCL features (e.g. celerity::access_mode, celerity::item and so on). This means that Celerity code no longer has to mix names from the sycl and celerity namespaces. While still possible for the most part, we recommend sticking to celerity::!
• Accessors can now also be created using SYCL 2020-style CTAD constructors: celerity::accessor acc{my_buffer, cgh, celerity::access::one_to_one{}, celerity::write_only}.

Note: We recommend using the following SYCL versions with this release:

• ComputeCpp: 2.6.0 or newer
• DPC++: 7735139 or newer
• hipSYCL: 7b00e2e or newer

This release contains a few fixes for bugs introduced in version 0.2.0.

Fixed

• Re-enable ComputeCpp workaround for explicit copy operations. (f58b146b)
• Fix compilation on Windows by avoiding the TRUE literal as enum value. (8de922e9)
• Fix compilation with Boost < 1.67 by using backwards compatible header. (a51c98a7)

It's been a while since our last release, but we have been busy!

See the changelog for a full summary of all changes.

HIGHLIGHTS

• The somewhat clunky with_master_access has been replaced by a much more powerful host_task API, which can schedule host-side code both on the master node as well as on worker nodes. It also features experimental support for integration with collective operations, such as parallel HDF5 I/O.
• Celerity buffers are now fully virtualized, meaning that each worker can take full advantage of the available device memory for its local workload.

See our docs on how to get started with Celerity (available either as markdown or on our website).

Note: If you are using hipSYCL, make sure to use the newest version from the develop branch.

In light of our recently released website we think it is the perfect time to also cut our first official release! The code base has reached a point where -- while not completely pain free -- we think it is ready to be compiled and experimented with by interested (and somewhat adventurous) external users!

If you encounter any problems with the documentation, build process or the examples, or if you have any other feedback you'd like to share, please don't hesitate to open an issue!

Note that, as mentioned in the readme and on the website, Celerity is a research project first and foremost, and it's still in its early stages. It will most likely not yet fully support your use case, and things will break!