Field space requirements can be used to specify that a task requires additional privileges on a field spaces such as the ability to allocate and free fields.

Member Legion::ProjectionFunctor::project (Context ctx, Task *task, unsigned index, LogicalRegion upper_bound, const DomainPoint &point)

Compute the projection for a logical region projection requirement down to a specific logical region.

Member Legion::ProjectionFunctor::project (Context ctx, Task *task, unsigned index, LogicalPartition upper_bound, const DomainPoint &point)

Compute the projection for a logical partition projection requirement down to a specific logical region.

Member Legion::Runtime::attach_file (Context ctx, const char *file_name, LogicalRegion handle, LogicalRegion parent, const std::vector< FieldID > &field_vec, LegionFileMode mode)

Attach an normal file as a physical region. This attach is similar to attach_hdf5 operation, except that the file has exact same data format as in-memory physical region. Data lays out as SOA in file.

Member Legion::Runtime::attach_hdf5 (Context ctx, const char *file_name, LogicalRegion handle, LogicalRegion parent, const std::map< FieldID, const char * > &field_map, LegionFileMode mode)

Attach an HDF5 file as a physical region. The file must already exist. Legion will defer the attach operation until all other operations on the logical region are finished. After the attach operation succeeds, then all other physical instances for the logical region will be invalidated, making the physical instance the only valid version of the logical region. The resulting physical instance is attached with restricted coherence (the same as logical regions mapped with simultaneous coherence). All operations using the logical region will be required to use the physical instance until the restricted coherence is removed using an acquire operation. The restricted coherence can be reinstated by performing a release operation. Just like other physical regions, the HDF5 file can be both mapped and unmapped after it is created. The runtime will report an error for an attempt to attach an file to a logical region which is already mapped in the enclosing parent task's context. The runtime will also report an error if the task launching the attach operation does not have the necessary privileges (read-write) on the logical region. The resulting physical region is unmapped, but can be mapped using the standard inline mapping calls.

Member Legion::Runtime::create_argument_map (Context ctx)

Create an argument map in the given context. This method is deprecated as argument maps can now be created directly by a simple declaration.

Member Legion::Runtime::create_index_space (Context ctx, const std::set< Domain > &domains)

Create a new top-level index space based on a set of domains

Member Legion::Runtime::create_index_space (Context ctx, size_t max_num_elmts)

Create a new top-level index space with the maximum number of elements

Member Legion::Runtime::detach_file (Context ctx, PhysicalRegion region)

Detach an normal file. THis detach operation is similar to detach_hdf5

Member Legion::Runtime::detach_hdf5 (Context ctx, PhysicalRegion region)

Detach an HDF5 file. This can only be performed on a physical region that was created by calling attach_hdf5. The runtime will properly defer the detach call until all other operations on the logical region are complete. It is the responsibility of the user to perform the necessary operations to flush any data back to the physical instance before detaching (e.g. releasing coherence, etc). If the physical region is still mapped when this function is called, then it will be unmapped by this call. Note that this file may not actually get detached until much later in the execution of the program due to Legion's deferred execution model.

Member Legion::Runtime::execute_index_space (Context ctx, TaskID task_id, const Domain domain, const std::vector< IndexSpaceRequirement > &indexes, const std::vector< FieldSpaceRequirement > &fields, const std::vector< RegionRequirement > &regions, const UntypedBuffer &global_arg, const ArgumentMap &arg_map, const Predicate &predicate=Predicate::TRUE_PRED, bool must_paralleism=false, MapperID id=0, MappingTagID tag=0)

An older method for launching an index space of tasks maintained for backwards compatibility with older Legion programs.

Member Legion::Runtime::execute_index_space (Context ctx, TaskID task_id, const Domain domain, const std::vector< IndexSpaceRequirement > &indexes, const std::vector< FieldSpaceRequirement > &fields, const std::vector< RegionRequirement > &regions, const UntypedBuffer &global_arg, const ArgumentMap &arg_map, ReductionOpID reduction, const UntypedBuffer &initial_value, const Predicate &predicate=Predicate::TRUE_PRED, bool must_parallelism=false, MapperID id=0, MappingTagID tag=0)

An older method for launching an index space of tasks that reduce all of their values by a reduction operation down to a single future. Maintained for backwards compatibility with older Legion programs.

Member Legion::Runtime::execute_task (Context ctx, TaskID task_id, const std::vector< IndexSpaceRequirement > &indexes, const std::vector< FieldSpaceRequirement > &fields, const std::vector< RegionRequirement > &regions, const UntypedBuffer &arg, const Predicate &predicate=Predicate::TRUE_PRED, MapperID id=0, MappingTagID tag=0)

An older method for launching a single task maintained for backwards compatibility with older Legion programs.

Member Legion::Runtime::get_index_space_domains (Context ctx, IndexSpace handle, std::vector< Domain > &domains)

Return the domains that represent the index space. While the previous call only works when there is a single domain for the index space, this call will work in all circumstances.

Member Legion::Runtime::get_tunable_value (Context ctx, TunableID tid, MapperID mapper=0, MappingTagID tag=0)

This is the old method for asking the mapper to specify a tunable value. It will assume that the resulting tunable future can be interpreted as an integer.

Member Legion::Runtime::has_multiple_domains (Context ctx, IndexSpace handle)

Return if the given index space is represented by multiple domains or just a single one. If multiple domains represent the index space then 'get_index_space_domains' should be used for getting the set of domains.

Member Legion::Runtime::register_legion_task (TaskID id, Processor::Kind proc_kind, bool single, bool index, VariantID vid=LEGION_AUTO_GENERATE_ID, TaskConfigOptions options=TaskConfigOptions(), const char *task_name=NULL)

Register a task with a template return type for the given kind of processor.

Register a task with a void return type for the given kind of processor.

Member Legion::Runtime::register_legion_task (TaskID id, Processor::Kind proc_kind, bool single, bool index, const UDT &user_data, VariantID vid=LEGION_AUTO_GENERATE_ID, TaskConfigOptions options=TaskConfigOptions(), const char *task_name=NULL)

Same as the register_legion_task above, but allow for users to pass some static data that will be passed as an argument to all invocations of the function.

Member Legion::Runtime::register_partition_function (ProjectionID handle)

Register a partition projection function that can be used to map from an upper bound of a logical partition down to a specific logical sub-region for a given domain point during index task execution. The projection ID zero is reserved for runtime use.

Member Legion::Runtime::register_region_function (ProjectionID handle)

Register a region projection function that can be used to map from an upper bound of a logical region down to a specific logical sub-region for a given domain point during index task execution. The projection ID zero is reserved for runtime use.

Member Legion::Runtime::set_registration_callback (RegistrationCallbackFnptr callback)

This call allows the application to register a callback function that will be run prior to beginning any task execution on every runtime in the system. It can be used to register or update the mapping between mapper IDs and mappers, register reductions, register projection function, register coloring functions, or configure any other static runtime variables prior to beginning the application.