├── .clang-format ├── .clang-tidy ├── .dir-locals.el ├── .dockerignore ├── .gitattributes ├── .github ├── CODEOWNERS ├── ISSUE_TEMPLATE │ └── bug_report.yml ├── copy-pr-bot.yaml ├── release.yml └── workflows │ ├── ci-gh-docs.yml │ ├── ci-gh-gasnet.yml │ ├── ci-gh-lint.yml │ ├── ci-gh-mac.yml │ ├── ci-gh-mpi.yml │ ├── ci-gh-nightly-release.yml │ ├── ci-gh.yml │ ├── gh-build-and-test.yml │ ├── gh-build-docs.yml │ ├── gh-gasnet.yml │ ├── gh-legate-profiler.yml │ ├── gh-mpi.yml │ ├── pr.yml │ ├── require-labels.yml │ ├── wheels-build.yml │ └── wheels-test.yml ├── .gitignore ├── .pre-commit-config.yaml ├── BUILD.rst ├── CONTRIBUTING.rst ├── LICENSE ├── README.md ├── benchmarks └── cpp │ ├── CMakeLists.txt │ └── inline_launch.cc ├── conda ├── conda-build │ ├── build.sh │ ├── conda_build_config.yaml │ └── meta.yaml ├── gasnet_wrapper │ ├── activate.sh │ ├── build-gex-wrapper.sh │ ├── build.sh │ ├── conda_build_config.yaml │ ├── deactivate.sh │ ├── meta.yaml │ ├── post-link.sh │ └── pre-unlink.sh ├── legate_profiler │ ├── build.sh │ ├── conda_build_config.yaml │ ├── dummy_legate │ │ ├── build.sh │ │ └── meta.yaml │ └── meta.yaml └── mpi_wrapper │ ├── activate.sh │ ├── build-mpi-wrapper.sh │ ├── build.sh │ ├── conda_build_config.yaml │ ├── deactivate.sh │ ├── meta.yaml │ ├── post-link.sh │ └── pre-unlink.sh ├── config ├── __init__.py ├── ensure_aedifix.py ├── examples │ ├── arch-ci-linux-docs.py │ ├── arch-ci-linux-gcc-py-pkgs-debug-sanitizer.py │ ├── arch-ci-linux-gcc-py-pkgs-debug.py │ ├── arch-ci-linux-gcc-py-pkgs-release-debug.py │ ├── arch-ci-linux-gcc-py-pkgs-release.py │ ├── arch-darwin-debug.py │ ├── arch-darwin-py-debug.py │ ├── arch-darwin-py-release.py │ ├── arch-dgx-superpod-debug.py │ ├── arch-legion-src-dir.py │ ├── arch-linux-cuda-local-debug.py │ └── arch-linux-py-cuda-pkgs-debug.py ├── legate_internal │ ├── __init__.py │ ├── main_package.py │ ├── packages │ │ ├── __init__.py │ │ ├── cal.py │ │ ├── gasnet.py │ │ ├── hdf5.py │ │ ├── legion.py │ │ ├── mpi.py │ │ ├── nccl.py │ │ ├── openmp.py │ │ ├── ucx.py │ │ └── zlib.py │ └── variables.mk └── py.typed ├── configure ├── continuous_integration ├── post_py.patch ├── requirements-build.txt └── scripts │ ├── build │ ├── build_hdf5.sh │ ├── build_wheel_linux.bash │ ├── make-conda-env │ ├── test │ ├── test_wheel_linux.bash │ ├── tools │ ├── legate-conda-utils │ ├── legate-configure-sccache │ └── pretty_printing.bash │ └── ucc-cmake-config │ ├── ucc-config-version.cmake │ ├── ucc-config.cmake │ └── ucc-targets.cmake ├── docs ├── figures │ └── developer-build.png └── legate │ ├── CMakeLists.txt │ ├── Doxyfile.in │ ├── source │ ├── BUILD.rst │ ├── CONTRIBUTING.rst │ ├── _static │ │ └── .keep │ ├── _templates │ │ ├── class.rst │ │ └── layout.html │ ├── api │ │ ├── cpp │ │ │ ├── data.rst │ │ │ ├── index.rst │ │ │ ├── io.rst │ │ │ ├── mapping.rst │ │ │ ├── partitioning.rst │ │ │ ├── runtime.rst │ │ │ ├── task.rst │ │ │ ├── tuning.rst │ │ │ ├── typedefs.rst │ │ │ ├── types.rst │ │ │ └── util.rst │ │ ├── index.rst │ │ └── python │ │ │ ├── auto_task.rst │ │ │ ├── classes.rst │ │ │ ├── constraint.rst │ │ │ ├── domain.rst │ │ │ ├── index.rst │ │ │ ├── inline_allocation.rst │ │ │ ├── io │ │ │ └── index.rst │ │ │ ├── library.rst │ │ │ ├── logical_array.rst │ │ │ ├── logical_store.rst │ │ │ ├── machine.rst │ │ │ ├── manual_task.rst │ │ │ ├── operation.rst │ │ │ ├── parallel_policy.rst │ │ │ ├── physical_array.rst │ │ │ ├── physical_store.rst │ │ │ ├── resource_config.rst │ │ │ ├── routines.rst │ │ │ ├── runtime.rst │ │ │ ├── scalar.rst │ │ │ ├── scope.rst │ │ │ ├── settings.rst │ │ │ ├── shape.rst │ │ │ ├── symbolic_expr.rst │ │ │ ├── task_config.rst │ │ │ ├── task_context.rst │ │ │ ├── task_local_buffer.rst │ │ │ ├── tasks.rst │ │ │ ├── types.rst │ │ │ ├── variable.rst │ │ │ └── variant_options.rst │ ├── changes │ │ ├── 2406.rst │ │ ├── 2411.rst │ │ ├── 2501.rst │ │ ├── 2503.rst │ │ ├── 2505.rst │ │ ├── 2507.rst │ │ ├── dev.rst │ │ └── index.rst │ ├── conf.py │ ├── developer │ │ ├── index.rst │ │ ├── style.rst │ │ └── testing.rst │ ├── faq.rst │ ├── gasnet.rst │ ├── index.rst │ ├── installation.rst │ ├── legate.stl │ │ └── source │ │ │ ├── legate-stl.rst │ │ │ ├── reference │ │ │ └── index.rst │ │ │ └── user │ │ │ ├── index.rst │ │ │ ├── installation.rst │ │ │ └── usage.rst │ ├── manual │ │ ├── data │ │ │ └── index.rst │ │ ├── index.rst │ │ ├── introduction │ │ │ └── index.rst │ │ ├── mappers │ │ │ └── index.rst │ │ ├── overview │ │ │ ├── index.rst │ │ │ └── nutshell.rst │ │ ├── runtime │ │ │ └── index.rst │ │ ├── tasks │ │ │ └── index.rst │ │ └── usage │ │ │ ├── hdf5_gds.rst │ │ │ ├── index.rst │ │ │ ├── jupyter.rst │ │ │ └── running.rst │ ├── mpi-wrapper.rst │ ├── networking-wheels.rst │ ├── oss-licenses.rst │ ├── overview.rst │ ├── resources.rst │ └── versions.rst │ └── switcher.json ├── makefile ├── pyproject.toml ├── scripts ├── build │ ├── mpi_wrappers │ │ ├── CMakeLists.txt │ │ └── pyproject.toml │ └── python │ │ └── legate │ │ ├── CMakeLists.txt │ │ ├── README.md │ │ └── pyproject.toml ├── generate-conda-envs.py ├── get_legate_dir.py ├── maint │ └── run_check.sh ├── pre-commit │ ├── actionlint.yml │ ├── angle_includes.py │ ├── c_begone.py │ ├── check_cmake_format.py │ ├── cmake-format-legate.json │ ├── cmake-format.bash │ ├── cmake_config_format.json │ ├── cmake_config_lint.json │ ├── copyright.py │ ├── dej2lint.py │ ├── legate_assert.py │ ├── legate_defined.sh │ ├── no_default.py │ ├── shellcheckrc │ ├── traced_throw.py │ ├── util │ │ ├── __init__.py │ │ ├── match_util.py │ │ └── re_replacement.py │ └── yamllint.yml ├── release │ ├── clone_release_epic.py │ ├── make_release.py │ └── util │ │ ├── __init__.py │ │ ├── bump_cmake_versions.py │ │ ├── bump_conda_versions.py │ │ ├── bump_docs_version.py │ │ └── context.py └── viz-gpu-test-log.py ├── setup.cfg ├── share └── legate │ ├── examples │ ├── binding │ │ ├── cython │ │ │ ├── CMakeLists.txt │ │ │ ├── hello_world.cc │ │ │ ├── hello_world.h │ │ │ ├── hello_world.py │ │ │ ├── hello_world_cython.pyx │ │ │ └── pyproject.toml │ │ ├── manual │ │ │ ├── CMakeLists.txt │ │ │ ├── hello_world.cc │ │ │ └── hello_world.py │ │ └── pybind11 │ │ │ ├── CMakeLists.txt │ │ │ ├── hello_world.cc │ │ │ ├── hello_world.py │ │ │ └── pyproject.toml │ ├── helloworld │ │ ├── CMakeLists.txt │ │ ├── build-and-run.sh │ │ └── helloworld.cc │ ├── io │ │ └── hdf5 │ │ │ ├── ex1.py │ │ │ └── ex1_gen │ │ │ ├── CMakeLists.txt │ │ │ ├── build.bash │ │ │ └── gen_h5_data.c │ ├── manual_tasks │ │ ├── CMakeLists.txt │ │ ├── build-and-run.sh │ │ └── manual_tasks.cc │ └── saxpy │ │ ├── CMakeLists.txt │ │ ├── build-and-run.sh │ │ └── saxpy.cc │ ├── libexec │ └── legate-bind.sh │ ├── mpi_wrapper │ ├── CMakeLists.txt │ ├── cmake │ │ └── Config.cmake.in │ ├── install.bash │ └── src │ │ └── legate_mpi_wrapper │ │ ├── mpi_wrapper.c │ │ ├── mpi_wrapper.h │ │ └── mpi_wrapper_types.h │ ├── realm_ucp_bootstrap │ ├── CMakeLists.txt │ ├── bootstrap.h │ ├── bootstrap_mpi.c │ ├── bootstrap_util.h │ └── cmake │ │ └── Config.cmake.in │ └── sanitizers │ ├── asan_default_options.txt │ ├── lsan_suppressions.txt │ ├── tsan_default_options.txt │ ├── tsan_suppressions.txt │ └── ubsan_default_options.txt ├── src ├── CMakeLists.txt ├── cmake │ ├── Modules │ │ ├── bin2c.cmake │ │ ├── clang_tidy.cmake │ │ ├── cpm_helpers.cmake │ │ ├── cuda_arch_helpers.cmake │ │ ├── cython_rpaths.cmake │ │ ├── debug_helpers.cmake │ │ ├── debug_symbols.cmake │ │ ├── default_flags.cmake │ │ ├── export_aedifix_post_config.cmake │ │ ├── find_legate_cpp.cmake │ │ ├── find_or_configure.cmake │ │ ├── generate_fatbin_modules.cmake │ │ ├── generate_git_revision_file.cmake │ │ ├── generate_legate_defines.cmake │ │ ├── generate_sanitizer_options.cmake │ │ ├── include_rapids.cmake │ │ ├── legate_configure_target.cmake │ │ ├── legate_options.cmake │ │ ├── set_cpu_arch_flags.cmake │ │ ├── setup_macos_sdk_environ.cmake │ │ ├── uninstall.cmake │ │ └── utilities.cmake │ ├── generate_install_info_py.cmake │ ├── patches │ │ ├── legion_complex_half.diff │ │ ├── legion_cuda_12_9.diff │ │ ├── legion_cuhook_optional.diff │ │ ├── legion_half.diff │ │ ├── legion_redop.diff │ │ └── legion_ucx_mpi_bootstrap.diff │ ├── scripts │ │ ├── external_clang_tidy.cmake │ │ └── git_revision.cmake │ ├── templates │ │ ├── bin2c.cc.in │ │ ├── bin2c.h.in │ │ ├── git_version.cc.in │ │ ├── install_info.py.in │ │ ├── legate_defines.h.in │ │ └── uninstall.cmake.in │ ├── thirdparty │ │ ├── get_argparse.cmake │ │ ├── get_cal.cmake │ │ ├── get_cccl.cmake │ │ ├── get_cpm_licenses.cmake │ │ ├── get_cpptrace.cmake │ │ ├── get_fmt.cmake │ │ ├── get_google_benchmark.cmake │ │ ├── get_google_test.cmake │ │ ├── get_hdf5_vfd_gds.cmake │ │ ├── get_highfive.cmake │ │ ├── get_kvikio.cmake │ │ ├── get_legion.cmake │ │ ├── get_nccl.cmake │ │ └── sphinx │ │ │ └── FindSphinx.cmake │ └── versions │ │ ├── legion_version.json │ │ └── versions.json ├── cpp │ ├── CMakeLists.txt │ ├── legate.h │ └── legate │ │ ├── comm │ │ ├── coll.cc │ │ ├── coll.h │ │ ├── coll_comm.h │ │ ├── communicator.h │ │ ├── communicator.inl │ │ └── detail │ │ │ ├── backend_network.cc │ │ │ ├── backend_network.h │ │ │ ├── coll.cc │ │ │ ├── coll.h │ │ │ ├── comm.cc │ │ │ ├── comm.h │ │ │ ├── comm_cal.cc │ │ │ ├── comm_cal.h │ │ │ ├── comm_cpu.cc │ │ │ ├── comm_cpu.h │ │ │ ├── comm_cpu_factory.h │ │ │ ├── comm_cpu_factory.inl │ │ │ ├── comm_local.cc │ │ │ ├── comm_local.h │ │ │ ├── comm_mpi.cc │ │ │ ├── comm_mpi.h │ │ │ ├── comm_nccl.cc │ │ │ ├── comm_nccl.h │ │ │ ├── local_network.cc │ │ │ ├── local_network.h │ │ │ ├── logger.cc │ │ │ ├── logger.h │ │ │ ├── mpi_interface.cc │ │ │ ├── mpi_interface.h │ │ │ ├── mpi_network.cc │ │ │ ├── mpi_network.h │ │ │ ├── pthread_barrier.h │ │ │ ├── thread_comm.cc │ │ │ ├── thread_comm.h │ │ │ └── thread_comm.inl │ │ ├── cuda │ │ ├── cuda.h │ │ ├── detail │ │ │ ├── cuda_driver_api.cc │ │ │ ├── cuda_driver_api.h │ │ │ ├── cuda_driver_api.inl │ │ │ ├── cuda_driver_types.h │ │ │ ├── module_manager.cc │ │ │ ├── module_manager.h │ │ │ └── nvtx.h │ │ ├── stream_pool.cc │ │ ├── stream_pool.h │ │ └── stream_pool.inl │ │ ├── data │ │ ├── allocator.cc │ │ ├── allocator.h │ │ ├── buffer.cc │ │ ├── buffer.h │ │ ├── buffer.inl │ │ ├── detail │ │ │ ├── array_kind.h │ │ │ ├── array_tasks.cc │ │ │ ├── array_tasks.h │ │ │ ├── array_tasks_cuda.cc │ │ │ ├── array_tasks_omp.cc │ │ │ ├── attachment.cc │ │ │ ├── attachment.h │ │ │ ├── attachment.inl │ │ │ ├── buffer.cc │ │ │ ├── buffer.h │ │ │ ├── buffer.inl │ │ │ ├── external_allocation.cc │ │ │ ├── external_allocation.h │ │ │ ├── external_allocation.inl │ │ │ ├── fixup_ranges_fatbin.cu │ │ │ ├── future_wrapper.cc │ │ │ ├── future_wrapper.h │ │ │ ├── future_wrapper.inl │ │ │ ├── logical_array.cc │ │ │ ├── logical_array.h │ │ │ ├── logical_array.inl │ │ │ ├── logical_region_field.cc │ │ │ ├── logical_region_field.h │ │ │ ├── logical_region_field.inl │ │ │ ├── logical_store.cc │ │ │ ├── logical_store.h │ │ │ ├── logical_store.inl │ │ │ ├── offsets_to_ranges_fatbin.cu │ │ │ ├── physical_array.cc │ │ │ ├── physical_array.h │ │ │ ├── physical_array.inl │ │ │ ├── physical_store.cc │ │ │ ├── physical_store.h │ │ │ ├── physical_store.inl │ │ │ ├── ranges_to_offsets_fatbin.cu │ │ │ ├── region_field.cc │ │ │ ├── region_field.h │ │ │ ├── region_field.inl │ │ │ ├── scalar.cc │ │ │ ├── scalar.h │ │ │ ├── scalar.inl │ │ │ ├── shape.cc │ │ │ ├── shape.h │ │ │ ├── shape.inl │ │ │ ├── transform.cc │ │ │ ├── transform.h │ │ │ ├── transform.inl │ │ │ ├── user_storage_tracker.cc │ │ │ └── user_storage_tracker.h │ │ ├── external_allocation.cc │ │ ├── external_allocation.h │ │ ├── external_allocation.inl │ │ ├── inline_allocation.h │ │ ├── logical_array.cc │ │ ├── logical_array.h │ │ ├── logical_store.cc │ │ ├── logical_store.h │ │ ├── physical_array.cc │ │ ├── physical_array.h │ │ ├── physical_array.inl │ │ ├── physical_store.cc │ │ ├── physical_store.h │ │ ├── physical_store.inl │ │ ├── scalar.cc │ │ ├── scalar.h │ │ ├── scalar.inl │ │ ├── shape.cc │ │ ├── shape.h │ │ ├── shape.inl │ │ ├── slice.h │ │ └── slice.inl │ │ ├── experimental │ │ ├── io │ │ │ ├── detail │ │ │ │ ├── library.cc │ │ │ │ ├── library.h │ │ │ │ ├── mapper.cc │ │ │ │ ├── mapper.h │ │ │ │ ├── task.cc │ │ │ │ └── task.h │ │ │ └── kvikio │ │ │ │ ├── detail │ │ │ │ ├── basic.cc │ │ │ │ ├── basic.h │ │ │ │ ├── tile.cc │ │ │ │ ├── tile.h │ │ │ │ ├── tile_by_offsets.cc │ │ │ │ └── tile_by_offsets.h │ │ │ │ ├── interface.cc │ │ │ │ └── interface.h │ │ ├── stl.hpp │ │ ├── stl │ │ │ └── detail │ │ │ │ ├── clang_tidy_dummy.cpp │ │ │ │ ├── config.hpp │ │ │ │ ├── elementwise.hpp │ │ │ │ ├── fill.hpp │ │ │ │ ├── for_each.hpp │ │ │ │ ├── force_include.h │ │ │ │ ├── functional.hpp │ │ │ │ ├── get_logical_store.hpp │ │ │ │ ├── iterator.hpp │ │ │ │ ├── launch_task.hpp │ │ │ │ ├── mdspan.hpp │ │ │ │ ├── meta.hpp │ │ │ │ ├── prefix.hpp │ │ │ │ ├── ranges.hpp │ │ │ │ ├── reduce.hpp │ │ │ │ ├── registrar.hpp │ │ │ │ ├── slice.hpp │ │ │ │ ├── span.hpp │ │ │ │ ├── stlfwd.hpp │ │ │ │ ├── store.hpp │ │ │ │ ├── suffix.hpp │ │ │ │ ├── transform.hpp │ │ │ │ ├── transform_reduce.hpp │ │ │ │ ├── type_traits.hpp │ │ │ │ └── utility.hpp │ │ ├── trace.cc │ │ └── trace.h │ │ ├── io │ │ └── hdf5 │ │ │ ├── detail │ │ │ ├── interface.cc │ │ │ ├── interface.h │ │ │ ├── read.cc │ │ │ ├── read.h │ │ │ ├── util.cc │ │ │ └── util.h │ │ │ ├── interface.cc │ │ │ └── interface.h │ │ ├── mapping │ │ ├── array.cc │ │ ├── array.h │ │ ├── array.inl │ │ ├── detail │ │ │ ├── array.cc │ │ │ ├── array.h │ │ │ ├── array.inl │ │ │ ├── base_mapper.cc │ │ │ ├── base_mapper.h │ │ │ ├── base_mapper.inl │ │ │ ├── core_mapper.cc │ │ │ ├── core_mapper.h │ │ │ ├── default_mapper.h │ │ │ ├── default_mapper.inl │ │ │ ├── instance_manager.cc │ │ │ ├── instance_manager.h │ │ │ ├── instance_manager.inl │ │ │ ├── machine.cc │ │ │ ├── machine.h │ │ │ ├── machine.inl │ │ │ ├── mapping.cc │ │ │ ├── mapping.h │ │ │ ├── mapping.inl │ │ │ ├── operation.cc │ │ │ ├── operation.h │ │ │ ├── operation.inl │ │ │ ├── store.cc │ │ │ ├── store.h │ │ │ └── store.inl │ │ ├── machine.cc │ │ ├── machine.h │ │ ├── machine.inl │ │ ├── mapping.cc │ │ ├── mapping.h │ │ ├── mapping.inl │ │ ├── operation.cc │ │ ├── operation.h │ │ ├── operation.inl │ │ ├── store.cc │ │ ├── store.h │ │ └── store.inl │ │ ├── operation │ │ ├── detail │ │ │ ├── attach.cc │ │ │ ├── attach.h │ │ │ ├── attach.inl │ │ │ ├── copy.cc │ │ │ ├── copy.h │ │ │ ├── copy.inl │ │ │ ├── copy_launcher.cc │ │ │ ├── copy_launcher.h │ │ │ ├── copy_launcher.inl │ │ │ ├── discard.cc │ │ │ ├── discard.h │ │ │ ├── discard.inl │ │ │ ├── execution_fence.cc │ │ │ ├── execution_fence.h │ │ │ ├── execution_fence.inl │ │ │ ├── fill.cc │ │ │ ├── fill.h │ │ │ ├── fill.inl │ │ │ ├── fill_launcher.cc │ │ │ ├── fill_launcher.h │ │ │ ├── fill_launcher.inl │ │ │ ├── gather.cc │ │ │ ├── gather.h │ │ │ ├── gather.inl │ │ │ ├── index_attach.cc │ │ │ ├── index_attach.h │ │ │ ├── index_attach.inl │ │ │ ├── launcher_arg.cc │ │ │ ├── launcher_arg.h │ │ │ ├── launcher_arg.inl │ │ │ ├── mapping_fence.cc │ │ │ ├── mapping_fence.h │ │ │ ├── mapping_fence.inl │ │ │ ├── operation.cc │ │ │ ├── operation.h │ │ │ ├── operation.inl │ │ │ ├── reduce.cc │ │ │ ├── reduce.h │ │ │ ├── reduce.inl │ │ │ ├── release_region_field.cc │ │ │ ├── release_region_field.h │ │ │ ├── release_region_field.inl │ │ │ ├── scatter.cc │ │ │ ├── scatter.h │ │ │ ├── scatter.inl │ │ │ ├── scatter_gather.cc │ │ │ ├── scatter_gather.h │ │ │ ├── scatter_gather.inl │ │ │ ├── store_analyzer.cc │ │ │ ├── store_analyzer.h │ │ │ ├── store_analyzer.inl │ │ │ ├── store_projection.cc │ │ │ ├── store_projection.h │ │ │ ├── store_projection.inl │ │ │ ├── task.cc │ │ │ ├── task.h │ │ │ ├── task.inl │ │ │ ├── task_launcher.cc │ │ │ ├── task_launcher.h │ │ │ ├── task_launcher.inl │ │ │ ├── timing.cc │ │ │ ├── timing.h │ │ │ └── timing.inl │ │ ├── projection.cc │ │ ├── projection.h │ │ ├── projection.inl │ │ ├── task.cc │ │ ├── task.h │ │ └── task.inl │ │ ├── partitioning │ │ ├── constraint.cc │ │ ├── constraint.h │ │ ├── constraint.inl │ │ ├── detail │ │ │ ├── constraint.cc │ │ │ ├── constraint.h │ │ │ ├── constraint.inl │ │ │ ├── constraint_solver.cc │ │ │ ├── constraint_solver.h │ │ │ ├── constraint_solver.inl │ │ │ ├── partition.cc │ │ │ ├── partition.h │ │ │ ├── partition.inl │ │ │ ├── partitioner.cc │ │ │ ├── partitioner.h │ │ │ ├── partitioner.inl │ │ │ ├── partitioning_tasks.cc │ │ │ ├── partitioning_tasks.h │ │ │ ├── partitioning_tasks.inl │ │ │ ├── partitioning_tasks_cuda.cc │ │ │ ├── partitioning_tasks_fatbin.cu │ │ │ ├── partitioning_tasks_omp.cc │ │ │ ├── proxy │ │ │ │ ├── align.cc │ │ │ │ ├── align.h │ │ │ │ ├── align.inl │ │ │ │ ├── bloat.cc │ │ │ │ ├── bloat.h │ │ │ │ ├── bloat.inl │ │ │ │ ├── broadcast.cc │ │ │ │ ├── broadcast.h │ │ │ │ ├── broadcast.inl │ │ │ │ ├── constraint.h │ │ │ │ ├── image.cc │ │ │ │ ├── image.h │ │ │ │ ├── image.inl │ │ │ │ ├── scale.cc │ │ │ │ ├── scale.h │ │ │ │ ├── scale.inl │ │ │ │ ├── select.h │ │ │ │ ├── select.inl │ │ │ │ ├── validate.cc │ │ │ │ ├── validate.h │ │ │ │ └── validate.inl │ │ │ ├── restriction.cc │ │ │ └── restriction.h │ │ ├── proxy.cc │ │ ├── proxy.h │ │ └── proxy.inl │ │ ├── runtime │ │ ├── detail │ │ │ ├── argument_parsing │ │ │ │ ├── argument.h │ │ │ │ ├── argument.inl │ │ │ │ ├── config_legion.cc │ │ │ │ ├── config_legion.h │ │ │ │ ├── config_realm.cc │ │ │ │ ├── config_realm.h │ │ │ │ ├── exceptions.cc │ │ │ │ ├── exceptions.h │ │ │ │ ├── flags │ │ │ │ │ ├── cpus.cc │ │ │ │ │ ├── cpus.h │ │ │ │ │ ├── fbmem.cc │ │ │ │ │ ├── fbmem.h │ │ │ │ │ ├── gpus.cc │ │ │ │ │ ├── gpus.h │ │ │ │ │ ├── logging.cc │ │ │ │ │ ├── logging.h │ │ │ │ │ ├── numamem.cc │ │ │ │ │ ├── numamem.h │ │ │ │ │ ├── ompthreads.cc │ │ │ │ │ ├── ompthreads.h │ │ │ │ │ ├── openmp.cc │ │ │ │ │ ├── openmp.h │ │ │ │ │ ├── sysmem.cc │ │ │ │ │ └── sysmem.h │ │ │ │ ├── legate_args.cc │ │ │ │ ├── legate_args.h │ │ │ │ ├── parse.cc │ │ │ │ ├── parse.h │ │ │ │ ├── util.cc │ │ │ │ └── util.h │ │ │ ├── communicator_manager.cc │ │ │ ├── communicator_manager.h │ │ │ ├── communicator_manager.inl │ │ │ ├── config.h │ │ │ ├── consensus_match_result.h │ │ │ ├── consensus_match_result.inl │ │ │ ├── field_manager.cc │ │ │ ├── field_manager.h │ │ │ ├── field_manager.inl │ │ │ ├── library.cc │ │ │ ├── library.h │ │ │ ├── library.inl │ │ │ ├── mapper_manager.cc │ │ │ ├── mapper_manager.h │ │ │ ├── mapper_manager.inl │ │ │ ├── mpi_detection.cc │ │ │ ├── mpi_detection.h │ │ │ ├── partition_manager.cc │ │ │ ├── partition_manager.h │ │ │ ├── projection.cc │ │ │ ├── projection.h │ │ │ ├── region_manager.cc │ │ │ ├── region_manager.h │ │ │ ├── runtime.cc │ │ │ ├── runtime.h │ │ │ ├── runtime.inl │ │ │ ├── scope.cc │ │ │ ├── scope.h │ │ │ ├── scope.inl │ │ │ ├── shard.cc │ │ │ └── shard.h │ │ ├── exception_mode.h │ │ ├── library.cc │ │ ├── library.h │ │ ├── library.inl │ │ ├── resource.h │ │ ├── runtime.cc │ │ ├── runtime.h │ │ └── runtime.inl │ │ ├── task │ │ ├── detail │ │ │ ├── exception.h │ │ │ ├── exception.inl │ │ │ ├── inline_task_body.cc │ │ │ ├── inline_task_body.h │ │ │ ├── legion_task.h │ │ │ ├── legion_task.inl │ │ │ ├── legion_task_body.cc │ │ │ ├── legion_task_body.h │ │ │ ├── return_value.cc │ │ │ ├── return_value.h │ │ │ ├── return_value.inl │ │ │ ├── returned_cpp_exception.cc │ │ │ ├── returned_cpp_exception.h │ │ │ ├── returned_cpp_exception.inl │ │ │ ├── returned_exception.cc │ │ │ ├── returned_exception.h │ │ │ ├── returned_exception.inl │ │ │ ├── returned_exception_common.h │ │ │ ├── returned_python_exception.cc │ │ │ ├── returned_python_exception.h │ │ │ ├── returned_python_exception.inl │ │ │ ├── task.cc │ │ │ ├── task.h │ │ │ ├── task.inl │ │ │ ├── task_config.cc │ │ │ ├── task_config.h │ │ │ ├── task_config.inl │ │ │ ├── task_context.cc │ │ │ ├── task_context.h │ │ │ ├── task_context.inl │ │ │ ├── task_info.cc │ │ │ ├── task_info.h │ │ │ ├── task_info.inl │ │ │ ├── task_return.cc │ │ │ ├── task_return.h │ │ │ ├── task_return.inl │ │ │ ├── task_return_layout.cc │ │ │ ├── task_return_layout.h │ │ │ ├── task_return_layout.inl │ │ │ ├── task_signature.cc │ │ │ ├── task_signature.h │ │ │ ├── task_signature.inl │ │ │ ├── variant_info.cc │ │ │ ├── variant_info.h │ │ │ └── variant_info.inl │ │ ├── exception.h │ │ ├── exception.inl │ │ ├── registrar.cc │ │ ├── registrar.h │ │ ├── task.cc │ │ ├── task.h │ │ ├── task.inl │ │ ├── task_config.cc │ │ ├── task_config.h │ │ ├── task_config.inl │ │ ├── task_context.cc │ │ ├── task_context.h │ │ ├── task_context.inl │ │ ├── task_info.cc │ │ ├── task_info.h │ │ ├── task_info.inl │ │ ├── task_signature.cc │ │ ├── task_signature.h │ │ ├── task_signature.inl │ │ ├── variant_helper.h │ │ ├── variant_info.cc │ │ ├── variant_info.h │ │ ├── variant_info.inl │ │ ├── variant_options.cc │ │ ├── variant_options.h │ │ └── variant_options.inl │ │ ├── timing │ │ ├── timing.cc │ │ └── timing.h │ │ ├── tuning │ │ ├── parallel_policy.cc │ │ ├── parallel_policy.h │ │ ├── parallel_policy.inl │ │ ├── scope.cc │ │ └── scope.h │ │ ├── type │ │ ├── detail │ │ │ ├── types.cc │ │ │ ├── types.h │ │ │ └── types.inl │ │ ├── type_traits.h │ │ ├── types.cc │ │ ├── types.h │ │ └── types.inl │ │ └── utilities │ │ ├── abort.cc │ │ ├── abort.h │ │ ├── assert.h │ │ ├── compiler.cc │ │ ├── compiler.h │ │ ├── cpp_version.h │ │ ├── debug.cc │ │ ├── debug.h │ │ ├── debug.inl │ │ ├── detail │ │ ├── align.cc │ │ ├── align.h │ │ ├── buffer_builder.cc │ │ ├── buffer_builder.h │ │ ├── buffer_builder.inl │ │ ├── compressed_pair.h │ │ ├── core_ids.h │ │ ├── cuda_reduction_buffer.cuh │ │ ├── cuda_reduction_buffer.inl │ │ ├── deserializer.cc │ │ ├── deserializer.h │ │ ├── deserializer.inl │ │ ├── doxygen.h │ │ ├── enumerate.h │ │ ├── enumerate.inl │ │ ├── env.cc │ │ ├── env.h │ │ ├── env_defaults.h │ │ ├── error.cc │ │ ├── error.h │ │ ├── formatters.cc │ │ ├── formatters.h │ │ ├── hash.h │ │ ├── linearize.cc │ │ ├── linearize.h │ │ ├── malloc.h │ │ ├── mdspan │ │ │ ├── flat_mdspan_iterator.h │ │ │ ├── flat_mdspan_iterator.inl │ │ │ ├── flat_mdspan_view.h │ │ │ ├── flat_mdspan_view.inl │ │ │ ├── for_each_in_extent.h │ │ │ ├── for_each_in_extent.inl │ │ │ ├── reduction_accessor.h │ │ │ ├── reduction_accessor.inl │ │ │ └── util.h │ │ ├── omp_thread_local_storage.h │ │ ├── omp_thread_local_storage.inl │ │ ├── ordered_set.h │ │ ├── ordered_set.inl │ │ ├── pack.h │ │ ├── proc_local_storage.cc │ │ ├── sanitizer_defaults.cc │ │ ├── shared_ptr_control_block.h │ │ ├── shared_ptr_control_block.inl │ │ ├── store_iterator_cache.h │ │ ├── store_iterator_cache.inl │ │ ├── strtoll.h │ │ ├── traced_exception.cc │ │ ├── traced_exception.h │ │ ├── traced_exception.inl │ │ ├── tuple.cc │ │ ├── tuple.h │ │ ├── type_traits.h │ │ ├── unravel.h │ │ ├── unravel.inl │ │ ├── zip.cc │ │ ├── zip.h │ │ ├── zip.inl │ │ ├── zstring_view.h │ │ └── zstring_view.inl │ │ ├── dispatch.cc │ │ ├── dispatch.h │ │ ├── env.h │ │ ├── hash.h │ │ ├── internal_shared_ptr.cc │ │ ├── internal_shared_ptr.h │ │ ├── internal_shared_ptr.inl │ │ ├── machine.cc │ │ ├── machine.h │ │ ├── macros.h │ │ ├── mdspan.h │ │ ├── mdspan.inl │ │ ├── memory.h │ │ ├── memory.inl │ │ ├── proc_local_storage.h │ │ ├── proc_local_storage.inl │ │ ├── scope_guard.h │ │ ├── scope_guard.inl │ │ ├── shared_ptr.h │ │ ├── shared_ptr.inl │ │ ├── span.h │ │ ├── span.inl │ │ ├── tuple.h │ │ ├── tuple.inl │ │ └── typedefs.h └── python │ ├── CMakeLists.txt │ ├── build_legate │ ├── __init__.py │ ├── build.py │ ├── editable.py │ └── utils │ │ ├── __init__.py │ │ ├── _build.py │ │ ├── _cmake_config.py │ │ ├── _io.py │ │ ├── _legate_config.py │ │ ├── _monkey.py │ │ ├── _types.py │ │ └── _utils.py │ ├── legate │ ├── CMakeLists.txt │ ├── __init__.py │ ├── _sphinxext │ │ ├── __init__.py │ │ ├── releases.py │ │ └── settings.py │ ├── _version.pyi │ ├── core │ │ ├── CMakeLists.txt │ │ ├── __init__.py │ │ ├── _ext │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.pxd │ │ │ ├── __init__.py │ │ │ ├── cython_libcpp │ │ │ │ └── string_view.pxd │ │ │ ├── task │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── decorator.pxd │ │ │ │ ├── decorator.pyi │ │ │ │ ├── decorator.pyx │ │ │ │ ├── invoker.pxd │ │ │ │ ├── invoker.pyi │ │ │ │ ├── invoker.pyx │ │ │ │ ├── py_task.pxd │ │ │ │ ├── py_task.pyi │ │ │ │ ├── py_task.pyx │ │ │ │ ├── python_task.pxd │ │ │ │ ├── python_task.pyx │ │ │ │ ├── type.pxd │ │ │ │ ├── type.pyi │ │ │ │ ├── type.pyx │ │ │ │ ├── util.pxd │ │ │ │ ├── util.pyi │ │ │ │ └── util.pyx │ │ │ └── utils │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── ordered_set.pyi │ │ │ │ └── ordered_set.pyx │ │ ├── _lib │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.pxd │ │ │ ├── __init__.py │ │ │ ├── data │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── buffer.pxd │ │ │ │ ├── buffer.pyi │ │ │ │ ├── buffer.pyx │ │ │ │ ├── detail │ │ │ │ │ └── logical_store.pxd │ │ │ │ ├── external_allocation.pxd │ │ │ │ ├── external_allocation.pyx │ │ │ │ ├── inline_allocation.pxd │ │ │ │ ├── inline_allocation.pyi │ │ │ │ ├── inline_allocation.pyx │ │ │ │ ├── logical_array.pxd │ │ │ │ ├── logical_array.pyi │ │ │ │ ├── logical_array.pyx │ │ │ │ ├── logical_store.pxd │ │ │ │ ├── logical_store.pyi │ │ │ │ ├── logical_store.pyx │ │ │ │ ├── physical_array.pxd │ │ │ │ ├── physical_array.pyi │ │ │ │ ├── physical_array.pyx │ │ │ │ ├── physical_store.pxd │ │ │ │ ├── physical_store.pyi │ │ │ │ ├── physical_store.pyx │ │ │ │ ├── scalar.pxd │ │ │ │ ├── scalar.pyi │ │ │ │ ├── scalar.pyx │ │ │ │ ├── shape.pxd │ │ │ │ ├── shape.pyi │ │ │ │ ├── shape.pyx │ │ │ │ ├── slice.pxd │ │ │ │ └── slice.pyx │ │ │ ├── experimental │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── io │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── __init__.py │ │ │ │ │ └── kvikio │ │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ │ ├── __init__.py │ │ │ │ │ │ ├── kvikio_interface.pxd │ │ │ │ │ │ ├── kvikio_interface.pyi │ │ │ │ │ │ └── kvikio_interface.pyx │ │ │ │ ├── trace.pxd │ │ │ │ ├── trace.pyi │ │ │ │ └── trace.pyx │ │ │ ├── legate_defines.pxd │ │ │ ├── legate_defines.pyi │ │ │ ├── legate_defines.pyx │ │ │ ├── mapping │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── detail │ │ │ │ │ └── machine.pxd │ │ │ │ ├── machine.pxd │ │ │ │ ├── machine.pyi │ │ │ │ ├── machine.pyx │ │ │ │ ├── mapping.pxd │ │ │ │ ├── mapping.pyi │ │ │ │ └── mapping.pyx │ │ │ ├── operation │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── projection.pxd │ │ │ │ ├── projection.pyi │ │ │ │ ├── projection.pyx │ │ │ │ ├── task.pxd │ │ │ │ ├── task.pyi │ │ │ │ └── task.pyx │ │ │ ├── partitioning │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── constraint.pxd │ │ │ │ ├── constraint.pyi │ │ │ │ ├── constraint.pyx │ │ │ │ └── proxy.pxd │ │ │ ├── runtime │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── detail │ │ │ │ │ └── runtime.pxd │ │ │ │ ├── exception_mode.pxd │ │ │ │ ├── exception_mode.pyi │ │ │ │ ├── exception_mode.pyx │ │ │ │ ├── library.pxd │ │ │ │ ├── library.pyi │ │ │ │ ├── library.pyx │ │ │ │ ├── resource.pxd │ │ │ │ ├── resource.pyi │ │ │ │ ├── resource.pyx │ │ │ │ ├── runtime.pxd │ │ │ │ ├── runtime.pyi │ │ │ │ └── runtime.pyx │ │ │ ├── task │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── detail │ │ │ │ │ ├── __init__.pxd │ │ │ │ │ ├── returned_python_exception.pxd │ │ │ │ │ ├── task_context.pxd │ │ │ │ │ └── task_info.pxd │ │ │ │ ├── exception.pxd │ │ │ │ ├── task_config.pxd │ │ │ │ ├── task_config.pyi │ │ │ │ ├── task_config.pyx │ │ │ │ ├── task_context.pxd │ │ │ │ ├── task_context.pyi │ │ │ │ ├── task_context.pyx │ │ │ │ ├── task_info.pxd │ │ │ │ ├── task_info.pyi │ │ │ │ ├── task_info.pyx │ │ │ │ ├── task_signature.pxd │ │ │ │ ├── task_signature.pyx │ │ │ │ ├── variant_helper.pxd │ │ │ │ ├── variant_info.pxd │ │ │ │ ├── variant_options.pxd │ │ │ │ ├── variant_options.pyi │ │ │ │ └── variant_options.pyx │ │ │ ├── tuning │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── parallel_policy.pxd │ │ │ │ ├── parallel_policy.pyi │ │ │ │ ├── parallel_policy.pyx │ │ │ │ ├── scope.pxd │ │ │ │ ├── scope.pyi │ │ │ │ └── scope.pyx │ │ │ ├── type │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── types.pxd │ │ │ │ ├── types.pyi │ │ │ │ └── types.pyx │ │ │ └── utilities │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── abort.pxd │ │ │ │ ├── detail │ │ │ │ └── tuple.pxd │ │ │ │ ├── shared_ptr.pxd │ │ │ │ ├── tuple.pxd │ │ │ │ ├── typedefs.pxd │ │ │ │ ├── typedefs.pyi │ │ │ │ ├── typedefs.pyx │ │ │ │ ├── unconstructable.pxd │ │ │ │ ├── unconstructable.pyi │ │ │ │ ├── unconstructable.pyx │ │ │ │ ├── utils.pxd │ │ │ │ └── utils.pyx │ │ ├── data_interface.py │ │ ├── experimental │ │ │ ├── __init__.py │ │ │ └── io │ │ │ │ ├── __init__.py │ │ │ │ ├── file_handle.py │ │ │ │ ├── tile.py │ │ │ │ └── zarr.py │ │ ├── task │ │ │ └── __init__.py │ │ ├── types.py │ │ └── utils.py │ ├── dask │ │ ├── __init__.py │ │ ├── main.py │ │ └── worker.py │ ├── driver │ │ ├── __init__.py │ │ ├── args.py │ │ ├── command.py │ │ ├── config.py │ │ ├── defaults.py │ │ ├── driver.py │ │ ├── driver_exec.py │ │ ├── environment.py │ │ ├── launcher.py │ │ └── main.py │ ├── install_info.pyi │ ├── io │ │ ├── CMakeLists.txt │ │ ├── __init__.py │ │ ├── _lib │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ └── hdf5 │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── __init__.py │ │ │ │ ├── hdf5_interface.pxd │ │ │ │ ├── hdf5_interface.pyi │ │ │ │ └── hdf5_interface.pyx │ │ └── hdf5.py │ ├── issue.py │ ├── jupyter │ │ ├── __init__.py │ │ ├── _legion_kernel.py │ │ ├── args.py │ │ ├── config.py │ │ ├── kernel.py │ │ ├── magic.py │ │ └── main.py │ ├── legate_jupyter.json │ ├── lgpatch.py │ ├── py.typed │ ├── settings.py │ ├── tester │ │ ├── __init__.py │ │ ├── args.py │ │ ├── config.py │ │ ├── defaults.py │ │ ├── logger.py │ │ ├── project.py │ │ ├── runner.py │ │ ├── stages │ │ │ ├── __init__.py │ │ │ ├── _linux │ │ │ │ ├── __init__.py │ │ │ │ ├── cpu.py │ │ │ │ ├── eager.py │ │ │ │ ├── gpu.py │ │ │ │ └── omp.py │ │ │ ├── _osx │ │ │ │ ├── __init__.py │ │ │ │ ├── cpu.py │ │ │ │ ├── eager.py │ │ │ │ ├── gpu.py │ │ │ │ └── omp.py │ │ │ ├── test_stage.py │ │ │ └── util.py │ │ ├── test_plan.py │ │ └── test_system.py │ ├── timing │ │ ├── CMakeLists.txt │ │ ├── __init__.py │ │ └── _lib │ │ │ ├── CMakeLists.txt │ │ │ ├── __init__.py │ │ │ ├── timing.pxd │ │ │ ├── timing.pyi │ │ │ └── timing.pyx │ └── util │ │ ├── __init__.py │ │ ├── args.py │ │ ├── fs.py │ │ ├── info.py │ │ ├── settings.py │ │ ├── shared_args.py │ │ ├── system.py │ │ ├── types.py │ │ └── ui.py │ └── typings │ ├── IPython │ ├── __init__.pyi │ └── core │ │ └── magic.pyi │ └── jupyter_client │ ├── __init__.pyi │ └── kernelspec.pyi ├── test.py └── tests ├── cpp ├── .gitignore ├── CMakeLists.txt ├── bug │ ├── alias_via_promote.cc │ ├── aligned_unpack.cc │ ├── dangling_store_partition.cc │ ├── logical_store_transform.cc │ ├── nullable_arrays.cc │ ├── premature_free.cc │ ├── remap_double_detach.cc │ ├── singleton_index_task.cc │ ├── string_physical_array_owner.cc │ └── temporary_logical_store.cc ├── experimental │ ├── stl │ │ ├── elementwise.cc │ │ ├── fill.cc │ │ ├── for_each.cc │ │ ├── reduce.cc │ │ ├── store.cc │ │ ├── transform.cc │ │ ├── transform_reduce.cc │ │ └── views.cc │ ├── streaming.cc │ └── tracing.cc ├── integration │ ├── aligned_unbound_stores.cc │ ├── alignment_constraints.cc │ ├── attach.cc │ ├── auto_task_error.cc │ ├── bloat_constraints.cc │ ├── broadcast_constraints.cc │ ├── cal_communicator.cu │ ├── child_store.cc │ ├── consensus_match.cc │ ├── copy_failure.cc │ ├── copy_gather.cc │ ├── copy_gather_scatter.cc │ ├── copy_normal.cc │ ├── copy_scatter.cc │ ├── copy_util.inl │ ├── cpu_communicator.cc │ ├── delinearize.cc │ ├── exception.cc │ ├── field_reuse.cc │ ├── fill.cc │ ├── find_memory_kind.cc │ ├── image_constraints.cc │ ├── index_attach.cc │ ├── inline_map.cc │ ├── input_output.cc │ ├── is_partitioned.cc │ ├── is_running_in_task.cc │ ├── machine_scope.cc │ ├── manual_task.cc │ ├── manual_task_proj.cc │ ├── mixed_dim.cc │ ├── multi_scalar_out.cc │ ├── nccl.cu │ ├── partitioner.cc │ ├── proc_local_storage.cc │ ├── projection.cc │ ├── provenance.cc │ ├── redundant.cc │ ├── region_manager.cc │ ├── register_variants.cc │ ├── replicated_write.cc │ ├── req_analyzer.cc │ ├── scalar_out.cc │ ├── scale_constraints.cc │ ├── task_misc.cc │ ├── task_store │ │ ├── auto_task_tests.cc │ │ ├── manual_task_tests.cc │ │ └── task_common.h │ ├── tasks │ │ ├── task_simple.cc │ │ └── task_simple.h │ ├── tree_reduce.cc │ ├── tree_reduce_unique.cc │ ├── tunable.cc │ ├── variant_options_precedence.cc │ └── weighted.cc ├── main_with_runtime_init.cc ├── main_wo_runtime_init.cc ├── noinit │ ├── argument_parsing │ │ ├── argument.cc │ │ ├── cpus.cc │ │ ├── fbmem.cc │ │ ├── gpus.cc │ │ ├── legion_default_args.cc │ │ ├── logging.cc │ │ ├── numamem.cc │ │ ├── omps.cc │ │ ├── ompthreads.cc │ │ ├── parse_args.cc │ │ ├── scaled.cc │ │ └── sysmem.cc │ ├── config.cc │ ├── cuda_driver_api.cc │ ├── delinearize.cc │ ├── enable_shared_from_this.cc │ ├── enumerate.cc │ ├── environment_variable.cc │ ├── find_memory_kind.cc │ ├── internal_shared_ptr.cc │ ├── internal_weak_ptr.cc │ ├── is_running_in_task.cc │ ├── macros.cc │ ├── scope_fail.cc │ ├── scope_guard.cc │ ├── shared_ptr.cc │ ├── shared_ptr_util.h │ ├── span.cc │ ├── task_exception.cc │ ├── to_domain.cc │ ├── tuple.cc │ ├── variant_options.cc │ ├── zip_common.h │ ├── zip_equal.cc │ └── zip_shortest.cc ├── non_reentrant │ ├── death_example.cc │ ├── oom_message.cc │ ├── runtime.cc │ ├── shutdown_callback.cc │ └── wo_runtime │ │ ├── exception │ │ ├── base.cc │ │ ├── common.h │ │ ├── terminate_handler.cc │ │ └── traced_exception.cc │ │ └── init │ │ └── init.cc ├── unit │ ├── attachment.cc │ ├── buffer │ │ ├── task_local_buffer.cc │ │ └── typed_buffer.cc │ ├── constraint.cc │ ├── debug.cc │ ├── dispatch.cc │ ├── formatter.cc │ ├── io │ │ └── hdf5 │ │ │ └── read.cc │ ├── library.cc │ ├── logical_array │ │ ├── create_array.cc │ │ ├── delinearize.cc │ │ ├── offload_to.cc │ │ ├── project.cc │ │ ├── promote.cc │ │ ├── slice.cc │ │ ├── transpose.cc │ │ ├── utils.cc │ │ └── utils.h │ ├── logical_store │ │ ├── create_store.cc │ │ ├── delinearize.cc │ │ ├── equal_storage.cc │ │ ├── offload_to.cc │ │ ├── overlaps.cc │ │ ├── partition.cc │ │ ├── physical_store.cc │ │ ├── project.cc │ │ ├── promote.cc │ │ ├── reinterpret_as.cc │ │ ├── slice.cc │ │ └── transpose.cc │ ├── machine.cc │ ├── mapping.cc │ ├── partition │ │ ├── image.cc │ │ ├── nopartition.cc │ │ ├── tiling.cc │ │ └── weighted.cc │ ├── physical_array │ │ ├── create_array.cc │ │ ├── create_list_array.cc │ │ ├── create_string_array.cc │ │ ├── create_struct_array.cc │ │ ├── fill_array.cc │ │ ├── fill_list_array.cc │ │ └── fill_string_array.cc │ ├── physical_store │ │ ├── create_bound_store.cc │ │ ├── create_by_physical_array.cc │ │ ├── create_future_store.cc │ │ ├── create_unbound_store.cc │ │ ├── inline_allocation.cc │ │ ├── read_accessor.cc │ │ ├── read_write_accessor.cc │ │ ├── reduce_accessor.cc │ │ ├── transform.cc │ │ └── write_accessor.cc │ ├── registration.cc │ ├── runtime.cc │ ├── scalar │ │ ├── create_primitive_scalar.cc │ │ ├── create_struct_scalar.cc │ │ ├── create_vector_scalar.cc │ │ ├── negative.cc │ │ └── pack.cc │ ├── scope.cc │ ├── scoped_allocator.cc │ ├── shape.cc │ ├── task_config │ │ └── basic.cc │ ├── task_signature │ │ ├── basic.cc │ │ ├── nargs.cc │ │ ├── nargs_util.h │ │ └── register.cc │ ├── timing.cc │ ├── transform │ │ ├── delinearize.cc │ │ ├── project.cc │ │ ├── promote.cc │ │ ├── shift.cc │ │ ├── transform_stack.cc │ │ └── transpose.cc │ └── type │ │ ├── binary_type.cc │ │ ├── fixed_array_type.cc │ │ ├── list_type.cc │ │ ├── primitive_type.cc │ │ ├── string_type.cc │ │ ├── struct_type.cc │ │ ├── type_features.cc │ │ └── type_traits.cc └── utilities │ ├── dummy_cuda_driver.cc │ ├── env.h │ └── utilities.h └── python ├── integration ├── __init__.py ├── py.typed ├── test_auto_task.py ├── test_file_handle.py ├── test_hdf5.py ├── test_legate_dask.py ├── test_logicalarray.py ├── test_manual_task.py ├── test_py_task.py ├── test_runtime_data_ops.py ├── test_store_creation.py ├── test_store_operation.py ├── test_tile.py ├── test_trace.py ├── test_zarr.py └── utils │ ├── __init__.py │ ├── data.py │ ├── tasks.py │ └── utils.py └── unit ├── __init__.py ├── legate ├── __init__.py ├── core │ ├── __init__.py │ ├── test_constraints.py │ ├── test_inline_allocation.py │ ├── test_invalid_scalar_arg.py │ ├── test_is_running_in_task.py │ ├── test_library.py │ ├── test_logicalarray.py │ ├── test_machine.py │ ├── test_parallel_policy.py │ ├── test_py_task_threadstate.py │ ├── test_redop_task.py │ ├── test_resource_config.py │ ├── test_runtime.py │ ├── test_scalar.py │ ├── test_scalar_task.py │ ├── test_scope.py │ ├── test_store.py │ ├── test_symbolic_expr.py │ ├── test_task.py │ ├── test_task_config.py │ ├── test_task_context.py │ ├── test_task_info.py │ ├── test_type.py │ ├── test_type_uid.py │ ├── test_variant_options.py │ └── util │ │ ├── __init__.py │ │ ├── py.typed │ │ ├── task_util.py │ │ └── type_util.py ├── driver │ ├── __init__.py │ ├── conftest.py │ ├── test_args.py │ ├── test_command.py │ ├── test_config.py │ ├── test_defaults.py │ ├── test_driver.py │ ├── test_environment.py │ ├── test_launcher.py │ ├── test_main.py │ └── util.py ├── jupyter │ ├── __init__.py │ ├── conftest.py │ ├── test_args.py │ ├── test_config.py │ ├── test_kernel.py │ └── test_main.py ├── test___init__.py ├── test_settings.py ├── tester │ ├── __init__.py │ ├── stages │ │ ├── __init__.py │ │ ├── _linux │ │ │ ├── __init__.py │ │ │ ├── test_cpu.py │ │ │ ├── test_eager.py │ │ │ ├── test_gpu.py │ │ │ └── test_omp.py │ │ ├── _osx │ │ │ ├── __init__.py │ │ │ ├── test_cpu.py │ │ │ ├── test_eager.py │ │ │ └── test_omp.py │ │ ├── test_test_stage.py │ │ └── test_util.py │ ├── test___init__.py │ ├── test_args.py │ ├── test_config.py │ ├── test_defaults.py │ ├── test_logger.py │ ├── test_project.py │ ├── test_runner.py │ └── test_test_system.py └── util │ ├── __init__.py │ ├── sample_cmake_cache.txt │ ├── sample_header.h │ ├── test_args.py │ ├── test_fs.py │ ├── test_settings.py │ ├── test_system.py │ ├── test_types.py │ └── test_ui.py └── util.py /.dir-locals.el: -------------------------------------------------------------------------------- 1 | ;;; legate specific configuration for Emacs 2 | ((nil . ((indent-tabs-mode . nil) 3 | (tab-width . 4) 4 | (eval . (add-hook 'before-save-hook #'delete-trailing-whitespace)))) 5 | (python-mode . ((python-interpreter . (seq-find (lambda (item) (executable-find item)) '("python3" "python"))) 6 | (python-indent-offset . 4) 7 | (fill-column . 79)))) 8 | -------------------------------------------------------------------------------- /.dockerignore: -------------------------------------------------------------------------------- 1 | .gitignore -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | legate/_version.py export-subst 2 | -------------------------------------------------------------------------------- /.github/copy-pr-bot.yaml: -------------------------------------------------------------------------------- 1 | --- 2 | # Configuration file for `copy-pr-bot` GitHub App 3 | # https://docs.gha-runners.nvidia.com/apps/copy-pr-bot/ 4 | 5 | enabled: true 6 | -------------------------------------------------------------------------------- /.github/release.yml: -------------------------------------------------------------------------------- 1 | --- 2 | changelog: 3 | exclude: 4 | labels: 5 | - category:housekeeping 6 | - Build 7 | - CI 8 | - Maintenance 9 | categories: 10 | - title: 🐛 Bug Fixes 11 | labels: 12 | - category:bug-fix 13 | - Bug 14 | - title: 🚀 New Features 15 | labels: 16 | - category:new-feature 17 | - Feature 18 | - title: 🛠️ Improvements 19 | labels: 20 | - category:improvement 21 | - title: 📖 Documentation 22 | labels: 23 | - category:documentation 24 | - Docs 25 | -------------------------------------------------------------------------------- /.github/workflows/ci-gh-gasnet.yml: -------------------------------------------------------------------------------- 1 | --- 2 | name: Build Gasnet Wrapper Package 3 | 4 | concurrency: 5 | group: ${{ startsWith(github.ref_name, 'main') && format('unique-{0}', github.run_id) || format('ci-gh-gasnet-on-{0}-from-{1}', github.event_name, github.ref_name) }} 6 | cancel-in-progress: true 7 | 8 | on: 9 | workflow_dispatch: 10 | push: 11 | branches: 12 | - "pull-request/[0-9]+" 13 | - "branch-*" 14 | - "main" 15 | 16 | jobs: 17 | build: 18 | uses: 19 | ./.github/workflows/gh-gasnet.yml 20 | -------------------------------------------------------------------------------- /.github/workflows/ci-gh-mac.yml: -------------------------------------------------------------------------------- 1 | --- 2 | name: Mac build and test 3 | 4 | concurrency: 5 | group: mac-ci-build-and-test-on-${{ github.event_name }}-from-${{ github.ref_name }} 6 | cancel-in-progress: true 7 | 8 | on: 9 | # Disabled until the CI scripts are in working order again. 10 | # schedule: 11 | # # Runs at 08:00 UTC every day 12 | # - cron: '0 8 * * *' 13 | workflow_dispatch: 14 | 15 | jobs: 16 | build-and-test: 17 | name: Build and test (mac, cpu, release, ucx) 18 | uses: 19 | ./.github/workflows/gh-build-and-test.yml 20 | with: 21 | platform: mac 22 | target-device: cpu 23 | build-type: ci 24 | build-mode: release 25 | build-has-tests: true 26 | network: ucx 27 | refname: ${{ github.ref_name }} 28 | default-branch: ${{ github.event.repository.default_branch }} 29 | secrets: inherit 30 | -------------------------------------------------------------------------------- /.github/workflows/ci-gh-mpi.yml: -------------------------------------------------------------------------------- 1 | --- 2 | name: Build MPI Wrapper Package 3 | 4 | concurrency: 5 | group: ${{ startsWith(github.ref_name, 'main') && format('unique-{0}', github.run_id) || format('ci-gh-mpi-{0}-from-{1}', github.event_name, github.ref_name) }} 6 | cancel-in-progress: true 7 | 8 | on: 9 | workflow_dispatch: 10 | push: 11 | branches: 12 | - "pull-request/[0-9]+" 13 | - "branch-*" 14 | - "main" 15 | 16 | jobs: 17 | build: 18 | uses: 19 | ./.github/workflows/gh-mpi.yml 20 | -------------------------------------------------------------------------------- /.github/workflows/require-labels.yml: -------------------------------------------------------------------------------- 1 | --- 2 | name: Pull Request Labels 3 | 4 | concurrency: 5 | group: label-check-${{ github.event_name }}-from-${{ github.ref_name }} 6 | cancel-in-progress: true 7 | 8 | on: 9 | pull_request: 10 | types: [opened, labeled, unlabeled, synchronize] 11 | merge_group: 12 | jobs: 13 | label: 14 | runs-on: ubuntu-latest 15 | steps: 16 | - name: Check Labels 17 | uses: mheap/github-action-required-labels@v5 18 | with: 19 | mode: minimum 20 | count: 1 21 | labels: | 22 | category:new-feature 23 | category:improvement 24 | category:bug-fix 25 | category:housekeeping 26 | category:documentation, 27 | Bug 28 | Build 29 | CI 30 | Docs 31 | Feature 32 | Maintenance 33 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | \#*# 3 | */typestubs/* 4 | .#* 5 | .DS_Store 6 | *.a 7 | *.d 8 | *.o 9 | *.so 10 | *.gz 11 | *.gcno 12 | *.gcda 13 | *.gcov 14 | *.fluid 15 | *.pyc 16 | *.swp 17 | *.log 18 | *.bbl 19 | *.blg 20 | *.aux 21 | *.json 22 | *.dylib 23 | install_info.py 24 | /dist 25 | /build*/ 26 | /legion 27 | /install* 28 | _skbuild/ 29 | config.mk 30 | /docs/legate/build 31 | docs/legate/source/api/python/generated/ 32 | docs/legate/source/generated/ 33 | *.egg-info 34 | .cache 35 | .coverage 36 | .vscode 37 | _cmake_test_compile 38 | !cmake/versions.json 39 | legate.code-workspace 40 | *.prof 41 | examples/cpp/build 42 | tests/cpp/build 43 | .legate-test-last-failed 44 | out/ 45 | .artifacts/ 46 | venv/ 47 | !cmake/presets/*.json 48 | !CMakePresets.json 49 | arch-* 50 | configure.log 51 | reconfigure-* 52 | *-arch 53 | *_venv 54 | _version.py 55 | scripts/get_legate_arch\.py 56 | -------------------------------------------------------------------------------- /conda/conda-build/conda_build_config.yaml: -------------------------------------------------------------------------------- 1 | --- 2 | build_mode_str: 3 | - debug 4 | - debug-sanitizer 5 | - release 6 | - release-debug 7 | 8 | upload_enabled: 9 | - true 10 | - false 11 | 12 | build_tests: 13 | - true 14 | - false 15 | 16 | network: 17 | - ucx 18 | - gex 19 | 20 | gpu_enabled: 21 | - true 22 | - false 23 | 24 | python: 25 | - 3.11 26 | - 3.12 27 | - 3.13 28 | 29 | numpy_version: 30 | # Not 2.1.0 which segfaults on asarray() sometimes, see 31 | # https://github.com/numpy/numpy/pull/27249 32 | - ">=1.22,!=2.1.0" 33 | 34 | cmake_version: 35 | - ">=3.26.4" 36 | 37 | cuda_compiler: 38 | - cuda-nvcc 39 | -------------------------------------------------------------------------------- /conda/gasnet_wrapper/activate.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | echo -e "\n\n--------------------- CONDA/GASNET_WRAPPER/ACTIVATE.SH -----------------------\n" 3 | 4 | # shellcheck disable=SC2154 5 | wrapper_file=$(find "${CONDA_PREFIX}/gex-wrapper" \( -name "librealm_gex_wrapper.so" -o -name "librealm_gex_wrapper.dylib" \) -print -quit) 6 | export REALM_GASNETEX_WRAPPER="${wrapper_file}" 7 | # WAR for: 8 | # https://gasnet-bugs.lbl.gov/bugzilla/show_bug.cgi?id=4638 9 | export GASNET_OFI_SPAWNER=mpi 10 | export FI_CXI_RDZV_THRESHOLD=256 11 | 12 | echo "REALM_GASNETEX_WRAPPER=${REALM_GASNETEX_WRAPPER}" 13 | echo "GASNET_OFI_SPAWNER=${GASNET_OFI_SPAWNER}" 14 | echo "FI_CXI_RDZV_THRESHOLD=${FI_CXI_RDZV_THRESHOLD}" 15 | -------------------------------------------------------------------------------- /conda/gasnet_wrapper/conda_build_config.yaml: -------------------------------------------------------------------------------- 1 | --- 2 | version: 3 | - 0.0.1 4 | -------------------------------------------------------------------------------- /conda/gasnet_wrapper/deactivate.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | echo -e "\n\n--------------------- CONDA/GASNET_WRAPPER/DEACTIVATE.SH -----------------------\n" 3 | 4 | unset REALM_GASNETEX_WRAPPER 5 | unset GASNET_OFI_SPAWNER 6 | unset FI_CXI_RDZV_THRESHOLD 7 | -------------------------------------------------------------------------------- /conda/gasnet_wrapper/meta.yaml: -------------------------------------------------------------------------------- 1 | --- 2 | {% set name = "realm-gex-wrapper" %} 3 | {% set major_version = (version|string).split(".")[0] %} 4 | {% set minor_version = (version|string).split(".")[1] %} 5 | {% set patch_version = (version|string).split(".")[2] %} 6 | 7 | package: 8 | name: {{ name|lower }} 9 | version: {{ version }} 10 | 11 | source: 12 | git_url: https://gitlab.com/StanfordLegion/legion.git 13 | 14 | build: 15 | include_recipe: false 16 | number: 14 17 | skip: true # [not linux] 18 | noarch: generic 19 | script_env: 20 | - PKG_NAME={{ name }} 21 | 22 | extra: 23 | recipe-maintainers: 24 | - m3vaz 25 | - marcinz 26 | -------------------------------------------------------------------------------- /conda/gasnet_wrapper/post-link.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # shellcheck disable=SC2154 3 | cat << EOF >> "${PREFIX}/.messages.txt" 4 | 5 | To finish configuring the Realm GASNet-EX wrapper, activate your environment and run ${CONDA_PREFIX}/gex-wrapper/build-gex-wrapper.sh 6 | 7 | EOF 8 | -------------------------------------------------------------------------------- /conda/gasnet_wrapper/pre-unlink.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | echo -e "\n\n--------------------- CONDA/GASNET_WRAPPER/PREUNLINK.SH -----------------------\n" 3 | 4 | set -eo pipefail 5 | echo "Remove the built artifacts" 6 | # shellcheck disable=SC2154 7 | rm -rf "${CONDA_PREFIX}/gex-wrapper/lib*" 8 | -------------------------------------------------------------------------------- /conda/legate_profiler/build.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | echo -e "\n\n--------------------- CONDA/LEGATE-PROFILER/BUILD.SH -----------------------\n" 4 | 5 | set -xeo pipefail 6 | 7 | # Build the legate profiler 8 | echo "Building legate-profiler..." 9 | # shellcheck disable=SC2154 10 | GIT_COMMIT=$(git -C "${SRC_DIR}" rev-parse HEAD) 11 | echo "Legion checked-out with commit: ${GIT_COMMIT}" 12 | 13 | # Navigate to the legate-profiler directory and build it 14 | # shellcheck disable=SC2154 15 | LIBCLANG_PATH=${BUILD_PREFIX}/lib cargo install --path "${SRC_DIR}"/tools/legion_prof_rs --all-features --root "${PREFIX}" 16 | echo "Done" 17 | -------------------------------------------------------------------------------- /conda/legate_profiler/conda_build_config.yaml: -------------------------------------------------------------------------------- 1 | --- 2 | LEGION_GIT_URL: 3 | - https://gitlab.com/StanfordLegion/legion.git 4 | LEGION_GIT_SHALLOW: 5 | - false 6 | rust_min_version: 7 | - "1.84" 8 | -------------------------------------------------------------------------------- /conda/legate_profiler/dummy_legate/build.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | echo -e "\n\n--------------------- CONDA/LEGATE-PROFILER/DUMMY-LEGATE/BUILD.SH -----------------------\n" 4 | 5 | set -ex 6 | echo "Dummy Legate build completed successfully." 7 | -------------------------------------------------------------------------------- /conda/mpi_wrapper/activate.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | echo -e "\n\n--------------------- CONDA/MPI_WRAPPER/ACTIVATE.SH -----------------------\n" 3 | 4 | # shellcheck disable=SC2154 5 | wrapper_file=$(find "${CONDA_PREFIX}/mpi-wrapper" -regex ".*/liblegate_mpi_wrapper\.\(so\|dylib\)" -print -quit) 6 | export LEGATE_MPI_WRAPPER="${wrapper_file}" 7 | echo "LEGATE_MPI_WRAPPER=${LEGATE_MPI_WRAPPER}" 8 | -------------------------------------------------------------------------------- /conda/mpi_wrapper/build.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | echo -e "\n\n--------------------- CONDA/MPI_WRAPPER/BUILD.SH -----------------------\n" 3 | 4 | set -eou pipefail 5 | 6 | # shellcheck disable=SC2154 7 | cp -rv "${SRC_DIR}/share/legate/mpi_wrapper" "${PREFIX}/mpi-wrapper" 8 | # shellcheck disable=SC2154 9 | cp -rv "${RECIPE_DIR}/build-mpi-wrapper.sh" "${PREFIX}/mpi-wrapper" 10 | 11 | # Copy the [de]activate scripts to ${PREFIX}/etc/conda/[de]activate.d. 12 | # This will allow them to be run on environment activation. 13 | for CHANGE in "activate" "deactivate" 14 | do 15 | mkdir -p "${PREFIX}/etc/conda/${CHANGE}.d" 16 | # shellcheck disable=SC2154 17 | cp "${RECIPE_DIR}/${CHANGE}.sh" "${PREFIX}/etc/conda/${CHANGE}.d/${PKG_NAME}_${CHANGE}.sh" 18 | done 19 | -------------------------------------------------------------------------------- /conda/mpi_wrapper/conda_build_config.yaml: -------------------------------------------------------------------------------- 1 | --- 2 | version: 3 | - 1.0 4 | -------------------------------------------------------------------------------- /conda/mpi_wrapper/deactivate.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | echo -e "\n\n--------------------- CONDA/MPI_WRAPPER/DEACTIVATE.SH -----------------------\n" 3 | 4 | unset LEGATE_MPI_WRAPPER 5 | -------------------------------------------------------------------------------- /conda/mpi_wrapper/meta.yaml: -------------------------------------------------------------------------------- 1 | --- 2 | {% set name = "legate-mpi-wrapper" %} 3 | {% set major_version = (version|string).split(".")[0] %} 4 | {% set minor_version = (version|string).split(".")[1] %} 5 | {% set patch_version = (version|string).split(".")[2] %} 6 | 7 | package: 8 | name: {{ name|lower }} 9 | version: {{ version }} 10 | 11 | source: 12 | git_url: ../../ 13 | 14 | build: 15 | include_recipe: false 16 | number: 19 17 | skip: true # [not linux] 18 | noarch: generic 19 | script_env: 20 | - PKG_NAME={{ name }} 21 | 22 | extra: 23 | recipe-maintainers: 24 | - m3vaz 25 | - marcinz 26 | -------------------------------------------------------------------------------- /conda/mpi_wrapper/post-link.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # shellcheck disable=SC2154 3 | cat << EOF >> "${PREFIX}/.messages.txt" 4 | 5 | To finish configuring the Legate MPI wrapper, activate your environment and run ${CONDA_PREFIX}/mpi-wrapper/build-mpi-wrapper.sh 6 | 7 | EOF 8 | -------------------------------------------------------------------------------- /conda/mpi_wrapper/pre-unlink.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | echo -e "\n\n--------------------- CONDA/MPI_WRAPPER/PREUNLINK.SH -----------------------\n" 3 | 4 | set -eo pipefail 5 | echo "Remove the built artifacts" 6 | # shellcheck disable=SC2154 7 | MPI_WRAPPER_DIR="${CONDA_PREFIX}/mpi-wrapper" 8 | rm -rf "${MPI_WRAPPER_DIR}/include" "${MPI_WRAPPER_DIR}/lib*" 9 | -------------------------------------------------------------------------------- /config/__init__.py: -------------------------------------------------------------------------------- 1 | # SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES.B 2 | # All rights reserved. 3 | # SPDX-License-Identifier: Apache-2.0 4 | from __future__ import annotations 5 | -------------------------------------------------------------------------------- /config/examples/arch-legion-src-dir.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | from __future__ import annotations 3 | 4 | import sys 5 | from pathlib import Path 6 | 7 | sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent)) 8 | 9 | from config.ensure_aedifix import ensure_aedifix # noqa: E402 10 | 11 | ensure_aedifix() 12 | 13 | from aedifix.main import basic_configure # noqa: E402 14 | from config.legate_internal.main_package import Legate # noqa: E402 15 | 16 | 17 | def main() -> int: 18 | argv = [ 19 | f"--LEGATE_ARCH={Path(__file__).stem}", 20 | "--with-tests", 21 | "--build-type=release", 22 | "--with-legion-src-dir=../legion", 23 | ] + sys.argv[1:] 24 | return basic_configure(tuple(argv), Legate) 25 | 26 | 27 | if __name__ == "__main__": 28 | sys.exit(main()) 29 | -------------------------------------------------------------------------------- /config/examples/arch-linux-cuda-local-debug.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | from __future__ import annotations 3 | 4 | import sys 5 | from pathlib import Path 6 | 7 | sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent)) 8 | 9 | from config.ensure_aedifix import ensure_aedifix # noqa: E402 10 | 11 | ensure_aedifix() 12 | 13 | from aedifix.main import basic_configure 14 | from config.legate_internal.main_package import Legate # noqa: E402 15 | 16 | 17 | def main() -> int: 18 | argv = [ 19 | f"--LEGATE_ARCH={Path(__file__).stem}", 20 | "--build-type=debug", 21 | "--with-cuda", 22 | "--with-cuda-dir=/usr/local/cuda", 23 | "--with-cudac=/usr/local/cuda/bin/nvcc", 24 | ] + sys.argv[1:] 25 | return basic_configure(tuple(argv), Legate) 26 | 27 | 28 | if __name__ == "__main__": 29 | sys.exit(main()) 30 | -------------------------------------------------------------------------------- /config/legate_internal/__init__.py: -------------------------------------------------------------------------------- 1 | # SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. 2 | # All rights reserved. 3 | # SPDX-License-Identifier: Apache-2.0 4 | from __future__ import annotations 5 | -------------------------------------------------------------------------------- /config/legate_internal/packages/__init__.py: -------------------------------------------------------------------------------- 1 | # SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. 2 | # All rights reserved. 3 | # SPDX-License-Identifier: Apache-2.0 4 | from __future__ import annotations 5 | -------------------------------------------------------------------------------- /config/py.typed: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nv-legate/legate/6df7db548884c1a9145b7cd95596aaed6e1eb784/config/py.typed -------------------------------------------------------------------------------- /continuous_integration/post_py.patch: -------------------------------------------------------------------------------- 1 | --- post.py 2023-11-09 19:56:28.379241491 +0530 2 | +++ post.py 2023-11-09 20:31:28.547995042 +0530 3 | @@ -463,7 +463,7 @@ 4 | 5 | def mk_relative_osx(path, host_prefix, m, files, rpaths=("lib",)): 6 | base_prefix = m.config.build_folder 7 | - assert base_prefix == dirname(host_prefix) 8 | + 9 | build_prefix = m.config.build_prefix 10 | prefix = build_prefix if exists(build_prefix) else host_prefix 11 | names = macho.otool(path, prefix) 12 | -------------------------------------------------------------------------------- /continuous_integration/requirements-build.txt: -------------------------------------------------------------------------------- 1 | --extra-index-url=https://pypi.anaconda.org/rapidsai-wheels-nightly/simple 2 | --extra-index-url=https://pypi.nvidia.com 3 | cmake>=3.26.4,!=3.30.0 4 | ninja 5 | nvidia-nccl-cu12 6 | libucx-cu12 7 | nvidia-libcal-cu12 8 | scikit-build-core[pyproject]>=0.10.0 9 | setuptools_scm 10 | cython 11 | -------------------------------------------------------------------------------- /continuous_integration/scripts/make-conda-env: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -euo pipefail 4 | 5 | export RAPIDS_SCRIPT_NAME="make-conda-env" 6 | 7 | . "$(dirname "$0")/tools/legate-conda-utils" 8 | 9 | make_conda_env() { 10 | case "$1" in 11 | ci) make_release_env;; 12 | nightly) make_release_env;; 13 | profiler) make_release_env ;; 14 | docs) get_yaml_and_make_conda_env;; 15 | *) return 1;; 16 | esac 17 | 18 | return 0; 19 | } 20 | 21 | (make_conda_env "$@"); 22 | -------------------------------------------------------------------------------- /continuous_integration/scripts/test_wheel_linux.bash: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | # SPDX-FileCopyrightText: Copyright (c) 2025-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | # SPDX-License-Identifier: Apache-2.0 5 | 6 | set -euo pipefail 7 | 8 | export RAPIDS_SCRIPT_NAME="test_sheel_linux.bash" 9 | 10 | rapids-logger "Are my wheels there???" 11 | 12 | ls -lh 13 | 14 | ls -lh final-dist 15 | 16 | rapids-pip-retry install final-dist/*.whl 17 | 18 | rapids-logger "Lamest of proof of life tests for legate" 19 | export LEGATE_SHOW_CONFIG=1 20 | export LEGATE_CONFIG="--fbmem 512" 21 | export LEGION_DEFAULT_ARGS="-ll:show_rsrv" 22 | python -c 'import legate.core' 23 | rapids-logger "Maybe that worked" 24 | -------------------------------------------------------------------------------- /continuous_integration/scripts/tools/legate-configure-sccache: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # A utility script that configures sccache environment variables 3 | 4 | export CMAKE_CUDA_COMPILER_LAUNCHER=sccache 5 | export CMAKE_CXX_COMPILER_LAUNCHER=sccache 6 | export CMAKE_C_COMPILER_LAUNCHER=sccache 7 | export RUSTC_WRAPPER=sccache 8 | export PARALLEL_LEVEL=${PARALLEL_LEVEL:-$(nproc --all --ignore=2)} 9 | export SCCACHE_BUCKET=rapids-sccache-east 10 | export SCCACHE_IDLE_TIMEOUT=32768 11 | export SCCACHE_REGION=us-east-2 12 | export SCCACHE_S3_KEY_PREFIX=legate-cunumeric-dev 13 | export SCCACHE_S3_NO_CREDENTIALS=false 14 | export SCCACHE_S3_USE_SSL=true 15 | 16 | if [[ "${CI:-false}" == "false" ]]; then 17 | # Configure sccache for read-only mode since no credentials 18 | # are available in local builds. 19 | export SCCACHE_S3_NO_CREDENTIALS=true 20 | fi 21 | -------------------------------------------------------------------------------- /continuous_integration/scripts/ucc-cmake-config/ucc-config.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 3 | # 4 | 5 | include("${CMAKE_CURRENT_LIST_DIR}/ucc-targets.cmake") 6 | 7 | set(UCC_LIBRARIES "${exec_prefix}/lib") 8 | set(UCC_INCLUDE_DIRS "${prefix}/include") 9 | -------------------------------------------------------------------------------- /continuous_integration/scripts/ucc-cmake-config/ucc-targets.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) 2021-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 3 | # 4 | 5 | set(prefix ${CMAKE_CURRENT_LIST_DIR}/../../..) 6 | set(exec_prefix "${prefix}") 7 | 8 | add_library(ucc::ucc SHARED IMPORTED) 9 | 10 | set_target_properties(ucc::ucc PROPERTIES 11 | IMPORTED_LOCATION "${exec_prefix}/lib/libucc.so" 12 | INTERFACE_INCLUDE_DIRECTORIES "${prefix}/include" 13 | ) 14 | -------------------------------------------------------------------------------- /docs/figures/developer-build.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nv-legate/legate/6df7db548884c1a9145b7cd95596aaed6e1eb784/docs/figures/developer-build.png -------------------------------------------------------------------------------- /docs/legate/source/BUILD.rst: -------------------------------------------------------------------------------- 1 | ../../../BUILD.rst -------------------------------------------------------------------------------- /docs/legate/source/CONTRIBUTING.rst: -------------------------------------------------------------------------------- 1 | ../../../CONTRIBUTING.rst -------------------------------------------------------------------------------- /docs/legate/source/_static/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nv-legate/legate/6df7db548884c1a9145b7cd95596aaed6e1eb784/docs/legate/source/_static/.keep -------------------------------------------------------------------------------- /docs/legate/source/_templates/class.rst: -------------------------------------------------------------------------------- 1 | {{ fullname | escape | underline }} 2 | 3 | .. currentmodule:: {{ module }} 4 | 5 | .. autoclass:: {{ objname }} 6 | 7 | .. automethod:: {{ objname }}.__init__ 8 | 9 | {% block attributes %} 10 | {% if attributes %} 11 | .. rubric:: Attributes 12 | 13 | .. autosummary:: 14 | :toctree: . 15 | {% for item in attributes %} 16 | {%- if item != '__doc__' %} 17 | ~{{ name }}.{{ item }} 18 | {%- endif -%} 19 | {%- endfor %} 20 | {% endif %} 21 | {% endblock %} 22 | 23 | {% block methods %} 24 | {% if methods %} 25 | .. rubric:: Methods 26 | 27 | .. autosummary:: 28 | :toctree: . 29 | {% for item in methods %} 30 | {%- if item != '__init__' %} 31 | ~{{ name }}.{{ item }} 32 | {%- endif -%} 33 | {%- endfor %} 34 | {% endif %} 35 | {% endblock %} 36 | -------------------------------------------------------------------------------- /docs/legate/source/_templates/layout.html: -------------------------------------------------------------------------------- 1 | {% extends "!layout.html" %} 2 | 3 | {% block extrahead %} 4 | 5 | 6 | 7 | {% endblock %} 8 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/data.rst: -------------------------------------------------------------------------------- 1 | ~~~~ 2 | Data 3 | ~~~~ 4 | 5 | .. doxygengroup:: data 6 | :protected-members: 7 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/index.rst: -------------------------------------------------------------------------------- 1 | ~~~~~~~~~~~~~~~~~ 2 | C++ API Reference 3 | ~~~~~~~~~~~~~~~~~ 4 | 5 | .. toctree:: 6 | :maxdepth: 1 7 | 8 | data 9 | partitioning 10 | runtime 11 | mapping 12 | tuning 13 | types 14 | typedefs 15 | task 16 | util 17 | 18 | Experimental API 19 | ---------------- 20 | 21 | .. toctree:: 22 | :maxdepth: 1 23 | 24 | io 25 | ../../legate.stl/source/reference/index 26 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/io.rst: -------------------------------------------------------------------------------- 1 | ~~~ 2 | IO 3 | ~~~ 4 | 5 | .. doxygengroup:: io 6 | :members: 7 | 8 | HDF5 9 | ==== 10 | 11 | .. doxygengroup:: io-hdf5 12 | :members: 13 | 14 | KVikIO 15 | ====== 16 | 17 | .. doxygengroup:: io-kvikio 18 | :members: 19 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/partitioning.rst: -------------------------------------------------------------------------------- 1 | ~~~~~~~~~~~~ 2 | Partitioning 3 | ~~~~~~~~~~~~ 4 | 5 | .. doxygengroup:: partitioning 6 | :members: 7 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/runtime.rst: -------------------------------------------------------------------------------- 1 | ~~~~~~~ 2 | Runtime 3 | ~~~~~~~ 4 | 5 | .. doxygengroup:: runtime 6 | :protected-members: 7 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/task.rst: -------------------------------------------------------------------------------- 1 | ~~~~ 2 | Task 3 | ~~~~ 4 | 5 | .. doxygengroup:: task 6 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/tuning.rst: -------------------------------------------------------------------------------- 1 | ~~~~~~ 2 | Tuning 3 | ~~~~~~ 4 | 5 | .. doxygengroup:: tuning 6 | :protected-members: 7 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/typedefs.rst: -------------------------------------------------------------------------------- 1 | ~~~~~~~~ 2 | Typedefs 3 | ~~~~~~~~ 4 | 5 | Geometry 6 | -------- 7 | 8 | .. doxygengroup:: geometry 9 | 10 | 11 | Accessor 12 | -------- 13 | 14 | .. doxygengroup:: accessor 15 | 16 | Iterator 17 | -------- 18 | 19 | .. doxygengroup:: iterator 20 | 21 | Machine 22 | ------- 23 | 24 | .. doxygengroup:: machine 25 | 26 | Reduction 27 | --------- 28 | 29 | .. doxygengroup:: reduction 30 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/types.rst: -------------------------------------------------------------------------------- 1 | ~~~~~ 2 | Types 3 | ~~~~~ 4 | 5 | .. doxygengroup:: types 6 | -------------------------------------------------------------------------------- /docs/legate/source/api/cpp/util.rst: -------------------------------------------------------------------------------- 1 | ~~~~ 2 | Util 3 | ~~~~ 4 | 5 | .. doxygengroup:: util 6 | -------------------------------------------------------------------------------- /docs/legate/source/api/index.rst: -------------------------------------------------------------------------------- 1 | API Reference 2 | ============= 3 | 4 | .. toctree:: 5 | :maxdepth: 2 6 | :caption: Contents: 7 | 8 | Python API Reference 9 | C++ API Reference 10 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/auto_task.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Auto Tasks 4 | ========== 5 | 6 | ``AutoTask`` represents a unit of work that can be split in flexible ways. The "auto" in 7 | ``AutoTask`` refers to the fact that the task launch is automatically parallelized by the 8 | runtime. On launch, the runtime will determine how many leaf tasks to instantiate, which 9 | pieces of the arguments each leaf task will access, and what processor each leaf task will 10 | be placed on. 11 | 12 | See ``ManualTask`` for tasks which need to be manually parallelized. 13 | 14 | 15 | .. autosummary:: 16 | :toctree: generated/ 17 | :template: class.rst 18 | 19 | AutoTask 20 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/classes.rst: -------------------------------------------------------------------------------- 1 | ------- 2 | Classes 3 | ------- 4 | 5 | .. toctree:: 6 | :maxdepth: 2 7 | 8 | runtime 9 | operation 10 | logical_store 11 | logical_array 12 | physical_store 13 | physical_array 14 | scalar 15 | machine 16 | shape 17 | variant_options 18 | resource_config 19 | task_context 20 | domain 21 | task_config 22 | task_local_buffer 23 | inline_allocation 24 | symbolic_expr 25 | auto_task 26 | manual_task 27 | constraint 28 | variable 29 | library 30 | scope 31 | parallel_policy 32 | types 33 | .. partition 34 | .. legion 35 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/constraint.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Constraints 4 | =========== 5 | 6 | ``Constraint`` represents a specific partitioning constraint imposed on an argument to a 7 | task. For example, the ``broadcast()`` constraint requires that all leaf tasks get a 8 | complete copy of the argument, instead of a subset. ``align()`` on the other hand mandates 9 | that two arguments must be partitioned in the same way (their pieces align each other). 10 | 11 | 12 | .. autosummary:: 13 | :toctree: generated/ 14 | :template: class.rst 15 | 16 | Constraint 17 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/domain.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Domains 4 | ======= 5 | 6 | ``DomainPoint`` and ``Domain`` allow the user to specify specific points or dense 7 | rectangles within N-dimensional spaces. They are often used as task "indices" (to locate a 8 | specific point task within a wider array of tasks), and to describe the overall launch 9 | domain of tasks. 10 | 11 | Being essentially a tuple and a pair of tuples, however, they are also more generally 12 | useful. 13 | 14 | .. autosummary:: 15 | :toctree: generated/ 16 | :template: class.rst 17 | 18 | DomainPoint 19 | Domain 20 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/index.rst: -------------------------------------------------------------------------------- 1 | ~~~~~~~~~~~~~~~~~~~~ 2 | Python API Reference 3 | ~~~~~~~~~~~~~~~~~~~~ 4 | 5 | .. currentmodule:: legate 6 | 7 | .. toctree:: 8 | :maxdepth: 2 9 | 10 | routines 11 | classes 12 | tasks 13 | settings 14 | 15 | 16 | Experimental API 17 | ---------------- 18 | 19 | .. toctree:: 20 | :maxdepth: 2 21 | 22 | io/index 23 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/inline_allocation.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Inline Allocations 4 | ================== 5 | 6 | ``InlineAllocation`` represents the raw memory and strides held by a ``PhysicalStore``. It 7 | may be used to directly modify the underlying values. 8 | 9 | 10 | .. autosummary:: 11 | :toctree: generated/ 12 | :template: class.rst 13 | 14 | InlineAllocation 15 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/io/index.rst: -------------------------------------------------------------------------------- 1 | .. _label_io: 2 | 3 | .. currentmodule:: legate.core.experimental.io 4 | 5 | === 6 | I/O 7 | === 8 | 9 | Utilities for serializing and deserializing Legate stores. 10 | 11 | HDF5 12 | ==== 13 | 14 | API 15 | --- 16 | 17 | .. currentmodule:: legate.io.hdf5 18 | 19 | .. autosummary:: 20 | :toctree: ../generated/ 21 | 22 | from_file 23 | kerchunk_read 24 | 25 | KVikIO 26 | ====== 27 | 28 | .. currentmodule:: legate.core.experimental.io.file_handle 29 | 30 | .. autosummary:: 31 | :toctree: ../generated/ 32 | 33 | from_file 34 | to_file 35 | 36 | .. autosummary:: 37 | :toctree: ../generated/ 38 | :template: class.rst 39 | 40 | FileHandle 41 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/library.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Library 4 | ======= 5 | 6 | A ``Library`` represents a namespace for a collection of tasks. 7 | 8 | 9 | .. autosummary:: 10 | :toctree: generated/ 11 | :template: class.rst 12 | 13 | Library 14 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/logical_array.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Arrays 4 | ====== 5 | 6 | ``LogicalArray`` represents a set of one or more ``LogicalStore``s that are partitioned in 7 | a related way, to synthesize a more sophisticated data container. For example, an 8 | integer-type ``LogicalStore`` can be combined with a boolean-type ``LogicalStore`` of the 9 | same size to create a masked integer array. 10 | 11 | 12 | .. autosummary:: 13 | :toctree: generated/ 14 | :template: class.rst 15 | 16 | LogicalArray 17 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/manual_task.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Manual Tasks 4 | ============ 5 | 6 | Where ``AutoTask`` s are parallelized automatically by the runtime, ``ManualTask`` is 7 | parallelized explicitly by the user. Usually it suffices to allow the runtime to 8 | parallelize a task, but sometimes a more fine-grained approach is needed. In this case, a 9 | user may construct a ``ManualTask`` and describe exactly the manner in which arguments are 10 | partitioned. 11 | 12 | 13 | .. autosummary:: 14 | :toctree: generated/ 15 | :template: class.rst 16 | 17 | ManualTask 18 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/parallel_policy.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | ParallelPolicy 4 | ============== 5 | 6 | ``ParallelPolicy`` allows users to to control the parallelization policy for tasks in a given scope. 7 | 8 | .. autosummary:: 9 | :toctree: generated/ 10 | :template: class.rst 11 | 12 | ParallelPolicy 13 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/physical_array.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Physical Array 4 | ============== 5 | 6 | Like ``PhysicalStore``, ``PhysicalArray`` is the manifestation of a ``LogicalArray`` 7 | within a task. 8 | 9 | .. autosummary:: 10 | :toctree: generated/ 11 | :template: class.rst 12 | 13 | PhysicalArray 14 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/physical_store.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Physical Store 4 | ============== 5 | 6 | The ``PhysicalStore`` is the manifestation of (part of) a ``LogicalStore`` within a 7 | task. Where ``LogicalStore`` can be used to abstractly describe the full dataset, with 8 | additional transformations at the logical level (e.g. transposing, reshaping, slicing), 9 | the ``PhysicalStore`` represents the actual piece of the data that a task is accessing. 10 | 11 | 12 | .. autosummary:: 13 | :toctree: generated/ 14 | :template: class.rst 15 | 16 | PhysicalStore 17 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/resource_config.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | ResourceConfig 4 | ============== 5 | 6 | The ``ResourceConfig`` class allows dictating the task resources available for a 7 | ``Library``. 8 | 9 | .. autosummary:: 10 | :toctree: generated/ 11 | :template: class.rst 12 | 13 | ResourceConfig 14 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/routines.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | -------- 4 | Routines 5 | -------- 6 | 7 | .. autosummary:: 8 | :toctree: generated/ 9 | 10 | get_legate_runtime 11 | get_machine 12 | track_provenance 13 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/scalar.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Scalar 4 | ====== 5 | 6 | ``Scalar`` represents a single, immutable value within a task. These are usually small or 7 | trivially copyable types. Unlike ``LogicalStore`` or ``LogicalArray`` which are 8 | partitioned and split across tasks for a particular task launch, ``Scalar`` s are always 9 | copied across all instances. 10 | 11 | 12 | .. autosummary:: 13 | :toctree: generated/ 14 | :template: class.rst 15 | 16 | Scalar 17 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/scope.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Execution Scope 4 | =============== 5 | 6 | ``Scope`` allows users to specify restrictions on the runtime's behavior within a given 7 | block of code. For example, the user may specify that a particular set of tasks may only 8 | execute on GPUs, or that a particular set of tasks may only execute on CPUs 1 through 9. 9 | 10 | .. autosummary:: 11 | :toctree: generated/ 12 | :template: class.rst 13 | 14 | Scope 15 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/settings.rst: -------------------------------------------------------------------------------- 1 | 2 | Settings 3 | ======== 4 | 5 | Legate has a number of runtime settings that can be configured through 6 | environment variables. 7 | 8 | .. settings:: settings 9 | :module: legate.settings 10 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/shape.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Shape 4 | ===== 5 | 6 | A ``Shape`` is used in expressing the shape of a certain entity in Legate. The 7 | reason Legate introduces this indirection to the shape metadata is that stores 8 | in Legate can have unknown shapes at creation time; the shape of an unbound 9 | store is determined only when the producer task finishes. The shape object can 10 | help the runtime query the store's metadata or construct another store 11 | isomorphic to the store without getting blocked. 12 | 13 | Shape objects should behave just like an array of integers, but operations that 14 | introspect the values implicitly block on completion of the producer task. 15 | 16 | 17 | .. autosummary:: 18 | :toctree: generated/ 19 | :template: class.rst 20 | 21 | Shape 22 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/symbolic_expr.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Symbolic Expressions 4 | ==================== 5 | 6 | ``SymbolicExpr`` is a helper class for symbolically representing coordinates, used to 7 | specify the parallel launch of a ``ManualTask``. 8 | 9 | 10 | .. autosummary:: 11 | :toctree: generated/ 12 | :template: class.rst 13 | 14 | SymbolicExpr 15 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/task_config.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Task Configuration 4 | ================== 5 | 6 | ``TaskConfig`` allows specifying additional configuration options (such as the task ID and 7 | task-wide default ``VariantOptions``) for a task. 8 | 9 | .. autosummary:: 10 | :toctree: generated/ 11 | :template: class.rst 12 | 13 | TaskConfig 14 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/task_context.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Task Context 4 | ============ 5 | 6 | The ``TaskContext`` class contains the inputs, outputs, scalars, reductions, and other 7 | task information during a task's execution. It is normally hidden from users using pure 8 | :ref:`Python tasks `, but can be explicitly requested via a task 9 | argument. See :ref:`label_explicit_task_context_argument` for further discussion. 10 | 11 | .. autosummary:: 12 | :toctree: generated/ 13 | :template: class.rst 14 | 15 | TaskContext 16 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/task_local_buffer.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Task-Local Buffers 4 | ================== 5 | 6 | ``TaskLocalBuffer`` is a buffer allocated during task execution for use as temporary 7 | storage, or to later "bind" to an unbound ``PhysicalStore``. The lifetime of the buffer is 8 | that of the task body. If the buffer was bound to a store, then the memory of the buffer 9 | is transferred to the store on completion of the task. If the buffer was not bound to a 10 | store, then the buffer is destroyed and the memory is reclaimed by the runtime. 11 | 12 | 13 | .. autosummary:: 14 | :toctree: generated/ 15 | :template: class.rst 16 | 17 | TaskLocalBuffer 18 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/types.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Types 4 | ===== 5 | 6 | ``Type`` is the fundamental unit of the type system in Legate. Compound types may be 7 | constructed using ``StrucType``, with special support provided for array-like types in 8 | ``FixedArrayType``. 9 | 10 | These types are usually used in the construction of the higher-level container classes 11 | (such as ``LogicalArray``, ``LogicalStore``, or ``Scalar``). 12 | 13 | 14 | .. autosummary:: 15 | :toctree: generated/ 16 | :template: class.rst 17 | 18 | Type 19 | StructType 20 | FixedArrayType 21 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/variable.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Variables 4 | ========= 5 | 6 | ``Variable`` represents a specific task argument within a constraint declaration. These 7 | are used by the runtime to solve the constraints on a task. 8 | 9 | 10 | .. autosummary:: 11 | :toctree: generated/ 12 | :template: class.rst 13 | 14 | Variable 15 | -------------------------------------------------------------------------------- /docs/legate/source/api/python/variant_options.rst: -------------------------------------------------------------------------------- 1 | .. currentmodule:: legate.core 2 | 3 | Variant Options 4 | =============== 5 | 6 | The ``VariantOptions`` class allows dictating per-variant configuration options for legate 7 | tasks. 8 | 9 | .. autosummary:: 10 | :toctree: generated/ 11 | :template: class.rst 12 | 13 | VariantOptions 14 | -------------------------------------------------------------------------------- /docs/legate/source/changes/dev.rst: -------------------------------------------------------------------------------- 1 | 2507.rst -------------------------------------------------------------------------------- /docs/legate/source/changes/index.rst: -------------------------------------------------------------------------------- 1 | Change Log 2 | ========== 3 | 4 | .. legate-releases:: 5 | -------------------------------------------------------------------------------- /docs/legate/source/developer/index.rst: -------------------------------------------------------------------------------- 1 | ======================= 2 | Developer Documentation 3 | ======================= 4 | 5 | .. toctree:: 6 | :maxdepth: 2 7 | :caption: Contents 8 | 9 | Style