Version 19.06.0 (June 27, 2019)

• Legion
  • All tools (Legion Prof, Legion Spy, etc.) now support Python 2 and 3
  • The flag -lg:warn_backtrace prints a backtrace on each warning
    to allow easier pinpointing of problematic code
• Realm
  • Support for building against debug versions of GASNet
  • Significantly reduced runtime overhead for small Realm tasks
  • External HDF5 instances work with datasets in groups
  • Scheduler locking allows spin-waiting for non-reentrant
    operations (e.g. Python module imports)
  • Memory size (e.g. "-ll:csize") arguments accept k/m/g/t
    size suffixes
  • Better error messages when Realm memory sizes are too large
• Regent
  • The image, preimage and restrict partitioning operators now
    accept an optional disjoint or aliased keyword to specify the
    disjointness of the resulting partition
  • The address of operator (&) is now supported
  • Support for explicit field maps for HDF5
• Legion Prof
  • Menu option to select a subset of the profile information
    for viewing
  • Grouping of memory channels, utilization and additional details
    such as source and destination nodes/processors associated with
    the channels
  • Physical instances contain additional information about the regions
    they belong to
• Python
  • Support for partitioning operators equal and restriction
  • Support for bool and complex types
  • Support for must epoch launches
  • Support for returning a future out of a fence
  • Fixes for macOS

Version 19.04.0 (April 30, 2019)

• Legion
  • Support for dimensions > 3. Set MAX_DIM at build time
    (or -DLegion_MAX_DIM in CMake) to build with any number of
    dimensions up to 9.
  • Change VariantID to 32 bits to match AUTO_GENERATE_ID
  • Improved mapper interfaces for instance allocation and
    failed instance allocation due to layout constraint conflicts
• Regent
  • Support for index fills
  • Support for disabling structure-slicing on structs by setting
    __no_field_slicing on the struc type
  • Substantial improvements to the auto-parallelizer, CUDA and
    OpenMP code generators
  • Substantial improvements in compile time for tasks with large
    numbers of fields
  • Build fixes for macOS
  • setup_env.py now works on macOS
• Realm
  • support for #pragma omp single sections in OpenMP processors
  • Realm IDs uses explicit bit packing instead of fragile C bit fields
  • numerous fixes for create_equal_subspace deppart operations
  • Support for CUDA 10
• Legion Prof
  • Added support for recording GPU processor times

Version 18.12.0 (December 27, 2018)

• Realm
  • More assorted bug fixes
  • Minor performance improvements in logging and accessor code
  • Handle signals on an alternate stack for better debugging/backtraces
• Regent
  • Added a new built-in complex type
  • Experimental support for building with PUC Lua
  • Multiple fixes to CUDA code generation, vectorization,
    auto-parallelization, and mapping optimization
  • Better error messages for __demand(__leaf) and so on
• Python
  • Use PyGILState for threading for compatibility with modules (e.g. numpy)
  • Support for calling tasks written in Regent

Version 18.09.0 (September 19, 2018)

• Legion
  • Support for physical tracing, which can provide up to 7x improvement in
    loops with very small tasks. Can be enabled in the mappers that
    inherit from DefaultMapper using -dm:memoize 1
• Realm
  • Assorted minor bug fixes
  • Support for development snapshots of GASNet-EX (using GASNet-1
    compatibility interfaces for now)
• Regent
  • Breaking change: Changed precendence of logical operators (and, or) to match that of
    Lua and Terra (or is now lower-precendence than and)
  • Full support for accessing sparse multi-dimensional regions
  • Initial support for incremental compilation. Enable with
    REGENT_INCREMENTAL=1
  • Changes to make compilation entirely deterministic
  • Multiple compilation speed improvements
  • Support for CUDA scalar reductions
  • Experimental support for parallel prefix operators, including CUDA
• Python
  • Support for defining methods as tasks
  • Support for passing futures to tasks and index tasks
  • Support for explicit return types on extern tasks
  • Improved support for Futures with encodings other than pickle

Version 18.05.0 (May 31, 2018)

• Legion
  • Migrated all node-local Legion reservations to use Realm fast reservations and removed no longer necessary continuations
  • Added support for mapper attached data to all Mappable types
  • Added support for assigning a block of IDs to a library in a consistent way across nodes via generate_library_task_ids and friends
• Realm
  • Added support for "fast" reservations that have better performance characteristics for reservations local to a node
• C API
  • Updated projection functor API to match Legion C++ API
• Regent
  • Regent now generates disjointness constraints for affine expressions in partition accesses. E.g. p[i] and p[i+1] are now known to be disjoint at compile time as long as p is a disjoint partition
  • Support for non-trivial projection functors in index space launches such as f(p[i+1])
  • Improvements to compile time spent in various optimization passes
  • Support for parallel compilation with the flag -fjobs N
  • Miscellaneous fixes

Version 18.02.0 (February 2, 2018)

• Legion
  • Support for PowerPC vector intrinsics
  • FieldAccessors support "view" coordinates and equivalent bounds checks
  • Improved schedule priorities for Legion meta-tasks
• Realm
  • Operation priority can now be adjust after a task/copy is launched
  • Assorted bug/memory leak fixes
  • AffineAccessors support an optional translation from "view" coordinates
    to actual coordinates in the instance being accessed
• Regent
  • Experimental support for calling Regent tasks from C/C++
  • Support for building with CMake
  • Support for running on PowerPC
• Bindings
  • Obsolete Lua and Terra bindings have been removed. The remaining Terra
    bindings have been renamed to Regent and now produce libregent.so

Version 17.10.0 (October 27, 2017)

• Legion
  • Introduction of new partitioning API based on dependent partitioning
  • Deprecation of old partitioning API, LegionRuntime::{Arrays,Accessors}
    namespaces
• Realm
  • Dependent partitioning API, including dimension-aware IndexSpace
  • Point/Rect types moved to Realm namespace
  • Instance creation allows caller to choose precise memory layout
  • Accessors moved to Realm namespace, changed to match new instance layouts
• C API
  • The C API is now accessed via the legion.h header file. Note that this
    is still a redirect back to the current legion/legion_c.h header
• Legion Prof
  • Added support for minimally invasive dumping of intermediate
    profiling data while the application is still running for long runs
• Python
  • New Python API bindings and native support for Python processors
    Compile with USE_PYTHON=1 and run with -ll:py 1 to enable Python
    Also see examples/python_interop for an example

Version 17.08.0 (August 24, 2017)

• Build system
  • Added HDF_ROOT variable to customize HDF5 install location
• Legion
  • New error message format and online reference at http://legion.stanford.edu/messages
• Legion Prof
  • Added new compact binary format for profile logs
  • Added flag: -hl:prof_logfile prof_%.gz
• Realm
  • Fixes to support big-endian systems
  • Several performance improvements to DMA subsystem
  • Added REALM_DEFAULT_ARGS environment variable containing flags to be inserted at front of command line
• Regent
  • Removed new operator. Unstructured regions are now fully allocated by default
  • Added optimization to automatically skip empty tasks
  • Initial support for extern tasks that are defined elsewhere
  • Tasks that use __demand(__openmp) are now constrained to run on OpenMP processors by default
  • RDIR: Better support for deeper nested region trees

Version 17.05.0 (May 26, 2017)

• Build system
  • Finally removed long-obsolete SHARED_LOWLEVEL flag
• Legion
  • Added C++14 [[deprecated]] attribute to existing deprecated APIs. All examples should all compile without deprecation warnings
  • Added Legion executor that enables support for interoperating with Agency inside of Legion tasks
• Realm
  • Switched to new DMA engine
  • Initial support for OpenMP "processors". Compile with USE_OPENMP and run with flags -ll:ocpu and -ll:othr.
• Regent
  • Added support running normal tasks on I/O processors
  • Added support for OpenMP code generation via __demand(__openmp)
• C API
  • Removed the following deprecated types:
    legion_task_result_t
    (obviated by the new task preamble/postamble)
  • Removed the following deprecated APIs:
    legion_physical_region_get_accessor_generic
    legion_physical_region_get_accessor_array
    (use legion_physical_region_get_field_accessor_* instead)
    legion_runtime_set_registration_callback
    (use legion_runtime_add_registration_callback instead)
    legion_runtime_register_task_void
    legion_runtime_register_task
    legion_runtime_register_task_uint32
    legion_runtime_register_task_uint64
    (use legion_runtime_preregister_task_variant_* instead)
    legion_future_from_buffer
    legion_future_from_uint32
    legion_future_from_uint64
    legion_future_from_bytes
    (use legion_future_from_untyped_pointer instead)
    legion_future_get_result
    legion_future_get_result_uint32
    legion_future_get_result_uint64
    legion_future_get_result_bytes
    (use legion_future_get_untyped_pointer instead)
    legion_future_get_result_size
    (use legion_future_get_untyped_size instead)
    legion_future_map_get_result
    (use legion_future_map_get_future instead)