├── testing ├── .gitignore ├── SConscript ├── async │ ├── SConscript │ └── cuda │ │ └── SConscript ├── cuda │ └── SConscript ├── future │ ├── SConscript │ └── cuda │ │ ├── SConscript │ │ └── async_future │ │ ├── SConscript │ │ └── make_dependent_stream.cu ├── invoke │ ├── SConscript │ └── cuda │ │ └── SConscript ├── memory │ ├── SConscript │ └── allocator │ │ ├── SConscript │ │ └── cuda │ │ └── SConscript ├── algorithm │ ├── SConscript │ └── cuda │ │ ├── SConscript │ │ ├── copy_n.cu │ │ └── async_copy_n.cu ├── bulk_async │ ├── SConscript │ └── cuda │ │ ├── SConscript │ │ └── device_lambda │ │ └── SConscript ├── bulk_invoke │ ├── SConscript │ ├── cuda │ │ ├── SConscript │ │ └── device_lambda │ │ │ └── SConscript │ └── void_result.cpp ├── bulk_then │ ├── SConscript │ └── cuda │ │ ├── SConscript │ │ └── device_lambda │ │ └── SConscript ├── container │ ├── SConscript │ └── vector │ │ ├── SConscript │ │ ├── pop_back.cpp │ │ ├── assign_operator.cpp │ │ ├── clear.cpp │ │ └── move_constructor.cpp ├── coordinate │ ├── SConscript │ ├── cuda │ │ └── SConscript │ └── point │ │ ├── SConscript │ │ └── fill_constructor.cpp ├── execution │ ├── SConscript │ ├── execution_policy │ │ ├── SConscript │ │ ├── cuda │ │ │ ├── SConscript │ │ │ └── on.cu │ │ └── on.cpp │ └── executor │ │ ├── cuda │ │ ├── SConscript │ │ ├── grid_executor.cu │ │ └── concurrent_grid_executor.cu │ │ ├── utility │ │ ├── SConscript │ │ ├── cuda │ │ │ └── SConscript │ │ ├── blocking_twoway_execute.cpp │ │ ├── blocking_bulk_twoway_execute_with_void_result.cpp │ │ ├── blocking_bulk_twoway_execute_with_collected_result.cpp │ │ ├── bulk_twoway_execute_with_void_result.cpp │ │ ├── bulk_twoway_execute_with_collected_result.cpp │ │ └── blocking_bulk_twoway_execute.cpp │ │ ├── executor_traits │ │ ├── SConscript │ │ ├── cuda │ │ │ ├── SConscript │ │ │ └── executor_shape.cu │ │ └── executor_shape.cpp │ │ ├── customization_points │ │ ├── SConscript │ │ ├── cuda │ │ │ ├── SConscript │ │ │ ├── unit_shape.cu │ │ │ └── make_ready_future.cu │ │ ├── unit_shape.cpp │ │ └── make_ready_future.cpp │ │ ├── SConscript │ │ ├── experimental │ │ └── SConscript │ │ ├── properties │ │ ├── SConscript │ │ └── cuda │ │ │ └── SConscript │ │ └── execution_functions │ │ ├── SConscript │ │ ├── cuda │ │ ├── SConscript │ │ ├── twoway_execute.cu │ │ └── then_execute.cu │ │ ├── twoway_execute.cpp │ │ ├── bulk_twoway_execute.cpp │ │ └── then_execute.cpp ├── unorganized │ ├── SConscript │ ├── cuda │ │ ├── SConscript │ │ ├── test_concurrent.cu │ │ ├── multidimensional_agent.cu │ │ ├── fill.cu │ │ ├── test_grid_executor_2d.cu │ │ └── cuda_grid.cu │ ├── multidimensional_agent.cpp │ ├── test_concurrent.cpp │ ├── unsequenced_saxpy.cpp │ ├── test.cpp │ ├── fill.cpp │ └── reduce.cpp └── experimental │ ├── SConscript │ └── ranges │ ├── SConscript │ ├── iota.cpp │ ├── interval.cpp │ ├── statically_bounded.cpp │ └── size.cpp ├── doc ├── .gitignore └── footer.html ├── agency ├── cuda │ ├── algorithm.hpp │ ├── container.hpp │ ├── experimental.hpp │ ├── execution.hpp │ ├── algorithm │ │ └── copy.hpp │ ├── memory.hpp │ ├── future.hpp │ ├── memory │ │ ├── resource.hpp │ │ ├── allocator.hpp │ │ ├── allocator │ │ │ ├── allocator.hpp │ │ │ ├── pinned_allocator.hpp │ │ │ ├── managed_allocator.hpp │ │ │ └── heterogeneous_allocator.hpp │ │ └── resource │ │ │ └── pinned_resource.hpp │ ├── execution │ │ ├── executor │ │ │ ├── concurrent_executor.hpp │ │ │ └── concurrent_grid_executor.hpp │ │ ├── detail │ │ │ ├── kernel.hpp │ │ │ └── kernel │ │ │ │ └── kernel.hpp │ │ ├── executor.hpp │ │ └── execution_policy │ │ │ ├── concurrent_grid_execution_policy.hpp │ │ │ └── grid_execution_policy.hpp │ ├── detail │ │ ├── workaround_unused_variable_warning.hpp │ │ ├── boxed_value.hpp │ │ ├── future │ │ │ └── README.md │ │ ├── feature_test.hpp │ │ ├── concurrency │ │ │ ├── block_barrier.hpp │ │ │ └── heterogeneous_barrier.hpp │ │ └── terminate.hpp │ ├── container │ │ └── vector.hpp │ └── experimental │ │ └── multidevice_array.hpp ├── functional.hpp ├── container.hpp ├── coordinate.hpp ├── execution │ ├── executor │ │ ├── experimental.hpp │ │ ├── detail │ │ │ ├── utility │ │ │ │ ├── README.md │ │ │ │ ├── executor_bulk_result.hpp │ │ │ │ ├── executor_bulk_result_or_void.hpp │ │ │ │ ├── blocking_twoway_execute.hpp │ │ │ │ ├── blocking_bulk_twoway_execute_with_void_result.hpp │ │ │ │ ├── blocking_bulk_twoway_execute_with_collected_result.hpp │ │ │ │ ├── bulk_twoway_execute_with_collected_result.hpp │ │ │ │ └── blocking_bulk_twoway_execute.hpp │ │ │ ├── this_thread_parallel_executor.hpp │ │ │ └── execution_functions │ │ │ │ ├── adaptations │ │ │ │ └── README.md │ │ │ │ └── README.md │ │ ├── unsequenced_executor.hpp │ │ ├── customization_points.hpp │ │ ├── parallel_executor.hpp │ │ ├── executor_traits.hpp │ │ ├── executor_traits │ │ │ ├── detail │ │ │ │ ├── member_index_type_or.hpp │ │ │ │ ├── executor_execution_depth_or.hpp │ │ │ │ ├── member_barrier_type_or.hpp │ │ │ │ ├── member_future_or.hpp │ │ │ │ ├── member_allocator_or.hpp │ │ │ │ ├── member_container_or.hpp │ │ │ │ └── member_shape_type_or.hpp │ │ │ ├── executor_execution_depth.hpp │ │ │ ├── is_executor.hpp │ │ │ ├── executor_shape.hpp │ │ │ ├── executor_future.hpp │ │ │ ├── executor_index.hpp │ │ │ └── executor_allocator.hpp │ │ ├── scoped_executor.hpp │ │ └── vector_executor.hpp │ ├── execution_agent │ │ ├── experimental.hpp │ │ ├── parallel_agent.hpp │ │ ├── sequenced_agent.hpp │ │ ├── unsequenced_agent.hpp │ │ ├── experimental │ │ │ ├── static_parallel_agent.hpp │ │ │ ├── static_sequenced_agent.hpp │ │ │ ├── static_concurrent_agent.hpp │ │ │ └── detail │ │ │ │ └── basic_static_execution_agent.hpp │ │ ├── parallel_group.hpp │ │ ├── sequenced_group.hpp │ │ ├── concurrent_group.hpp │ │ ├── unsequenced_group.hpp │ │ └── concurrent_agent.hpp │ ├── execution_policy │ │ └── README.md │ ├── execution_agent.hpp │ └── executor.hpp ├── memory │ ├── allocator.hpp │ ├── allocator │ │ ├── detail │ │ │ ├── malloc_allocator.hpp │ │ │ ├── allocator_traits │ │ │ │ ├── member_pointer_or.hpp │ │ │ │ ├── member_size_type_or.hpp │ │ │ │ ├── member_value_type_or.hpp │ │ │ │ ├── destroy.hpp │ │ │ │ └── construct.hpp │ │ │ └── allocator_traits.hpp │ │ └── allocator.hpp │ ├── to_address.hpp │ └── detail │ │ └── resource │ │ ├── null_resource.hpp │ │ ├── malloc_resource.hpp │ │ └── tiered_resource.hpp ├── memory.hpp ├── detail │ ├── unit.hpp │ ├── algorithm │ │ ├── move.hpp │ │ ├── equal.hpp │ │ ├── max.hpp │ │ ├── min.hpp │ │ ├── copy.hpp │ │ ├── copy │ │ │ ├── uninitialized_copy_n.hpp │ │ │ └── uninitialized_copy.hpp │ │ └── move │ │ │ ├── uninitialized_move_n.hpp │ │ │ └── uninitialized_move.hpp │ ├── control_structures │ │ ├── single_result.hpp │ │ ├── executor_functions │ │ │ └── README.md │ │ ├── README.md │ │ ├── is_bulk_call_possible_via_execution_policy.hpp │ │ └── decay_parameter.hpp │ ├── iterator │ │ ├── iterator_traits.hpp │ │ ├── iterator_traits │ │ │ ├── iterator_is_contiguous.hpp │ │ │ ├── iterator_value_is_trivially_copyable.hpp │ │ │ └── iterator_is_random_access.hpp │ │ ├── data.hpp │ │ ├── advance.hpp │ │ └── distance.hpp │ ├── algorithm.hpp │ ├── iterator.hpp │ ├── config.hpp │ ├── default_shape.hpp │ ├── terminate.hpp │ ├── unwrap_tuple_if.hpp │ ├── requires.hpp │ ├── is_call_possible.hpp │ ├── host_device_cast.hpp │ ├── singleton.hpp │ └── make_tuple_if.hpp ├── experimental │ ├── ndarray.hpp │ ├── ranges │ │ ├── repeat.hpp │ │ ├── interval.hpp │ │ ├── transformed.hpp │ │ └── tile.hpp │ └── ranges.hpp ├── future │ ├── future_traits.hpp │ └── future_traits │ │ ├── future_rebind_value.hpp │ │ ├── future_result.hpp │ │ ├── future_then_result.hpp │ │ └── is_future.hpp ├── experimental.hpp ├── execution.hpp ├── coordinate │ └── detail │ │ ├── colexicographic_rank.hpp │ │ └── shape │ │ ├── shape_size.hpp │ │ ├── make_shape.hpp │ │ └── shape_element.hpp ├── omp.hpp ├── cuda.hpp ├── functional │ └── invoke.hpp ├── version.hpp ├── agency.hpp └── async.hpp ├── examples ├── SConscript ├── cuda │ └── SConscript ├── version.cpp ├── hello_world.cpp ├── hello_lambda.cpp ├── fill.cpp ├── saxpy.cpp ├── hello_async.cpp ├── concurrent_ping_pong.cpp ├── concurrent_sum.cpp └── hello_then.cpp ├── .gitmodules ├── .gitignore └── LICENSE /testing/.gitignore: -------------------------------------------------------------------------------- 1 | *.dblite 2 | -------------------------------------------------------------------------------- /doc/.gitignore: -------------------------------------------------------------------------------- 1 | # ignore the html directory 2 | html/* 3 | -------------------------------------------------------------------------------- /agency/cuda/algorithm.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | -------------------------------------------------------------------------------- /agency/functional.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | -------------------------------------------------------------------------------- /agency/cuda/container.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | -------------------------------------------------------------------------------- /examples/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /agency/cuda/experimental.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | -------------------------------------------------------------------------------- /examples/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/async/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/future/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/invoke/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/memory/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/algorithm/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/async/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/bulk_async/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/bulk_invoke/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/bulk_then/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/container/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/coordinate/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/execution/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/future/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/invoke/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/unorganized/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/algorithm/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/bulk_async/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/bulk_invoke/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/bulk_then/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/container/vector/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/coordinate/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/coordinate/point/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/experimental/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/memory/allocator/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/unorganized/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /agency/container.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | -------------------------------------------------------------------------------- /testing/experimental/ranges/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/memory/allocator/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /agency/coordinate.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | -------------------------------------------------------------------------------- /testing/execution/execution_policy/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/execution/executor/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/execution/executor/utility/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/future/cuda/async_future/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/bulk_async/cuda/device_lambda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/bulk_invoke/cuda/device_lambda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/bulk_then/cuda/device_lambda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/execution/execution_policy/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/execution/executor/utility/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /agency/execution/executor/experimental.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | -------------------------------------------------------------------------------- /testing/execution/executor/executor_traits/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/execution/executor/customization_points/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /testing/execution/executor/executor_traits/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /agency/cuda/execution.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | -------------------------------------------------------------------------------- /testing/execution/executor/customization_points/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 4 | Return('programs') 5 | 6 | -------------------------------------------------------------------------------- /agency/memory/allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | -------------------------------------------------------------------------------- /agency/cuda/algorithm/copy.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | -------------------------------------------------------------------------------- /agency/memory.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | -------------------------------------------------------------------------------- /doc/footer.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 |
7 | © 2016 NVIDIA Corporation 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /agency/cuda/memory.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | -------------------------------------------------------------------------------- /testing/execution/executor/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | 4 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 5 | 6 | # return the entire list of programs to the caller 7 | Return('programs') 8 | 9 | -------------------------------------------------------------------------------- /agency/detail/unit.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace agency 6 | { 7 | namespace detail 8 | { 9 | 10 | 11 | struct unit {}; 12 | 13 | 14 | } // end detail 15 | } // end agency 16 | 17 | -------------------------------------------------------------------------------- /testing/execution/executor/experimental/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | 4 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 5 | 6 | # return the entire list of programs to the caller 7 | Return('programs') 8 | 9 | -------------------------------------------------------------------------------- /testing/execution/executor/properties/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | 4 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 5 | 6 | # return the entire list of programs to the caller 7 | Return('programs') 8 | 9 | -------------------------------------------------------------------------------- /testing/execution/executor/properties/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | 4 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 5 | 6 | # return the entire list of programs to the caller 7 | Return('programs') 8 | 9 | -------------------------------------------------------------------------------- /agency/cuda/future.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | -------------------------------------------------------------------------------- /testing/execution/executor/execution_functions/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | 4 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 5 | 6 | # return the entire list of programs to the caller 7 | Return('programs') 8 | 9 | -------------------------------------------------------------------------------- /testing/execution/executor/execution_functions/cuda/SConscript: -------------------------------------------------------------------------------- 1 | Import('env') 2 | env = env.Clone() 3 | 4 | programs = env.RecursivelyCreateProgramsAndUnitTestAliases() 5 | 6 | # return the entire list of programs to the caller 7 | Return('programs') 8 | 9 | -------------------------------------------------------------------------------- /agency/experimental/ndarray.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | -------------------------------------------------------------------------------- /examples/version.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | int major = AGENCY_MAJOR_VERSION; 7 | int minor = AGENCY_MINOR_VERSION; 8 | 9 | std::cout << "Agency v" << major << "." << minor << std::endl; 10 | 11 | return 0; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/utility/README.md: -------------------------------------------------------------------------------- 1 | This directory contains utility functions whose semantics are similar to execution functions, but are not themselves execution functions. 2 | 3 | These functions are implemented by adapting a given executor's natively-supported execution functions. 4 | -------------------------------------------------------------------------------- /agency/detail/algorithm/move.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | -------------------------------------------------------------------------------- /agency/cuda/memory/resource.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | -------------------------------------------------------------------------------- /agency/execution/executor/unsequenced_executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | 9 | 10 | using unsequenced_executor = vector_executor; 11 | 12 | 13 | } // end agency 14 | 15 | -------------------------------------------------------------------------------- /agency/future/future_traits.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | -------------------------------------------------------------------------------- /agency/cuda/execution/executor/concurrent_executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace agency 6 | { 7 | namespace cuda 8 | { 9 | 10 | 11 | using concurrent_executor = block_executor; 12 | 13 | 14 | } // end cuda 15 | } // end agency 16 | 17 | 18 | -------------------------------------------------------------------------------- /agency/detail/control_structures/single_result.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | 7 | namespace agency 8 | { 9 | 10 | 11 | template 12 | using single_result = scope_result<0,T>; 13 | 14 | 15 | } // end agency 16 | 17 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "testing/site_scons/site_tools/nvcc-scons"] 2 | path = testing/site_scons/site_tools/nvcc-scons 3 | url = https://github.com/jaredhoberock/nvcc-scons.git 4 | [submodule "examples/site_scons/site_tools/nvcc-scons"] 5 | path = examples/site_scons/site_tools/nvcc-scons 6 | url = https://github.com/jaredhoberock/nvcc-scons.git 7 | -------------------------------------------------------------------------------- /agency/cuda/detail/workaround_unused_variable_warning.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace agency 4 | { 5 | namespace cuda 6 | { 7 | namespace detail 8 | { 9 | 10 | 11 | template 12 | __host__ __device__ 13 | void workaround_unused_variable_warning(const T&) {} 14 | 15 | 16 | } // end detail 17 | } // end cuda 18 | } // end agency 19 | 20 | -------------------------------------------------------------------------------- /agency/detail/iterator/iterator_traits.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/experimental.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | -------------------------------------------------------------------------------- /testing/unorganized/multidimensional_agent.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | auto exec = agency::par2d({0,0}, {2,2}); 7 | 8 | agency::bulk_invoke(exec, [](agency::parallel_agent_2d& self) 9 | { 10 | std::cout << "hello world from agent " << self.index() << std::endl; 11 | }); 12 | 13 | return 0; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/this_thread_parallel_executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace this_thread 9 | { 10 | 11 | 12 | using parallel_executor = sequenced_executor; 13 | 14 | 15 | } // end this_thread 16 | } // end agency 17 | 18 | -------------------------------------------------------------------------------- /agency/execution/executor/customization_points.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | -------------------------------------------------------------------------------- /agency/execution/executor/parallel_executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | 10 | 11 | using parallel_executor = detail::parallel_thread_pool_executor; 12 | 13 | 14 | } // end agency 15 | 16 | -------------------------------------------------------------------------------- /examples/hello_world.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void hello(agency::sequenced_agent& self) 5 | { 6 | std::cout << "Hello, world from agent " << self.index() << std::endl; 7 | } 8 | 9 | int main() 10 | { 11 | // create 10 sequenced_agents to execute the hello() task in bulk 12 | agency::bulk_invoke(agency::seq(10), hello); 13 | 14 | return 0; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /agency/cuda/memory/allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | -------------------------------------------------------------------------------- /testing/unorganized/test_concurrent.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | using namespace agency; 7 | 8 | bulk_async(con(10), [](concurrent_agent &g) 9 | { 10 | std::cout << "agent " << g.index() << " arriving at barrier" << std::endl; 11 | 12 | g.wait(); 13 | 14 | std::cout << "departing barrier" << std::endl; 15 | }).wait(); 16 | 17 | return 0; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/execution_functions/adaptations/README.md: -------------------------------------------------------------------------------- 1 | This directory contains functions which provide the semantics of one execution function by adapting some other execution function provided natively by a given executor. 2 | 3 | For example, the function `bulk_then_execute_via_bulk_twoway_execute` adapts an executor's native behavior provided via its `.bulk_twoway_execute` member function to deliver the semantics of `bulk_then_execute`. 4 | 5 | -------------------------------------------------------------------------------- /agency/cuda/detail/boxed_value.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace cuda 10 | { 11 | namespace detail 12 | { 13 | 14 | 15 | template 16 | using boxed_value = agency::detail::boxed_value>; 17 | 18 | 19 | } // end detail 20 | } // end cuda 21 | } // end agency 22 | 23 | -------------------------------------------------------------------------------- /agency/memory/allocator/detail/malloc_allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | template 14 | using malloc_allocator = allocator_adaptor; 15 | 16 | 17 | } // end detail 18 | } // end agency 19 | 20 | -------------------------------------------------------------------------------- /agency/detail/algorithm.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | -------------------------------------------------------------------------------- /agency/detail/control_structures/executor_functions/README.md: -------------------------------------------------------------------------------- 1 | This directory contains the implementations of lower-level forms of the bulk invocation functions: 2 | 3 | * `bulk_invoke_executor` 4 | * `bulk_async_executor` 5 | * `bulk_then_executor` 6 | 7 | These work like the regular `bulk_invoke` etc. functions, but take an executor 8 | as a parameter rather than an execution policy. The implementation of 9 | higher-level forms of `bulk_invoke` and friends lower onto these functions. 10 | 11 | -------------------------------------------------------------------------------- /examples/hello_lambda.cpp: -------------------------------------------------------------------------------- 1 | /// \example hello_lambda.cpp 2 | /// \brief Demonstrates how to use `bulk_invoke` to output sequential hello world messages. 3 | /// 4 | 5 | #include 6 | #include 7 | 8 | int main() 9 | { 10 | // create 10 sequenced_agents to greet us in bulk 11 | agency::bulk_invoke(agency::seq(10), [](agency::sequenced_agent& self) 12 | { 13 | std::cout << "Hello, world from agent " << self.index() << std::endl; 14 | }); 15 | 16 | return 0; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /agency/detail/iterator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | -------------------------------------------------------------------------------- /agency/experimental.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | -------------------------------------------------------------------------------- /agency/cuda/container/vector.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace cuda 10 | { 11 | 12 | 13 | // XXX for the moment, don't define an Allocator template parameter 14 | // to prevent use of allocators which are not compatible with CUDA 15 | template 16 | using vector = agency::vector>; 17 | 18 | 19 | } // end cuda 20 | } // end agency 21 | 22 | -------------------------------------------------------------------------------- /agency/execution.hpp: -------------------------------------------------------------------------------- 1 | /// \file 2 | /// \brief Include this file to use any component of Agency related to execution. 3 | /// 4 | /// Including `` recursively includes Agency header files organized beneath 5 | /// ``. 6 | /// 7 | 8 | /// 9 | /// \defgroup execution Execution 10 | /// 11 | 12 | #pragma once 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | -------------------------------------------------------------------------------- /agency/detail/config.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifdef __CUDACC__ 4 | # define __AGENCY_ANNOTATION __host__ __device__ 5 | #else 6 | # define __AGENCY_ANNOTATION 7 | #endif // __AGENCY_ANNOTATION 8 | 9 | #if defined(__NVCC__) && !(defined(__clang__) && defined(__CUDA__)) 10 | # ifndef __agency_exec_check_disable__ 11 | # define __agency_exec_check_disable__ \ 12 | # pragma nv_exec_check_disable 13 | # endif // __agency_exec_check_disable__ 14 | #else 15 | # define __agency_exec_check_disable__ 16 | #endif // __agency_exec_check_disable__ 17 | 18 | -------------------------------------------------------------------------------- /agency/cuda/execution/detail/kernel.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | -------------------------------------------------------------------------------- /agency/cuda/execution/executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | -------------------------------------------------------------------------------- /agency/detail/algorithm/equal.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace agency 6 | { 7 | namespace detail 8 | { 9 | 10 | 11 | template 12 | __AGENCY_ANNOTATION 13 | bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2) 14 | { 15 | for(; first1 != last1; ++first1, ++first2) 16 | { 17 | if(!(*first1 == *first2)) 18 | { 19 | return false; 20 | } 21 | } 22 | 23 | return true; 24 | } 25 | 26 | 27 | } // end detail 28 | } // end agency 29 | 30 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | -------------------------------------------------------------------------------- /testing/unorganized/cuda/test_concurrent.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | struct functor 6 | { 7 | __device__ 8 | void operator()(agency::concurrent_agent& self) 9 | { 10 | printf("agent %d arriving at barrier\n", (int)self.index()); 11 | 12 | self.wait(); 13 | 14 | printf("departing barrier\n"); 15 | } 16 | }; 17 | 18 | int main() 19 | { 20 | agency::cuda::concurrent_executor gpu; 21 | 22 | agency::bulk_invoke(agency::con(10).on(gpu), functor()); 23 | 24 | return 0; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /agency/cuda/memory/allocator/allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace cuda 11 | { 12 | 13 | template 14 | using allocator = heterogeneous_allocator>; 15 | 16 | 17 | } // end cuda 18 | } // end agency 19 | 20 | -------------------------------------------------------------------------------- /agency/detail/algorithm/max.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace agency 6 | { 7 | namespace detail 8 | { 9 | 10 | 11 | __agency_exec_check_disable__ 12 | template 13 | __AGENCY_ANNOTATION 14 | const T& max(const T& a, const T& b) 15 | { 16 | return a < b ? b : a; 17 | } 18 | 19 | 20 | __agency_exec_check_disable__ 21 | template 22 | __AGENCY_ANNOTATION 23 | const T& max(const T& a, const T& b, Compare comp) 24 | { 25 | return comp(a, b) ? b : a; 26 | } 27 | 28 | 29 | } // end detail 30 | } // end agency 31 | 32 | -------------------------------------------------------------------------------- /agency/detail/algorithm/min.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace agency 6 | { 7 | namespace detail 8 | { 9 | 10 | 11 | __agency_exec_check_disable__ 12 | template 13 | __AGENCY_ANNOTATION 14 | const T& min(const T& a, const T& b) 15 | { 16 | return b < a ? b : a; 17 | } 18 | 19 | 20 | __agency_exec_check_disable__ 21 | template 22 | __AGENCY_ANNOTATION 23 | const T& min(const T& a, const T& b, Compare comp) 24 | { 25 | return comp(b, a) ? b : a; 26 | } 27 | 28 | 29 | } // end detail 30 | } // end agency 31 | 32 | -------------------------------------------------------------------------------- /agency/cuda/detail/future/README.md: -------------------------------------------------------------------------------- 1 | This directory contains the implementations of the various types of CUDA futures. 2 | 3 | * `deferred_future` - This type of future becomes ready when `.wait()` or `.get()` is called. The continuation is invoked in the calling thread. 4 | * `async_future` - This type of future tracks CUDA kernels launched on a CUDA device. The continuation becomes ready when the kernel launch completes. 5 | * `future` - This type of future is conceptually a `variant`. 6 | * `shared_future` - This type of future is conceptually a `shared_ptr`. 7 | 8 | -------------------------------------------------------------------------------- /agency/detail/algorithm/copy.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/execution_functions/README.md: -------------------------------------------------------------------------------- 1 | This directory contains "execution functions": 2 | 3 | * `bulk_then_execute` 4 | * `bulk_twoway_execute` 5 | * `then_execute` 6 | * `twoway_execute` 7 | 8 | These are free functions which receive an executor and other parameters, and create execution agents. 9 | 10 | If the given executor natively supports the execution function via a member function, then the execution function simply calls that member function. 11 | 12 | Otherwise, the executor's native support is adapted to provide the execution function's semantics. 13 | 14 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/parallel_agent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | 11 | 12 | using parallel_agent = detail::basic_execution_agent; 13 | using parallel_agent_1d = parallel_agent; 14 | using parallel_agent_2d = detail::basic_execution_agent; 15 | 16 | 17 | } // end agency 18 | 19 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/sequenced_agent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | 11 | 12 | using sequenced_agent = detail::basic_execution_agent; 13 | using sequenced_agent_1d = sequenced_agent; 14 | using sequenced_agent_2d = detail::basic_execution_agent; 15 | 16 | 17 | } // end agency 18 | 19 | -------------------------------------------------------------------------------- /testing/experimental/ranges/iota.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | 9 | void test() 10 | { 11 | using namespace agency::experimental; 12 | 13 | size_t n = 100; 14 | 15 | auto rng = iota(0, n); 16 | 17 | std::vector ref(n); 18 | std::iota(ref.begin(), ref.end(), 0); 19 | 20 | assert(std::equal(ref.begin(), ref.end(), rng.begin())); 21 | } 22 | 23 | int main() 24 | { 25 | test(); 26 | 27 | std::cout << "OK" << std::endl; 28 | 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /examples/fill.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | // create an array 9 | std::vector array(100); 10 | 11 | // create a group of parallel agents 12 | agency::bulk_invoke(agency::par(array.size()), [&array](agency::parallel_agent& self) 13 | { 14 | // set the value of the agent's corresponding array element 15 | array[self.index()] = 42; 16 | }); 17 | 18 | // check the result 19 | assert(array == std::vector(100,42)); 20 | 21 | std::cout << "OK" << std::endl; 22 | 23 | return 0; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # ignore all files, so that we can ignore executables created by build systems 2 | * 3 | 4 | # don't ignore directories, so we can recurse into them 5 | !*/ 6 | 7 | # don't ignore files that have an extension 8 | !*.* 9 | 10 | # ignore intermediate files introduced by build systems 11 | *.o 12 | *.out 13 | 14 | # don't ignore scons makefiles 15 | !**/SConstruct 16 | !**/SConscript 17 | 18 | # ignore files introduced by scons 19 | .sconsign.dblite 20 | *.pyc 21 | 22 | # ignore files introduced by doxygen 23 | *.log 24 | 25 | # ignore files produced by compiler diagnostics (typically named errors.txt) 26 | *.txt 27 | 28 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/unsequenced_agent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | 11 | 12 | using unsequenced_agent = detail::basic_execution_agent; 13 | using unsequenced_agent_1d = unsequenced_agent; 14 | using unsequenced_agent_2d = detail::basic_execution_agent; 15 | 16 | 17 | } // end agency 18 | 19 | -------------------------------------------------------------------------------- /agency/experimental/ranges/repeat.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | namespace agency 9 | { 10 | namespace experimental 11 | { 12 | 13 | 14 | template 15 | __AGENCY_ANNOTATION 16 | counted_view, Difference> 17 | repeat(const T& value, const Difference& n) 18 | { 19 | agency::detail::constant_iterator iter(value); 20 | return {iter, n}; 21 | } 22 | 23 | 24 | } // end experimental 25 | } // end agency 26 | 27 | -------------------------------------------------------------------------------- /testing/experimental/ranges/interval.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | 9 | void test() 10 | { 11 | using namespace agency::experimental; 12 | 13 | size_t n = 100; 14 | 15 | auto rng = interval(10, 20); 16 | 17 | std::vector ref(n); 18 | std::iota(ref.begin(), ref.end(), 10); 19 | 20 | assert(std::equal(ref.begin(), ref.end(), rng.begin())); 21 | } 22 | 23 | int main() 24 | { 25 | test(); 26 | 27 | std::cout << "OK" << std::endl; 28 | 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /agency/detail/iterator/iterator_traits/iterator_is_contiguous.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | // XXX for the moment, only consider pointers to be contiguous iterators 14 | template 15 | using iterator_is_contiguous = std::is_pointer; 16 | 17 | 18 | template 19 | using iterators_are_contiguous = conjunction< 20 | iterator_is_contiguous... 21 | >; 22 | 23 | 24 | } // end detail 25 | } // end agency 26 | 27 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/experimental/static_parallel_agent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace experimental 11 | { 12 | 13 | 14 | template 15 | using static_parallel_agent = detail::basic_static_execution_agent; 16 | 17 | 18 | } // end experimental 19 | } // end agency 20 | 21 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/detail/member_index_type_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template 13 | struct member_index_type_or 14 | { 15 | template 16 | using helper = typename U::index_type; 17 | 18 | using type = detected_or_t; 19 | }; 20 | 21 | template 22 | using member_index_type_or_t = typename member_index_type_or::type; 23 | 24 | 25 | } // end detail 26 | } // end agency 27 | 28 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/experimental/static_sequenced_agent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace experimental 11 | { 12 | 13 | 14 | template 15 | using static_sequenced_agent = detail::basic_static_execution_agent; 16 | 17 | 18 | } // end experimental 19 | } // end agency 20 | 21 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/detail/executor_execution_depth_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | 9 | namespace agency 10 | { 11 | namespace detail 12 | { 13 | 14 | 15 | 16 | template 17 | struct executor_execution_depth_or 18 | : bulk_guarantee_depth< 19 | decltype(bulk_guarantee_t::template static_query()) 20 | > 21 | {}; 22 | 23 | 24 | } // end detail 25 | } // end agency 26 | 27 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/detail/member_barrier_type_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template 13 | struct member_barrier_type_or 14 | { 15 | template 16 | using helper = typename U::barrier_type; 17 | 18 | using type = detected_or_t; 19 | }; 20 | 21 | template 22 | using member_barrier_type_or_t = typename member_barrier_type_or::type; 23 | 24 | 25 | } // end detail 26 | } // end agency 27 | 28 | -------------------------------------------------------------------------------- /agency/future/future_traits/future_rebind_value.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace agency 6 | { 7 | 8 | 9 | template 10 | struct future_rebind_value 11 | { 12 | using type = typename Future::template rebind_value; 13 | }; 14 | 15 | 16 | template class Future, class FromType, class ToType> 17 | struct future_rebind_value,ToType> 18 | { 19 | using type = Future; 20 | }; 21 | 22 | 23 | template 24 | using future_rebind_value_t = typename future_rebind_value::type; 25 | 26 | 27 | } // end agency 28 | 29 | -------------------------------------------------------------------------------- /testing/unorganized/unsequenced_saxpy.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | using namespace agency; 9 | 10 | size_t n = 1 << 16; 11 | std::vector x(n, 1), y(n, 2), z(n); 12 | float a = 13.; 13 | 14 | bulk_invoke(unseq(n), [&](unsequenced_agent &self) 15 | { 16 | auto i = self.index(); 17 | z[i] = a * x[i] + y[i]; 18 | }); 19 | 20 | float expected = a * 1. + 2.; 21 | assert(std::all_of(z.begin(), z.end(), [=](float x){ return expected == x; })); 22 | 23 | std::cout << "OK" << std::endl; 24 | 25 | return 0; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /agency/execution/execution_policy/README.md: -------------------------------------------------------------------------------- 1 | This directory contains definitions of Agency's built-in execution policy 2 | types. These are all defined by inheriting from `basic_execution_policy`, using 3 | the appropriate types as template parameters to describe their essential 4 | characteristics. We use inheritance, instead of making a simple `typedef` of 5 | `basic_execution_policy`, for the sake of better documentation and compiler error 6 | messages. Defining a unique type like `sequenced_execution_policy` ensures that 7 | "`sequenced_execution_policy`" appears in compiler output, instead of some type 8 | recipe involving `basic_execution_policy`. 9 | 10 | -------------------------------------------------------------------------------- /agency/future/future_traits/future_result.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | 9 | 10 | template 11 | struct future_result 12 | { 13 | // the decay removes the reference returned 14 | // from futures like shared_future 15 | // the idea is given Future, 16 | // future_result> returns T 17 | using type = typename std::decay< 18 | decltype(std::declval().get()) 19 | >::type; 20 | }; 21 | 22 | 23 | template 24 | using future_result_t = typename future_result::type; 25 | 26 | 27 | } // end agency 28 | 29 | -------------------------------------------------------------------------------- /agency/cuda/execution/detail/kernel/kernel.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace agency 6 | { 7 | namespace cuda 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | template 14 | __global__ void cuda_kernel(Function f, Args... args) 15 | { 16 | f(args...); 17 | } 18 | 19 | 20 | template 21 | __host__ __device__ 22 | auto make_cuda_kernel(const Function&, const Args&...) -> 23 | decltype(&cuda_kernel) 24 | { 25 | return &cuda_kernel; 26 | } 27 | 28 | 29 | } // end detail 30 | } // end cuda 31 | } // end agency 32 | 33 | -------------------------------------------------------------------------------- /agency/detail/iterator/iterator_traits/iterator_value_is_trivially_copyable.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | template 14 | using iterator_value_is_trivially_copyable = std::is_trivially_copyable< 15 | typename std::iterator_traits::value_type 16 | >; 17 | 18 | 19 | template 20 | using iterator_values_are_trivially_copyable = conjunction< 21 | iterator_value_is_trivially_copyable... 22 | >; 23 | 24 | 25 | } // end detail 26 | } // end agency 27 | 28 | -------------------------------------------------------------------------------- /testing/unorganized/cuda/multidimensional_agent.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | struct functor 6 | { 7 | __device__ 8 | void operator()(agency::parallel_agent_2d& self) 9 | { 10 | printf("Hello world from agent {%llu, %llu}\n", agency::get<0>(self.index()), agency::get<1>(self.index())); 11 | } 12 | }; 13 | 14 | int main() 15 | { 16 | auto exec = agency::cuda::par2d({0,0}, {2,2}); 17 | 18 | agency::bulk_invoke(exec, functor()); 19 | 20 | cudaError_t error = cudaDeviceSynchronize(); 21 | 22 | std::cerr << "CUDA error: " << cudaGetErrorString(error) << std::endl; 23 | 24 | return 0; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/detail/member_future_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template class Default> 13 | struct member_future_or 14 | { 15 | template 16 | using helper = typename V::template future; 17 | 18 | using type = detected_or_t, helper, T>; 19 | }; 20 | 21 | template class Default> 22 | using member_future_or_t = typename member_future_or::type; 23 | 24 | 25 | } // end detail 26 | } // end agency 27 | 28 | -------------------------------------------------------------------------------- /agency/memory/allocator/detail/allocator_traits/member_pointer_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | // returns T::pointer if it exists, Default otherwise 13 | template 14 | struct member_pointer_or 15 | { 16 | template 17 | using helper = typename U::pointer; 18 | 19 | using type = detected_or_t; 20 | }; 21 | 22 | template 23 | using member_pointer_or_t = typename member_pointer_or::type; 24 | 25 | 26 | } // end detail 27 | } // end agency 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /agency/memory/allocator/detail/allocator_traits/member_size_type_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | // returns T::size_type if it exists, Default otherwise 13 | template 14 | struct member_size_type_or 15 | { 16 | template 17 | using helper = typename U::size_type; 18 | 19 | using type = detected_or_t; 20 | }; 21 | 22 | template 23 | using member_size_type_or_t = typename member_size_type_or::type; 24 | 25 | 26 | } // end detail 27 | } // end agency 28 | 29 | -------------------------------------------------------------------------------- /agency/memory/allocator/detail/allocator_traits/member_value_type_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | // returns T::value_type if it exists, Default otherwise 13 | template 14 | struct member_value_type_or 15 | { 16 | template 17 | using helper = typename U::value_type; 18 | 19 | using type = detected_or_t; 20 | }; 21 | 22 | template 23 | using member_value_type_or_t = typename member_value_type_or::type; 24 | 25 | 26 | } // end detail 27 | } // end agency 28 | 29 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/detail/member_allocator_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template class Default> 13 | struct member_allocator_or 14 | { 15 | template 16 | using helper = typename V::template allocator; 17 | 18 | using type = detected_or_t, helper, T>; 19 | }; 20 | 21 | template class Default> 22 | using member_allocator_or_t = typename member_allocator_or::type; 23 | 24 | 25 | } // end detail 26 | } // end agency 27 | 28 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/detail/member_container_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template class Default> 13 | struct member_container_or 14 | { 15 | template 16 | using helper = typename V::template container; 17 | 18 | using type = detected_or_t, helper, T>; 19 | }; 20 | 21 | template class Default> 22 | using member_container_or_t = typename member_container_or::type; 23 | 24 | 25 | } // end detail 26 | } // end agency 27 | 28 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/detail/member_shape_type_or.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | // returns T::shape_type if it exists, Default otherwise 13 | template 14 | struct member_shape_type_or 15 | { 16 | template 17 | using helper = typename U::shape_type; 18 | 19 | using type = detected_or_t; 20 | }; 21 | 22 | template 23 | using member_shape_type_or_t = typename member_shape_type_or::type; 24 | 25 | 26 | } // end detail 27 | } // end agency 28 | 29 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/parallel_group.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | 10 | 11 | template 12 | using parallel_group = detail::execution_group; 13 | template 14 | using parallel_group_1d = detail::execution_group; 15 | template 16 | using parallel_group_2d = detail::execution_group; 17 | 18 | 19 | } // end agency 20 | 21 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/sequenced_group.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | 10 | 11 | template 12 | using sequenced_group = detail::execution_group; 13 | template 14 | using sequenced_group_1d = detail::execution_group; 15 | template 16 | using sequenced_group_2d = detail::execution_group; 17 | 18 | 19 | } // end agency 20 | 21 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/concurrent_group.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | 10 | 11 | template 12 | using concurrent_group = detail::execution_group; 13 | template 14 | using concurrent_group_1d = detail::execution_group; 15 | template 16 | using concurrent_group_2d = detail::execution_group; 17 | 18 | 19 | } // end agency 20 | 21 | -------------------------------------------------------------------------------- /agency/memory/to_address.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | namespace agency 9 | { 10 | 11 | 12 | __agency_exec_check_disable__ 13 | template::to_address(std::declval()) 16 | ) 17 | > 18 | __AGENCY_ANNOTATION 19 | auto to_address(const Ptr& p) noexcept 20 | -> decltype(std::pointer_traits::to_address(p)) 21 | { 22 | return std::pointer_traits::to_address(p); 23 | } 24 | 25 | 26 | template 27 | __AGENCY_ANNOTATION 28 | constexpr T* to_address(T* ptr) noexcept 29 | { 30 | return ptr; 31 | } 32 | 33 | 34 | } // end agency 35 | 36 | -------------------------------------------------------------------------------- /testing/execution/execution_policy/on.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | void test(const ExecutionPolicy& policy, const Executor& ex) 6 | { 7 | auto p1 = policy.on(ex); 8 | assert(p1.executor() == ex); 9 | } 10 | 11 | int main() 12 | { 13 | // test seq 14 | test(agency::seq, agency::sequenced_executor()); 15 | 16 | // test par 17 | test(agency::par, agency::sequenced_executor()); 18 | test(agency::par, agency::parallel_executor()); 19 | test(agency::par, agency::concurrent_executor()); 20 | 21 | // test con 22 | test(agency::con, agency::concurrent_executor()); 23 | 24 | std::cout << "OK" << std::endl; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/unsequenced_group.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | 10 | 11 | template 12 | using unsequenced_group = detail::execution_group; 13 | template 14 | using unsequenced_group_1d = detail::execution_group; 15 | template 16 | using unsequenced_group_2d = detail::execution_group; 17 | 18 | 19 | } // end agency 20 | 21 | -------------------------------------------------------------------------------- /agency/coordinate/detail/colexicographic_rank.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | // this function returns the rank of the given index in the index 13 | // space implied by the shape argument 14 | // its rank is its position in a colexicographically sorted array of all the indices in the index space 15 | template 16 | __AGENCY_ANNOTATION 17 | std::size_t colexicographic_rank(const Index& idx, const Shape& shape) 18 | { 19 | return agency::detail::index_cast(idx, shape, agency::detail::index_space_size(shape)); 20 | } 21 | 22 | 23 | } // end detail 24 | } // end agency 25 | 26 | -------------------------------------------------------------------------------- /testing/execution/executor/customization_points/unit_shape.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "../test_executors.hpp" 6 | 7 | template 8 | void test(Executor exec) 9 | { 10 | using shape_type = agency::executor_shape_t; 11 | 12 | shape_type unit = agency::unit_shape(exec); 13 | 14 | assert(unit == shape_type(1)); 15 | } 16 | 17 | int main() 18 | { 19 | test(bulk_twoway_executor()); 20 | test(bulk_then_executor()); 21 | 22 | test(not_a_bulk_twoway_executor()); 23 | test(not_a_bulk_then_executor()); 24 | 25 | test(complete_bulk_executor()); 26 | 27 | std::cout << "OK" << std::endl; 28 | 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /testing/execution/executor/customization_points/cuda/unit_shape.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "../../test_executors.hpp" 6 | 7 | template 8 | void test(Executor exec) 9 | { 10 | using shape_type = agency::executor_shape_t; 11 | 12 | shape_type unit = agency::unit_shape(exec); 13 | 14 | assert(unit == shape_type(1)); 15 | } 16 | 17 | int main() 18 | { 19 | test(bulk_twoway_executor()); 20 | test(bulk_then_executor()); 21 | 22 | test(not_a_bulk_twoway_executor()); 23 | test(not_a_bulk_then_executor()); 24 | 25 | test(complete_bulk_executor()); 26 | 27 | std::cout << "OK" << std::endl; 28 | 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /agency/execution/execution_agent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | -------------------------------------------------------------------------------- /agency/experimental/ranges/interval.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace experimental 10 | { 11 | 12 | 13 | template::value 16 | ), 17 | __AGENCY_REQUIRES( 18 | std::is_convertible< 19 | OtherArithmetic, Arithmetic 20 | >::value 21 | )> 22 | auto interval(Arithmetic begin, OtherArithmetic end) -> 23 | decltype(iota(begin, end)) 24 | { 25 | return iota(begin, end); 26 | } 27 | 28 | 29 | } // end experimental 30 | } // end agency 31 | 32 | -------------------------------------------------------------------------------- /agency/future/future_traits/future_then_result.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | 10 | 11 | template 12 | struct future_then_result 13 | { 14 | // get the result of Function when invoked with Future's value 15 | using result_of_function = detail::result_of_continuation_t; 16 | 17 | // lift the result into a Future of the appropriate type 18 | using type = future_rebind_value_t; 19 | }; 20 | 21 | 22 | template 23 | using future_then_result_t = typename future_then_result::type; 24 | 25 | 26 | } // end agency 27 | 28 | -------------------------------------------------------------------------------- /agency/detail/default_shape.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | template 14 | struct default_shape 15 | { 16 | using type = point; 17 | }; // end default_shape 18 | 19 | // when rank is 1, just return a simple size_t rather than a point 20 | template<> 21 | struct default_shape<1> 22 | { 23 | using type = std::size_t; 24 | }; // end default_shape 25 | 26 | 27 | // a rank 0 makes no sense, so don't define a result 28 | template<> 29 | struct default_shape<0> 30 | { 31 | }; // end default_shape 32 | 33 | template 34 | using default_shape_t = typename default_shape::type; 35 | 36 | 37 | } // end detail 38 | } // end agency 39 | 40 | -------------------------------------------------------------------------------- /examples/saxpy.cpp: -------------------------------------------------------------------------------- 1 | /// \example saxpy.cpp 2 | /// \brief Demonstrates how to use `bulk_invoke` to perform a parallel SAXPY. 3 | /// 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int main() 11 | { 12 | // set up some inputs 13 | size_t n = 16 << 20; 14 | std::vector x(n, 1), y(n, 2); 15 | float a = 13.; 16 | 17 | // use par to execute SAXPY in parallel, and collect the results 18 | auto results = agency::bulk_invoke(agency::par(n), [&](agency::parallel_agent& self) 19 | { 20 | int i = self.index(); 21 | return a * x[i] + y[i]; 22 | }); 23 | 24 | // check the result 25 | std::vector ref(n, a * 1.f + 2.f); 26 | assert(results == ref); 27 | 28 | std::cout << "OK" << std::endl; 29 | 30 | return 0; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/executor_execution_depth.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | template::value> 14 | struct executor_execution_depth_impl; 15 | 16 | template 17 | struct executor_execution_depth_impl 18 | : executor_execution_depth_or 19 | {}; 20 | 21 | 22 | } // end detail 23 | 24 | 25 | template 26 | struct executor_execution_depth : detail::executor_execution_depth_impl {}; 27 | 28 | 29 | } // end agency 30 | 31 | -------------------------------------------------------------------------------- /testing/execution/executor/utility/blocking_twoway_execute.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | #include "../test_executors.hpp" 10 | 11 | 12 | template 13 | void test(Executor exec) 14 | { 15 | auto result = agency::detail::blocking_twoway_execute(exec, []{ return 7; }); 16 | 17 | assert(7 == result); 18 | } 19 | 20 | 21 | int main() 22 | { 23 | test(then_executor()); 24 | test(twoway_executor()); 25 | 26 | test(bulk_then_executor()); 27 | test(bulk_twoway_executor()); 28 | 29 | // XXX call test() with all the other types of executors 30 | 31 | std::cout << "OK" << std::endl; 32 | 33 | return 0; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /agency/experimental/ranges/transformed.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace experimental 9 | { 10 | 11 | 12 | 13 | template 14 | using transformed_view = zip_with_view; 15 | 16 | 17 | // transformed() is a synonym for zip_with() 18 | // it's named transformed rather than transform to avoid collision with 19 | // a potential transform algorithm 20 | template 21 | __AGENCY_ANNOTATION 22 | transformed_view transformed(Function f, Ranges&&... ranges) 23 | { 24 | return transformed_view(f, std::forward(ranges)...); 25 | } 26 | 27 | 28 | } // end experimental 29 | } // end agency 30 | 31 | -------------------------------------------------------------------------------- /agency/execution/executor/scoped_executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | 9 | 10 | template 11 | class scoped_executor : public executor_array 12 | { 13 | private: 14 | using super_t = executor_array; 15 | 16 | public: 17 | using outer_executor_type = Executor1; 18 | using inner_executor_type = Executor2; 19 | 20 | scoped_executor(const outer_executor_type&, 21 | const inner_executor_type& inner_ex) 22 | : super_t(1, inner_ex) 23 | {} 24 | 25 | scoped_executor() : 26 | scoped_executor(outer_executor_type(), inner_executor_type()) 27 | {} 28 | }; 29 | 30 | 31 | } // end agency 32 | 33 | -------------------------------------------------------------------------------- /testing/container/vector/pop_back.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void test_pop_back() 7 | { 8 | using namespace agency; 9 | 10 | { 11 | // test pop_back on single-element vector 12 | 13 | vector v(1,7); 14 | 15 | v.pop_back(); 16 | 17 | assert(v.empty()); 18 | } 19 | 20 | { 21 | // test pop_back on multi-element vector 22 | 23 | size_t initial_size = 10; 24 | 25 | vector v(initial_size, 7); 26 | 27 | auto before_back = v.end() - 2; 28 | 29 | v.pop_back(); 30 | 31 | assert(v.size() == initial_size - 1); 32 | assert(before_back == v.end() - 1); 33 | } 34 | } 35 | 36 | int main() 37 | { 38 | test_pop_back(); 39 | 40 | std::cout << "OK" << std::endl; 41 | 42 | return 0; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/is_executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | namespace agency 11 | { 12 | 13 | 14 | template 15 | using is_executor = agency::detail::disjunction< 16 | detail::is_bulk_then_executor, 17 | detail::is_bulk_twoway_executor, 18 | detail::is_single_then_executor, 19 | detail::is_single_twoway_executor 20 | >; 21 | 22 | 23 | } // end agency 24 | 25 | -------------------------------------------------------------------------------- /agency/memory/detail/resource/null_resource.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | // a null_resource is a memory resource that always fails to allocate 13 | // unlike arena_resource, it does not throw an exception or otherwise report error upon failure 14 | // besides returning nullptr from .allocate() 15 | // null_resource is useful in contexts where no dynamic memory is not needed and error reporting 16 | // is expensive 17 | struct null_resource 18 | { 19 | __AGENCY_ANNOTATION 20 | void* allocate(std::size_t) noexcept 21 | { 22 | return nullptr; 23 | } 24 | 25 | __AGENCY_ANNOTATION 26 | void deallocate(void*, std::size_t) noexcept 27 | { 28 | } 29 | }; 30 | 31 | 32 | } // end detail 33 | } // end agency 34 | 35 | -------------------------------------------------------------------------------- /testing/execution/executor/execution_functions/twoway_execute.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | #include "../test_executors.hpp" 10 | 11 | 12 | template 13 | void test(Executor exec) 14 | { 15 | auto f = agency::detail::twoway_execute(exec, []{ return 7;}); 16 | 17 | auto result = f.get(); 18 | 19 | assert(7 == result); 20 | } 21 | 22 | 23 | int main() 24 | { 25 | test(then_executor()); 26 | test(twoway_executor()); 27 | test(bulk_then_executor()); 28 | test(bulk_twoway_executor()); 29 | 30 | // XXX call test() with all the other types of executors 31 | 32 | std::cout << "OK" << std::endl; 33 | 34 | return 0; 35 | } 36 | 37 | -------------------------------------------------------------------------------- /testing/unorganized/test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() 6 | { 7 | using namespace agency; 8 | 9 | bulk_invoke(seq(4), [&](sequenced_agent &g) 10 | { 11 | std::cout << g.index() << std::endl; 12 | }); 13 | 14 | auto f1 = bulk_async(seq(4), [&](sequenced_agent &g) 15 | { 16 | std::cout << g.index() << std::endl; 17 | }); 18 | 19 | f1.wait(); 20 | 21 | auto f2 = bulk_async(seq(2, seq(1)), [&](sequenced_group &self) 22 | { 23 | std::cout << self.index() << std::endl; 24 | }); 25 | 26 | f2.wait(); 27 | 28 | auto f3 = bulk_async(seq(3, seq(1, seq(4))), [&](sequenced_group> &self) 29 | { 30 | std::cout << self.index() << std::endl; 31 | }); 32 | 33 | f3.wait(); 34 | 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /agency/detail/control_structures/README.md: -------------------------------------------------------------------------------- 1 | This directory contains the implementations of the control structures: 2 | 3 | * `bulk_invoke` 4 | * `bulk_async` 5 | * `bulk_then` 6 | 7 | The implementations of these functions share a similar structure. 8 | 9 | The publically accessable entry points to these functions in `agency::` first use an `enable_if` 10 | to guard the entry point and then lower onto functions in `agency::detail::`. For example, 11 | `agency::bulk_invoke()` lowers onto `agency::detail::bulk_invoke_execution_policy()`. 12 | 13 | `agency::detail::bulk_invoke_execution_policy()` sets up a function which 14 | creates an execution agent and calls the user-provided function `f` with the agent 15 | and other user-provided arguments as parameters. This function is then invoked 16 | using the lower-level `agency::detail::bulk_invoke_executor()` function. 17 | 18 | -------------------------------------------------------------------------------- /agency/detail/iterator/iterator_traits/iterator_is_random_access.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace detail 11 | { 12 | 13 | 14 | template 15 | using iterator_is_random_access = std::is_convertible< 16 | typename std::iterator_traits::iterator_category, 17 | std::random_access_iterator_tag 18 | >; 19 | 20 | 21 | // XXX WAR nvbug 1965154 22 | //template 23 | //using iterators_are_random_access = conjunction< 24 | // iterator_is_random_access... 25 | //>; 26 | template 27 | struct iterators_are_random_access : conjunction< 28 | iterator_is_random_access... 29 | > 30 | {}; 31 | 32 | 33 | } // end detail 34 | } // end agency 35 | 36 | -------------------------------------------------------------------------------- /testing/experimental/ranges/statically_bounded.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | 9 | void test() 10 | { 11 | using namespace agency::experimental; 12 | 13 | std::vector ints(10); 14 | std::iota(ints.begin(), ints.end(), 0); 15 | 16 | auto rng = statically_bounded<13>(ints); 17 | 18 | std::vector ref(10); 19 | std::iota(ref.begin(), ref.end(), 0); 20 | 21 | assert(std::equal(ref.begin(), ref.end(), rng.begin())); 22 | 23 | std::fill(rng.begin(), rng.end(), 13); 24 | std::fill(ref.begin(), ref.end(), 13); 25 | 26 | assert(std::equal(ref.begin(), ref.end(), rng.begin())); 27 | } 28 | 29 | int main() 30 | { 31 | test(); 32 | 33 | std::cout << "OK" << std::endl; 34 | 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /testing/unorganized/cuda/fill.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | 9 | struct fill_functor 10 | { 11 | int* x; 12 | 13 | __host__ __device__ 14 | fill_functor(int* x_) 15 | : x(x_) 16 | {} 17 | 18 | __device__ 19 | void operator()(agency::parallel_agent& self) 20 | { 21 | int i = self.index(); 22 | x[i] = 13; 23 | } 24 | }; 25 | 26 | 27 | int main() 28 | { 29 | size_t n = 1 << 16; 30 | thrust::device_vector x(n); 31 | 32 | fill_functor func(raw_pointer_cast(x.data())); 33 | 34 | agency::bulk_invoke(agency::cuda::par(n), func); 35 | 36 | assert(thrust::all_of(x.begin(), x.end(), thrust::placeholders::_1 == 13)); 37 | 38 | std::cout << "OK" << std::endl; 39 | 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/utility/executor_bulk_result.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace detail 11 | { 12 | 13 | 14 | template::value> 15 | struct executor_bulk_result {}; 16 | 17 | template 18 | struct executor_bulk_result 19 | { 20 | using type = bulk_result< 21 | T, 22 | executor_shape_t, 23 | executor_allocator_t 24 | >; 25 | }; 26 | 27 | 28 | template 29 | using executor_bulk_result_t = typename executor_bulk_result::type; 30 | 31 | 32 | } // end detail 33 | } // end agency 34 | 35 | 36 | -------------------------------------------------------------------------------- /testing/unorganized/fill.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | using namespace agency; 9 | 10 | size_t n = 1 << 16; 11 | std::vector x(n); 12 | 13 | auto f = bulk_async(par(n), [&](parallel_agent &self) 14 | { 15 | int i = self.index(); 16 | x[i] = 13; 17 | }); 18 | 19 | try 20 | { 21 | f.get(); 22 | } 23 | catch(exception_list &e) 24 | { 25 | std::cerr << "caught exception_list: " << e.what() << std::endl; 26 | std::terminate(); 27 | } 28 | 29 | for(size_t i = 0; i < n; ++i) 30 | { 31 | if(x[i] != 13) 32 | { 33 | std::cout << "x[" << i << "]: " << x[i] << std::endl; 34 | } 35 | } 36 | 37 | assert(std::all_of(x.begin(), x.end(), [=](int x){ return 13 == x; })); 38 | 39 | std::cout << "OK" << std::endl; 40 | 41 | return 0; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /testing/execution/executor/execution_functions/cuda/twoway_execute.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | #include "../../test_executors.hpp" 10 | 11 | 12 | template 13 | void test(Executor exec) 14 | { 15 | auto f = agency::detail::twoway_execute(exec, [] __host__ __device__ { return 7;}); 16 | 17 | auto result = f.get(); 18 | 19 | assert(7 == result); 20 | } 21 | 22 | 23 | int main() 24 | { 25 | test(then_executor()); 26 | test(twoway_executor()); 27 | test(bulk_then_executor()); 28 | test(bulk_twoway_executor()); 29 | test(agency::cuda::grid_executor()); 30 | 31 | // XXX call test() with all the other types of executors 32 | 33 | std::cout << "OK" << std::endl; 34 | 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /testing/unorganized/cuda/test_grid_executor_2d.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct hello_world 5 | { 6 | __device__ 7 | void operator()(agency::cuda::grid_executor_2d::index_type index) 8 | { 9 | auto outer = agency::get<0>(index); 10 | auto inner = agency::get<1>(index); 11 | printf("Hello world from block {%d,%d}, thread {%d,%d}\n", outer[0], outer[1], inner[0], inner[1]); 12 | } 13 | }; 14 | 15 | int main() 16 | { 17 | agency::cuda::grid_executor_2d ex; 18 | 19 | auto num_blocks = agency::uint2{2,2}; 20 | auto num_threads = agency::uint2{2,2}; 21 | agency::cuda::grid_executor_2d::shape_type shape = {num_blocks, num_threads}; 22 | 23 | std::cout << "Testing execute on host" << std::endl; 24 | agency::detail::blocking_bulk_twoway_execute_with_auto_result_and_without_shared_parameters(ex, hello_world(), shape); 25 | 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /agency/detail/iterator/data.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | __agency_exec_check_disable__ 13 | template 14 | __AGENCY_ANNOTATION 15 | constexpr auto data(C& c) -> decltype(c.data()) 16 | { 17 | return c.data(); 18 | } 19 | 20 | 21 | __agency_exec_check_disable__ 22 | template 23 | __AGENCY_ANNOTATION 24 | constexpr auto data(const C& c) -> decltype(c.data()) 25 | { 26 | return c.data(); 27 | } 28 | 29 | 30 | template 31 | __AGENCY_ANNOTATION 32 | constexpr T* data(T (&array)[n]) noexcept 33 | { 34 | return array; 35 | } 36 | 37 | 38 | template 39 | __AGENCY_ANNOTATION 40 | constexpr const E* data(std::initializer_list il) noexcept 41 | { 42 | return il.begin(); 43 | } 44 | 45 | 46 | } // end detail 47 | } // end agency 48 | 49 | -------------------------------------------------------------------------------- /agency/omp.hpp: -------------------------------------------------------------------------------- 1 | /// \file 2 | /// \brief Include this file to use any component of Agency which is not experimental and which requires 3 | /// OpenMP C++ language extensions. 4 | /// 5 | /// Including `` recursively includes most of the header files organized beneath 6 | /// ``. It is provided for quick access to most of Agency's OpenMP features. Features not included 7 | /// by this header, but which are organized beneath `` are considered experimental. 8 | /// 9 | /// Specifically, `` provides definitions for all entities inside the `agency::omp` namespace, 10 | /// except for `agency::omp::experimental`. 11 | /// 12 | 13 | #pragma once 14 | 15 | #include 16 | #include 17 | 18 | /// \namespace agency::omp 19 | /// \brief `agency::omp` is the namespace which contains OpenMP-specific functionality. 20 | /// 21 | 22 | -------------------------------------------------------------------------------- /testing/execution/executor/customization_points/make_ready_future.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "../test_executors.hpp" 6 | 7 | template 8 | void test(Executor exec) 9 | { 10 | // make a void future 11 | { 12 | auto f = agency::make_ready_future(exec); 13 | assert(f.valid()); 14 | f.wait(); 15 | } 16 | 17 | // make an int future 18 | { 19 | auto f = agency::make_ready_future(exec, 13); 20 | assert(f.valid()); 21 | assert(f.get() == 13); 22 | } 23 | } 24 | 25 | int main() 26 | { 27 | test(bulk_twoway_executor()); 28 | test(bulk_then_executor()); 29 | 30 | test(not_a_bulk_twoway_executor()); 31 | test(not_a_bulk_then_executor()); 32 | 33 | test(complete_bulk_executor()); 34 | 35 | std::cout << "OK" << std::endl; 36 | 37 | return 0; 38 | } 39 | 40 | -------------------------------------------------------------------------------- /agency/execution/executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | -------------------------------------------------------------------------------- /agency/cuda/memory/allocator/pinned_allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | namespace agency 10 | { 11 | namespace cuda 12 | { 13 | 14 | 15 | template 16 | class pinned_allocator : public agency::detail::allocator_adaptor 17 | { 18 | private: 19 | using super_t = agency::detail::allocator_adaptor; 20 | 21 | public: 22 | using super_t::super_t; 23 | 24 | pinned_allocator() = default; 25 | 26 | pinned_allocator(const pinned_allocator&) = default; 27 | 28 | template 29 | pinned_allocator(const pinned_allocator& other) 30 | : super_t(other) 31 | {} 32 | }; 33 | 34 | 35 | } // end cuda 36 | } // end agency 37 | 38 | -------------------------------------------------------------------------------- /agency/experimental/ranges.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/executor_shape.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | namespace agency 10 | { 11 | namespace detail 12 | { 13 | 14 | 15 | template::value> 16 | struct executor_shape_impl 17 | { 18 | }; 19 | 20 | template 21 | struct executor_shape_impl 22 | { 23 | using type = member_shape_type_or_t>; 24 | }; 25 | 26 | 27 | } // end detail 28 | 29 | 30 | template 31 | struct executor_shape : detail::executor_shape_impl {}; 32 | 33 | template 34 | using executor_shape_t = typename executor_shape::type; 35 | 36 | 37 | } // end agency 38 | 39 | -------------------------------------------------------------------------------- /agency/memory/detail/resource/malloc_resource.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | struct malloc_resource 14 | { 15 | __AGENCY_ANNOTATION 16 | inline void* allocate(size_t num_bytes) 17 | { 18 | return malloc(num_bytes); 19 | } 20 | 21 | __AGENCY_ANNOTATION 22 | inline void deallocate(void* ptr, size_t) 23 | { 24 | free(ptr); 25 | } 26 | 27 | __AGENCY_ANNOTATION 28 | inline bool is_equal(const malloc_resource&) const 29 | { 30 | return true; 31 | } 32 | }; 33 | 34 | 35 | __AGENCY_ANNOTATION 36 | inline bool operator==(const malloc_resource& a, const malloc_resource& b) 37 | { 38 | return a.is_equal(b); 39 | } 40 | 41 | __AGENCY_ANNOTATION 42 | inline bool operator!=(const malloc_resource& a, const malloc_resource& b) 43 | { 44 | return !(a == b); 45 | } 46 | 47 | 48 | } // end detail 49 | } // end agency 50 | 51 | -------------------------------------------------------------------------------- /agency/detail/terminate.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | 9 | namespace agency 10 | { 11 | namespace detail 12 | { 13 | 14 | 15 | // XXX consider using __cpp_exceptions below to portably check for exception support 16 | // rather than using __CUDA_ARCH__ 17 | 18 | 19 | __AGENCY_ANNOTATION 20 | inline void terminate() 21 | { 22 | #ifdef __CUDA_ARCH__ 23 | asm("trap;"); 24 | #else 25 | std::terminate(); 26 | #endif 27 | } 28 | 29 | 30 | __AGENCY_ANNOTATION 31 | inline void terminate_with_message(const char* message) 32 | { 33 | printf("%s\n", message); 34 | 35 | detail::terminate(); 36 | } 37 | 38 | 39 | __AGENCY_ANNOTATION 40 | inline void throw_runtime_error(const char* message) 41 | { 42 | #ifndef __CUDA_ARCH__ 43 | throw std::runtime_error(message); 44 | #else 45 | detail::terminate_with_message(message); 46 | #endif 47 | } 48 | 49 | 50 | } // end detail 51 | } // end agency 52 | 53 | -------------------------------------------------------------------------------- /agency/detail/iterator/advance.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template 13 | __AGENCY_ANNOTATION 14 | RandomAccessIterator& advance(std::random_access_iterator_tag, RandomAccessIterator& iter, Distance n) 15 | { 16 | iter += n; 17 | return iter; 18 | } 19 | 20 | template 21 | __AGENCY_ANNOTATION 22 | InputIterator& advance(std::input_iterator_tag, InputIterator& iter, Distance n) 23 | { 24 | for(Distance i = 0; i != n; ++i) 25 | { 26 | ++iter; 27 | } 28 | 29 | return iter; 30 | } 31 | 32 | template 33 | __AGENCY_ANNOTATION 34 | InputIterator& advance(InputIterator& iter, Distance n) 35 | { 36 | return detail::advance(typename std::iterator_traits::iterator_category(), iter, n); 37 | } 38 | 39 | 40 | } // end detail 41 | } // end agency 42 | 43 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/utility/executor_bulk_result_or_void.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace detail 11 | { 12 | 13 | 14 | template::value> 15 | struct executor_bulk_result_or_void {}; 16 | 17 | template 18 | struct executor_bulk_result_or_void 19 | { 20 | using type = typename detail::lazy_conditional< 21 | std::is_void::value, 22 | detail::identity, 23 | executor_bulk_result 24 | >::type; 25 | }; 26 | 27 | 28 | template 29 | using executor_bulk_result_or_void_t = typename executor_bulk_result_or_void::type; 30 | 31 | 32 | } // end detail 33 | } // end agency 34 | 35 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/executor_future.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | namespace agency 10 | { 11 | namespace detail 12 | { 13 | 14 | 15 | template::value> 16 | struct executor_future_impl 17 | { 18 | }; 19 | 20 | template 21 | struct executor_future_impl 22 | { 23 | using type = member_future_or_t; 24 | }; 25 | 26 | 27 | } // end detail 28 | 29 | 30 | template 31 | struct executor_future : detail::executor_future_impl {}; 32 | 33 | template 34 | using executor_future_t = typename executor_future::type; 35 | 36 | 37 | } // end agency 38 | 39 | -------------------------------------------------------------------------------- /testing/execution/executor/customization_points/cuda/make_ready_future.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include "../../test_executors.hpp" 7 | 8 | template 9 | void test(Executor exec) 10 | { 11 | // make a void future 12 | { 13 | auto f = agency::make_ready_future(exec); 14 | assert(f.valid()); 15 | f.wait(); 16 | } 17 | 18 | // make an int future 19 | { 20 | auto f = agency::make_ready_future(exec, 13); 21 | assert(f.valid()); 22 | assert(f.get() == 13); 23 | } 24 | } 25 | 26 | int main() 27 | { 28 | test(bulk_twoway_executor()); 29 | test(bulk_then_executor()); 30 | 31 | test(not_a_bulk_twoway_executor()); 32 | test(not_a_bulk_then_executor()); 33 | 34 | test(complete_bulk_executor()); 35 | 36 | test(agency::cuda::grid_executor()); 37 | 38 | std::cout << "OK" << std::endl; 39 | 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/executor_index.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | namespace agency 10 | { 11 | namespace detail 12 | { 13 | 14 | 15 | template::value> 16 | struct executor_index_impl 17 | { 18 | }; 19 | 20 | template 21 | struct executor_index_impl 22 | { 23 | using type = member_index_type_or_t>; 24 | }; 25 | 26 | 27 | } // end detail 28 | 29 | 30 | template 31 | struct executor_index : detail::executor_index_impl {}; 32 | 33 | template 34 | using executor_index_t = typename executor_index::type; 35 | 36 | 37 | } // end agency 38 | 39 | -------------------------------------------------------------------------------- /testing/future/cuda/async_future/make_dependent_stream.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | __managed__ int global_variable; 6 | 7 | __global__ void get_global_variable(int* result) 8 | { 9 | *result = global_variable; 10 | } 11 | 12 | int main() 13 | { 14 | using namespace agency; 15 | 16 | std::vector> result(1, 13); 17 | 18 | // global_variable starts out at zero 19 | global_variable = 0; 20 | 21 | cuda::async_future f = bulk_async(cuda::par(1), [] __device__ (parallel_agent& self) 22 | { 23 | global_variable = 7; 24 | }); 25 | 26 | // launch a kernel but make its launch dependent on f's completion 27 | cudaStream_t stream = cuda::experimental::make_dependent_stream(f); 28 | 29 | get_global_variable<<<1,1,0,stream>>>(result.data()); 30 | 31 | cudaStreamSynchronize(stream); 32 | cudaStreamDestroy(stream); 33 | 34 | assert(result[0] == 7); 35 | 36 | std::cout << "OK" << std::endl; 37 | 38 | return 0; 39 | } 40 | 41 | -------------------------------------------------------------------------------- /agency/execution/executor/executor_traits/executor_allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | namespace agency 11 | { 12 | namespace detail 13 | { 14 | 15 | 16 | template::value> 17 | struct executor_allocator_impl 18 | { 19 | }; 20 | 21 | template 22 | struct executor_allocator_impl 23 | { 24 | using type = member_allocator_or_t; 25 | }; 26 | 27 | 28 | } // end detail 29 | 30 | 31 | template 32 | struct executor_allocator : detail::executor_allocator_impl {}; 33 | 34 | template 35 | using executor_allocator_t = typename executor_allocator::type; 36 | 37 | 38 | } // end agency 39 | 40 | -------------------------------------------------------------------------------- /agency/cuda/memory/allocator/managed_allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace cuda 11 | { 12 | 13 | 14 | template 15 | class managed_allocator : public agency::detail::allocator_adaptor 16 | { 17 | private: 18 | using super_t = agency::detail::allocator_adaptor; 19 | 20 | public: 21 | explicit managed_allocator(const device_id& d) 22 | : super_t(managed_resource(d)) 23 | {} 24 | 25 | managed_allocator() 26 | : managed_allocator(device_id(0)) 27 | {} 28 | 29 | managed_allocator(const managed_allocator&) = default; 30 | 31 | template 32 | managed_allocator(const managed_allocator& other) 33 | : managed_allocator(other.device()) 34 | {} 35 | }; 36 | 37 | 38 | } // end cuda 39 | } // end agency 40 | 41 | -------------------------------------------------------------------------------- /agency/detail/unwrap_tuple_if.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | template 14 | __AGENCY_ANNOTATION 15 | static auto unwrap_tuple_if_impl(std::true_type, Tuple&& t) 16 | -> decltype(agency::get<0>(std::forward(t))) 17 | { 18 | return agency::get<0>(std::forward(t)); 19 | } 20 | 21 | template 22 | __AGENCY_ANNOTATION 23 | static auto unwrap_tuple_if_impl(std::false_type, Tuple&& t) 24 | -> decltype(std::forward(t)) 25 | { 26 | return std::forward(t); 27 | } 28 | 29 | 30 | template 31 | __AGENCY_ANNOTATION 32 | auto unwrap_tuple_if(Tuple&& t) 33 | -> decltype( 34 | detail::unwrap_tuple_if_impl(std::integral_constant(), std::forward(t)) 35 | ) 36 | { 37 | return detail::unwrap_tuple_if_impl(std::integral_constant(), std::forward(t)); 38 | } 39 | 40 | 41 | } // end detail 42 | } // end agency 43 | 44 | -------------------------------------------------------------------------------- /agency/detail/requires.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | // The __AGENCY_REQUIRES() macro may be used in a function template's parameter list 7 | // to simulate Concepts. 8 | // 9 | // For example, to selectively enable a function template only for integer types, 10 | // we could do something like this: 11 | // 12 | // template::value) 14 | // > 15 | // Integer plus_one(Integer x) 16 | // { 17 | // return x + 1; 18 | // } 19 | // 20 | 21 | #define __AGENCY_CONCATENATE_IMPL(x, y) x##y 22 | 23 | #define __AGENCY_CONCATENATE(x, y) __AGENCY_CONCATENATE_IMPL(x, y) 24 | 25 | #define __AGENCY_MAKE_UNIQUE(x) __AGENCY_CONCATENATE(x, __COUNTER__) 26 | 27 | #define __AGENCY_REQUIRES_IMPL(unique_name, ...) bool unique_name = true, typename std::enable_if<(unique_name and __VA_ARGS__)>::type* = nullptr 28 | 29 | #define __AGENCY_REQUIRES(...) __AGENCY_REQUIRES_IMPL(__AGENCY_MAKE_UNIQUE(__deduced_true), __VA_ARGS__) 30 | 31 | -------------------------------------------------------------------------------- /agency/cuda/detail/feature_test.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // cf. c++ feature test study group 4 | #if defined(__CUDACC__) 5 | # if !defined(__CUDA_ARCH__) || (__CUDA_ARCH__>= 350 && defined(__CUDACC_RDC__)) 6 | # define __cuda_lib_has_cudart 1 7 | # else 8 | # define __cuda_lib_has_cudart 0 9 | # endif 10 | #else 11 | # define __cuda_lib_has_cudart 0 12 | #endif 13 | 14 | #if defined(__CUDACC__) 15 | # if !defined(__CUDA_ARCH__) || (__CUDA_ARCH__ >= 200) 16 | # define __cuda_lib_has_printf 1 17 | # else 18 | # define __cuda_lib_has_printf 0 19 | # endif 20 | #else 21 | # define __cuda_lib_has_printf 1 22 | #endif 23 | 24 | 25 | #if (!defined(__CUDA_ARCH__) || (__CUDA_ARCH__ == 0)) && (CUDART_VERSION >= 9000) 26 | # define __cuda_lib_has_cudaLaunchCooperativeKernel 1 27 | #else 28 | # define __cuda_lib_has_cudaLaunchCooperativeKernel 0 29 | #endif 30 | 31 | 32 | #if (CUDART_VERSION >= 9000) && (__CUDACC_RDC__) && (__CUDA_ARCH__ >= 500) 33 | # define __cuda_lib_has_cooperative_groups 1 34 | #else 35 | # define __cuda_lib_has_cooperative_groups 0 36 | #endif 37 | 38 | -------------------------------------------------------------------------------- /agency/coordinate/detail/shape/shape_size.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | // shape_size is a type trait which returns the 13 | // number of elements in a Shape. 14 | // 15 | // A Shape is either: 16 | // 1. An integral type or 17 | // 2. A tuple of Shapes 18 | // 19 | // shape_element's implementation below needs to handle these two cases. 20 | 21 | 22 | // case 2: Shape is a Tuple-like type 23 | template 24 | struct shape_size_impl : std::tuple_size {}; 25 | 26 | 27 | // case 1: Shape is an integral type. 28 | template 29 | struct shape_size_impl< 30 | Shape, 31 | typename std::enable_if< 32 | std::is_integral::value 33 | >::type 34 | > : std::integral_constant 35 | { 36 | }; 37 | 38 | 39 | template 40 | struct shape_size : std::integral_constant::value> {}; 41 | 42 | 43 | } // end detail 44 | } // end agency 45 | 46 | -------------------------------------------------------------------------------- /testing/execution/executor/executor_traits/executor_shape.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "../test_executors.hpp" 6 | 7 | int main() 8 | { 9 | static_assert(!agency::detail::is_detected::value, "executor_shape_t should not be detected"); 10 | 11 | static_assert(agency::detail::is_detected_exact::value, "bulk_executor_without_shape_type should have size_t shape_type"); 12 | 13 | static_assert(agency::detail::is_detected_exact::value, "bulk_executor_with_shape_type should have bulk_executor_with_shape_type::shape_type shape_type"); 14 | 15 | static_assert(agency::detail::is_detected_exact::value, "bulk_then_executor should have size_t shape_type"); 16 | 17 | std::cout << "OK" << std::endl; 18 | 19 | return 0; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /testing/execution/executor/utility/blocking_bulk_twoway_execute_with_void_result.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include "../test_executors.hpp" 7 | 8 | template 9 | void test(Executor exec) 10 | { 11 | std::atomic counter{0}; 12 | 13 | using shape_type = agency::executor_shape_t; 14 | using index_type = agency::executor_index_t; 15 | 16 | shape_type shape{10}; 17 | 18 | agency::detail::blocking_bulk_twoway_execute_with_void_result(exec, 19 | [&](index_type, int& shared_arg) 20 | { 21 | counter += shared_arg; 22 | }, 23 | shape, 24 | []{ return 13; } // shared_arg 25 | ); 26 | 27 | assert(counter == 13 * 10); 28 | } 29 | 30 | 31 | int main() 32 | { 33 | test(bulk_twoway_executor()); 34 | test(bulk_then_executor()); 35 | test(not_a_bulk_twoway_executor()); 36 | test(not_a_bulk_then_executor()); 37 | test(complete_bulk_executor()); 38 | 39 | std::cout << "OK" << std::endl; 40 | 41 | return 0; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /agency/cuda.hpp: -------------------------------------------------------------------------------- 1 | /// \file 2 | /// \brief Include this file to use any component of Agency which is not experimental and which requires 3 | /// CUDA C++ language extensions. 4 | /// 5 | /// Including `` recursively includes most of the header files organized beneath 6 | /// ``. It is provided for quick access to most of Agency's CUDA features. Features not included 7 | /// by this header, but which are organized beneath `` are considered experimental. 8 | /// 9 | /// Specifically, `` provides definitions for all entities inside the `agency::cuda` namespace, 10 | /// except for `agency::cuda::experimental`. 11 | /// 12 | 13 | #pragma once 14 | 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | 23 | /// \namespace agency::cuda 24 | /// \brief `agency::cuda` is the namespace which contains CUDA-specific functionality. 25 | /// 26 | 27 | -------------------------------------------------------------------------------- /testing/execution/executor/utility/blocking_bulk_twoway_execute_with_collected_result.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "../test_executors.hpp" 6 | 7 | template 8 | void test(Executor exec) 9 | { 10 | using index_type = agency::executor_index_t; 11 | 12 | size_t shape = 10; 13 | 14 | auto result = agency::detail::blocking_bulk_twoway_execute_with_collected_result(exec, 15 | [](index_type idx, std::vector& shared_arg) 16 | { 17 | return shared_arg[idx]; 18 | }, 19 | shape, 20 | [=]{ return std::vector(shape); }, // results 21 | [=]{ return std::vector(shape, 13); } // shared_arg 22 | ); 23 | 24 | assert(std::vector(shape, 13) == result); 25 | } 26 | 27 | int main() 28 | { 29 | test(bulk_twoway_executor()); 30 | test(bulk_then_executor()); 31 | test(not_a_bulk_twoway_executor()); 32 | test(not_a_bulk_then_executor()); 33 | test(complete_bulk_executor()); 34 | 35 | std::cout << "OK" << std::endl; 36 | 37 | return 0; 38 | } 39 | 40 | -------------------------------------------------------------------------------- /testing/execution/executor/utility/bulk_twoway_execute_with_void_result.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include "../test_executors.hpp" 7 | 8 | template 9 | void test(Executor exec) 10 | { 11 | std::atomic counter{0}; 12 | 13 | using shape_type = agency::executor_shape_t; 14 | using index_type = agency::executor_index_t; 15 | 16 | shape_type shape{10}; 17 | 18 | auto f = agency::detail::bulk_twoway_execute_with_void_result(exec, 19 | [&](index_type, int& shared_arg) 20 | { 21 | counter += shared_arg; 22 | }, 23 | shape, 24 | []{ return 13; } // shared_arg 25 | ); 26 | 27 | f.wait(); 28 | 29 | assert(counter == 13 * 10); 30 | } 31 | 32 | 33 | int main() 34 | { 35 | test(bulk_twoway_executor()); 36 | test(bulk_then_executor()); 37 | test(not_a_bulk_twoway_executor()); 38 | test(not_a_bulk_then_executor()); 39 | test(complete_bulk_executor()); 40 | 41 | std::cout << "OK" << std::endl; 42 | 43 | return 0; 44 | } 45 | 46 | -------------------------------------------------------------------------------- /testing/execution/executor/utility/bulk_twoway_execute_with_collected_result.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "../test_executors.hpp" 6 | 7 | template 8 | void test(Executor exec) 9 | { 10 | using index_type = agency::executor_index_t; 11 | 12 | size_t shape = 10; 13 | 14 | auto f = agency::detail::bulk_twoway_execute_with_collected_result(exec, 15 | [](index_type idx, std::vector& shared_arg) 16 | { 17 | return shared_arg[idx]; 18 | }, 19 | shape, 20 | [=]{ return std::vector(shape); }, // results 21 | [=]{ return std::vector(shape, 13); } // shared_arg 22 | ); 23 | 24 | auto result = f.get(); 25 | 26 | assert(std::vector(shape, 13) == result); 27 | } 28 | 29 | int main() 30 | { 31 | test(bulk_twoway_executor()); 32 | test(bulk_then_executor()); 33 | test(not_a_bulk_twoway_executor()); 34 | test(not_a_bulk_then_executor()); 35 | test(complete_bulk_executor()); 36 | 37 | std::cout << "OK" << std::endl; 38 | 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/experimental/static_concurrent_agent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | namespace agency 10 | { 11 | namespace experimental 12 | { 13 | 14 | // XXX consider moving this to a location where default_concurrent_resource can call it 15 | __AGENCY_ANNOTATION 16 | constexpr std::size_t default_pool_size(std::size_t group_size) 17 | { 18 | return group_size * sizeof(int); 19 | } 20 | 21 | template 22 | using static_concurrent_agent = detail::basic_static_execution_agent< 23 | agency::detail::basic_concurrent_agent< 24 | std::size_t, 25 | agency::detail::default_barrier, 26 | agency::detail::arena_resource 27 | >, 28 | group_size, 29 | grain_size 30 | >; 31 | 32 | 33 | } // end experimental 34 | } // end agency 35 | 36 | -------------------------------------------------------------------------------- /agency/detail/is_call_possible.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template 13 | struct has_member_type_impl 14 | { 15 | typedef char yes_type; 16 | typedef int no_type; 17 | template static yes_type test(typename S::type *); 18 | template static no_type test(...); 19 | static bool const value = sizeof(test(0)) == sizeof(yes_type); 20 | typedef std::integral_constant type; 21 | }; 22 | 23 | 24 | template 25 | struct has_member_type : has_member_type_impl::type {}; 26 | 27 | 28 | template 29 | struct is_call_possible 30 | : has_member_type< 31 | std::result_of 32 | > 33 | { 34 | }; 35 | 36 | 37 | template 38 | struct enable_if_call_possible 39 | : std::enable_if< 40 | agency::detail::is_call_possible< 41 | Function,Args... 42 | >::value, 43 | Result 44 | > 45 | {}; 46 | 47 | 48 | } // end detail 49 | } // end agency 50 | 51 | -------------------------------------------------------------------------------- /agency/coordinate/detail/shape/make_shape.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | template 14 | struct make_shape_impl 15 | { 16 | template 17 | __AGENCY_ANNOTATION 18 | static Shape make(Args&&... args) 19 | { 20 | return Shape{std::forward(args)...}; 21 | } 22 | }; 23 | 24 | // specialization for std::array, which requires the weird doubly-nested brace syntax 25 | template 26 | struct make_shape_impl> 27 | { 28 | template 29 | __AGENCY_ANNOTATION 30 | static std::array make(Args&&... args) 31 | { 32 | return std::array{{std::forward(args)...}}; 33 | } 34 | }; 35 | 36 | 37 | // make_shape makes a Shape from a list of elements 38 | // XXX should probably require that the number of Args... matches shape_size 39 | template 40 | __AGENCY_ANNOTATION 41 | Shape make_shape(Args&&... args) 42 | { 43 | return make_shape_impl::make(std::forward(args)...); 44 | } 45 | 46 | 47 | } // end detail 48 | } // end agency 49 | 50 | -------------------------------------------------------------------------------- /agency/detail/iterator/distance.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template 13 | __AGENCY_ANNOTATION 14 | typename std::iterator_traits::difference_type distance(std::random_access_iterator_tag, RandomAccessIterator first, RandomAccessIterator last) 15 | { 16 | return last - first; 17 | } 18 | 19 | template 20 | __AGENCY_ANNOTATION 21 | typename std::iterator_traits::difference_type distance(std::input_iterator_tag, InputIterator first, InputIterator last) 22 | { 23 | typename std::iterator_traits::difference_type result = 0; 24 | 25 | for(; first != last; ++first) 26 | { 27 | ++result; 28 | } 29 | 30 | return result; 31 | } 32 | 33 | template 34 | __AGENCY_ANNOTATION 35 | typename std::iterator_traits::difference_type distance(InputIterator first, InputIterator last) 36 | { 37 | return detail::distance(typename std::iterator_traits::iterator_category(), first, last); 38 | } 39 | 40 | 41 | } // end detail 42 | } // end agency 43 | 44 | -------------------------------------------------------------------------------- /examples/hello_async.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() 6 | { 7 | using namespace agency; 8 | 9 | std::cout << "Starting two tasks asynchronously..." << std::endl; 10 | 11 | std::mutex mut; 12 | 13 | // asynchronously create 5 agents to greet us in bulk 14 | auto f1 = bulk_async(par(5), [&](parallel_agent& self) 15 | { 16 | mut.lock(); 17 | std::cout << "Hello, world from agent " << self.index() << " in task 1" << std::endl; 18 | mut.unlock(); 19 | }); 20 | 21 | // asynchronously create 5 agents to greet us in bulk 22 | auto f2 = bulk_async(par(5), [&](parallel_agent& self) 23 | { 24 | mut.lock(); 25 | std::cout << "Hello, world from agent " << self.index() << " in task 2" << std::endl; 26 | mut.unlock(); 27 | }); 28 | 29 | std::cout << "Sleeping before waiting on the tasks..." << std::endl; 30 | std::this_thread::sleep_for(std::chrono::seconds(1)); 31 | std::cout << "Woke up, waiting for the tasks to complete..." << std::endl; 32 | 33 | // wait for tasks 1 & 2 to complete before continuing 34 | f1.wait(); 35 | f2.wait(); 36 | 37 | std::cout << "OK" << std::endl; 38 | 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/utility/blocking_twoway_execute.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | 14 | namespace agency 15 | { 16 | namespace detail 17 | { 18 | 19 | 20 | __agency_exec_check_disable__ 21 | template::value)> 22 | __AGENCY_ANNOTATION 23 | detail::result_of_t()> 24 | blocking_twoway_execute(const E& exec, Function&& f) 25 | { 26 | // get a reference to avoid copies in agency::require 27 | executor_ref exec_ref{exec}; 28 | 29 | return agency::require(exec_ref, always_blocking, single, twoway).twoway_execute(std::forward(f)).get(); 30 | } 31 | 32 | 33 | } // end detail 34 | } // end agency 35 | 36 | -------------------------------------------------------------------------------- /examples/concurrent_ping_pong.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | int main() 8 | { 9 | int ball = 0; 10 | std::string names[2] = {"ping", "pong"}; 11 | std::mutex mut; 12 | 13 | // create two concurrent agents 14 | agency::bulk_invoke(agency::con(2), [&](agency::concurrent_agent& self) 15 | { 16 | auto name = names[self.index()]; 17 | 18 | // play for 20 volleys 19 | for(int next_state = self.index(); next_state < 20; next_state += 2) 20 | { 21 | // wait for the next volley 22 | while(ball != next_state) 23 | { 24 | mut.lock(); 25 | std::cout << name << " waiting for return" << std::endl; 26 | mut.unlock(); 27 | 28 | std::this_thread::sleep_for(std::chrono::seconds(1)); 29 | } 30 | 31 | // return the ball 32 | mut.lock(); 33 | ball += 1; 34 | std::cout << name << "! ball is now " << ball << std::endl; 35 | mut.unlock(); 36 | 37 | std::this_thread::sleep_for(std::chrono::seconds(1)); 38 | } 39 | }); 40 | 41 | assert(ball == 20); 42 | 43 | std::cout << "OK" << std::endl; 44 | 45 | return 0; 46 | } 47 | 48 | -------------------------------------------------------------------------------- /agency/detail/host_device_cast.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | template 14 | struct host_device_function 15 | { 16 | FunctionReference f_; 17 | 18 | __agency_exec_check_disable__ 19 | template 20 | __AGENCY_ANNOTATION 21 | auto operator()(Args&&... args) const 22 | -> decltype( 23 | agency::detail::invoke(std::forward(f_), std::forward(args)...) 24 | ) 25 | { 26 | return agency::detail::invoke(std::forward(f_), std::forward(args)...); 27 | } 28 | }; 29 | 30 | 31 | template 32 | __AGENCY_ANNOTATION 33 | host_device_function host_device_cast(Function&& f) 34 | { 35 | return host_device_function{std::forward(f)}; 36 | } 37 | 38 | 39 | // avoid nested wrapping 40 | template 41 | __AGENCY_ANNOTATION 42 | host_device_function host_device_cast(host_device_function f) 43 | { 44 | return f; 45 | } 46 | 47 | 48 | } // end detail 49 | } // end agency 50 | 51 | -------------------------------------------------------------------------------- /testing/coordinate/point/fill_constructor.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void test_fill_constructor() 7 | { 8 | using namespace agency; 9 | 10 | { 11 | // test fill construct 1D point 12 | constexpr size_t num_elements = 1; 13 | 14 | point p(13); 15 | 16 | ptrdiff_t expected_difference = num_elements; 17 | 18 | assert(std::count(p.begin(), p.end(), 13) == expected_difference); 19 | } 20 | 21 | { 22 | // test fill construct 2D point 23 | constexpr size_t num_elements = 2; 24 | 25 | point p(13); 26 | 27 | ptrdiff_t expected_difference = num_elements; 28 | 29 | assert(std::count(p.begin(), p.end(), 13) == expected_difference); 30 | } 31 | 32 | { 33 | // test fill construct 3D point 34 | constexpr size_t num_elements = 3; 35 | 36 | point p(13); 37 | 38 | ptrdiff_t expected_difference = num_elements; 39 | 40 | assert(std::count(p.begin(), p.end(), 13) == expected_difference); 41 | } 42 | } 43 | 44 | int main() 45 | { 46 | test_fill_constructor(); 47 | 48 | std::cout << "OK" << std::endl; 49 | 50 | return 0; 51 | } 52 | 53 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/concurrent_agent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | 13 | namespace agency 14 | { 15 | namespace detail 16 | { 17 | 18 | 19 | using default_barrier = any_barrier; 20 | using default_concurrent_resource = tiered_resource, malloc_resource>; 21 | 22 | 23 | } // end detail 24 | 25 | 26 | // XXX consider introducing unique types for concurrent_agent & concurrent_agent_2d for the sake of better compiler error messages 27 | using concurrent_agent = detail::basic_concurrent_agent; 28 | using concurrent_agent_1d = concurrent_agent; 29 | using concurrent_agent_2d = detail::basic_concurrent_agent; 30 | 31 | 32 | } // end agency 33 | 34 | -------------------------------------------------------------------------------- /examples/concurrent_sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int sum(const std::vector& data) 5 | { 6 | using namespace agency; 7 | 8 | return bulk_invoke(con(data.size()), [&](concurrent_agent& self) -> single_result 9 | { 10 | // copy data into scratch buffer 11 | shared_vector scratch(self, data); 12 | 13 | auto i = self.index(); 14 | auto n = scratch.size(); 15 | 16 | while(n > 1) 17 | { 18 | if(i < n/2) 19 | { 20 | scratch[i] += scratch[n - i - 1]; 21 | } 22 | 23 | // wait for every agent in the group to reach this point 24 | self.wait(); 25 | 26 | // cut the number of active agents in half 27 | n -= n/2; 28 | } 29 | 30 | // the first agent returns the result 31 | if(i == 0) 32 | { 33 | return scratch[0]; 34 | } 35 | 36 | // all other agents return an ignored value 37 | return std::ignore; 38 | }); 39 | } 40 | 41 | int main() 42 | { 43 | int n = 10; 44 | 45 | std::vector data(n, 1); 46 | 47 | auto result = sum(data); 48 | 49 | std::cout << "sum is " << result << std::endl; 50 | 51 | assert(result == n); 52 | 53 | std::cout << "OK" << std::endl; 54 | 55 | return 0; 56 | } 57 | 58 | -------------------------------------------------------------------------------- /testing/algorithm/cuda/copy_n.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | template 11 | void test(ExecutionPolicy policy) 12 | { 13 | Container source(policy, 10, 7); 14 | Container dest(policy, source.size(), 13); 15 | 16 | auto result = agency::cuda::copy_n(policy, source.begin(), source.size(), dest.begin()); 17 | 18 | assert(source.end() == agency::get<0>(result)); 19 | assert(dest.end() == agency::get<1>(result)); 20 | assert(Container(10, 7) == dest); 21 | } 22 | 23 | int main() 24 | { 25 | using namespace agency; 26 | 27 | test>>(seq); 28 | test>>(par); 29 | test>>(cuda::par); 30 | 31 | // XXX disable this while operator== used in test() above executes in the current thread 32 | //test>>(cuda::par); 33 | 34 | std::cout << "OK" << std::endl; 35 | } 36 | 37 | -------------------------------------------------------------------------------- /agency/functional/invoke.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | namespace agency 12 | { 13 | 14 | 15 | template 16 | __AGENCY_ANNOTATION 17 | detail::result_of_t< 18 | typename std::decay::type(typename std::decay::type...) 19 | > 20 | invoke(Executor& exec, Function&& f, Args&&... args) 21 | { 22 | auto g = detail::bind(std::forward(f), std::forward(args)...); 23 | 24 | return detail::blocking_twoway_execute(exec, std::move(g)); 25 | } 26 | 27 | 28 | template 29 | detail::result_of_t< 30 | typename std::decay::type(typename std::decay::type...) 31 | > 32 | invoke(Function&& f, Args&&... args) 33 | { 34 | agency::sequenced_executor exec; 35 | return agency::invoke(exec, std::forward(f), std::forward(args)...); 36 | } 37 | 38 | 39 | } // end agency 40 | 41 | -------------------------------------------------------------------------------- /testing/container/vector/assign_operator.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | void test_assign_operator() 10 | { 11 | using namespace agency; 12 | 13 | { 14 | // test assign empty to empty 15 | 16 | vector empty; 17 | vector other_empty; 18 | 19 | empty = other_empty; 20 | 21 | assert(empty.empty()); 22 | assert(other_empty.empty()); 23 | } 24 | 25 | { 26 | // test assign non-empty to empty 27 | 28 | vector initially_empty; 29 | vector not_empty(10, 13); 30 | 31 | initially_empty = not_empty; 32 | 33 | assert(!initially_empty.empty()); 34 | assert(!not_empty.empty()); 35 | assert(initially_empty == not_empty); 36 | } 37 | 38 | { 39 | // test assign non-empty to non-empty 40 | 41 | vector non_empty(100, 7); 42 | vector other_not_empty(10, 13); 43 | 44 | non_empty = other_not_empty; 45 | 46 | assert(!non_empty.empty()); 47 | assert(!other_not_empty.empty()); 48 | assert(non_empty == other_not_empty); 49 | } 50 | } 51 | 52 | int main() 53 | { 54 | test_assign_operator(); 55 | 56 | return 0; 57 | } 58 | 59 | -------------------------------------------------------------------------------- /testing/experimental/ranges/size.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #include 9 | 10 | struct has_free_function_size {}; 11 | 12 | constexpr size_t size(has_free_function_size) 13 | { 14 | return 0; 15 | } 16 | 17 | void test() 18 | { 19 | { 20 | // test std::vector 21 | std::vector vec(10); 22 | 23 | assert(agency::experimental::size(vec) == vec.size()); 24 | } 25 | 26 | { 27 | // test std::array 28 | std::array arr; 29 | 30 | assert(agency::experimental::size(arr) == arr.size()); 31 | } 32 | 33 | { 34 | // test std::list 35 | std::list lst(10); 36 | 37 | assert(agency::experimental::size(lst) == lst.size()); 38 | } 39 | 40 | { 41 | // test agency::vector 42 | agency::vector vec(10); 43 | 44 | assert(agency::experimental::size(vec) == vec.size()); 45 | } 46 | 47 | { 48 | // test has_free_function_size 49 | has_free_function_size x; 50 | 51 | assert(agency::experimental::size(x) == size(x)); 52 | } 53 | } 54 | 55 | int main() 56 | { 57 | test(); 58 | 59 | std::cout << "OK" << std::endl; 60 | 61 | return 0; 62 | } 63 | 64 | -------------------------------------------------------------------------------- /testing/container/vector/clear.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | void test_clear() 8 | { 9 | using namespace agency; 10 | 11 | { 12 | // test clear empty vector 13 | 14 | vector v; 15 | 16 | v.clear(); 17 | 18 | assert(v.empty()); 19 | } 20 | 21 | { 22 | // test clear vector 23 | 24 | size_t num_elements = 10; 25 | 26 | vector v(num_elements, 13); 27 | 28 | v.clear(); 29 | 30 | assert(v.empty()); 31 | } 32 | } 33 | 34 | template 35 | void test_clear(ExecutionPolicy policy) 36 | { 37 | using namespace agency; 38 | 39 | { 40 | // test clear empty vector 41 | 42 | vector v; 43 | 44 | v.clear(policy); 45 | 46 | assert(v.empty()); 47 | } 48 | 49 | { 50 | // test clear vector 51 | 52 | size_t num_elements = 10; 53 | 54 | vector v(num_elements, 13); 55 | 56 | v.clear(policy); 57 | 58 | assert(v.empty()); 59 | } 60 | } 61 | 62 | int main() 63 | { 64 | test_clear(); 65 | test_clear(agency::seq); 66 | test_clear(agency::par); 67 | 68 | std::cout << "OK" << std::endl; 69 | 70 | return 0; 71 | } 72 | 73 | -------------------------------------------------------------------------------- /agency/cuda/detail/concurrency/block_barrier.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | 7 | namespace agency 8 | { 9 | namespace cuda 10 | { 11 | namespace detail 12 | { 13 | 14 | 15 | class block_barrier 16 | { 17 | public: 18 | __AGENCY_ANNOTATION 19 | block_barrier(int count) 20 | #ifndef __CUDA_ARCH__ 21 | : count_(count) 22 | #endif 23 | {} 24 | 25 | __AGENCY_ANNOTATION 26 | block_barrier(block_barrier&&) = delete; 27 | 28 | __AGENCY_ANNOTATION 29 | int count() const 30 | { 31 | #ifndef __CUDA_ARCH__ 32 | return count_; 33 | #else 34 | return blockDim.x * blockDim.y * blockDim.z; 35 | #endif 36 | } 37 | 38 | __AGENCY_ANNOTATION 39 | void arrive_and_wait() 40 | { 41 | #ifdef __CUDA_ARCH__ 42 | // since we sometimes need to call .arrive_and_wait() from textually-unaligned code locations, 43 | // use this barrier intrinsic instead of __syncthreads(). 44 | // unlike __syncthreads(), __barrier_sync(0) does not assume textual alignment. 45 | __barrier_sync(0); 46 | #else 47 | assert(0); 48 | #endif 49 | } 50 | 51 | private: 52 | #ifndef __CUDA_ARCH__ 53 | int count_; 54 | #endif 55 | }; 56 | 57 | 58 | } // end detail 59 | } // end cuda 60 | } // end agency 61 | 62 | -------------------------------------------------------------------------------- /testing/execution/executor/executor_traits/cuda/executor_shape.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include "../../test_executors.hpp" 7 | 8 | int main() 9 | { 10 | static_assert(!agency::detail::is_detected::value, "executor_shape_t should not be detected"); 11 | 12 | static_assert(agency::detail::is_detected_exact::value, "bulk_executor_without_shape_type should have size_t shape_type"); 13 | 14 | static_assert(agency::detail::is_detected_exact::value, "bulk_executor_with_shape_type should have bulk_executor_with_shape_type::shape_type shape_type"); 15 | 16 | static_assert(agency::detail::is_detected_exact::value, "bulk_then_executor should have size_t shape_type"); 17 | 18 | static_assert(agency::detail::is_detected_exact::value, "grid_executor should have uint2 shape_type"); 19 | 20 | std::cout << "OK" << std::endl; 21 | 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /agency/detail/algorithm/copy/uninitialized_copy_n.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace detail 11 | { 12 | 13 | 14 | template::type>::value)> 16 | __AGENCY_ANNOTATION 17 | Iterator2 uninitialized_copy_n(ExecutionPolicy&& policy, Allocator& alloc, Iterator1 first, Size n, Iterator2 result) 18 | { 19 | return detail::construct_n(std::forward(policy), alloc, result, n, first); 20 | } 21 | 22 | 23 | template 24 | __AGENCY_ANNOTATION 25 | Iterator2 uninitialized_copy_n(Allocator& alloc, Iterator1 first, Size n, Iterator2 result) 26 | { 27 | // pass this instead of agency::seq to work around the prohibition on 28 | // taking the address of a global constexpr object (i.e., agency::seq) from a CUDA __device__ function 29 | sequenced_execution_policy seq; 30 | return detail::uninitialized_copy_n(seq, alloc, first, n, result); 31 | } 32 | 33 | 34 | } // end detail 35 | } // end agency 36 | 37 | -------------------------------------------------------------------------------- /agency/version.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2008-2017 NVIDIA Corporation 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | #pragma once 18 | 19 | // This is the only Agency header that is guaranteed to 20 | // change with every Agency release. 21 | // 22 | // AGENCY_VERSION % 100 is the sub-minor version 23 | // AGENCY_VERSION / 100 % 1000 is the minor version 24 | // AGENCY_VERSION / 100000 is the major version 25 | 26 | // XXX there are no leading zeros on AGENCY_VERSION because that is interpreted as an octal value 27 | #define AGENCY_VERSION 300 28 | 29 | #define AGENCY_MAJOR_VERSION (AGENCY_VERSION / 100000) 30 | 31 | #define AGENCY_MINOR_VERSION (AGENCY_VERSION / 100 % 1000) 32 | 33 | #define AGENCY_SUBMINOR_VERSION (AGENCY_VERSION % 100) 34 | 35 | -------------------------------------------------------------------------------- /examples/hello_then.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() 6 | { 7 | using namespace agency; 8 | 9 | std::cout << "Starting predecessor and continuation tasks asynchronously..." << std::endl; 10 | 11 | std::mutex mut; 12 | 13 | // asynchronously create 5 agents to greet us in a predecessor task 14 | std::future predecessor = bulk_async(par(5), [&](parallel_agent& self) 15 | { 16 | mut.lock(); 17 | std::cout << "Hello, world from agent " << self.index() << " in the predecessor task" << std::endl; 18 | mut.unlock(); 19 | }); 20 | 21 | // create a continuation to the predecessor 22 | std::future continuation = bulk_then(par(5), [&](parallel_agent& self) 23 | { 24 | mut.lock(); 25 | std::cout << "Hello, world from agent " << self.index() << " in the continuation" << std::endl; 26 | mut.unlock(); 27 | }, 28 | predecessor); 29 | 30 | std::cout << "Sleeping before waiting on the continuation..." << std::endl; 31 | std::this_thread::sleep_for(std::chrono::seconds(1)); 32 | std::cout << "Woke up, waiting for the continuation to complete..." << std::endl; 33 | 34 | // wait for the continuation to complete before continuing 35 | continuation.wait(); 36 | 37 | std::cout << "OK" << std::endl; 38 | return 0; 39 | } 40 | 41 | -------------------------------------------------------------------------------- /agency/coordinate/detail/shape/shape_element.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | // shape_element is a type trait which returns the 14 | // type of the ith element of the given Shape. 15 | // 16 | // A Shape is either: 17 | // 1. An integral type or 18 | // 2. A tuple of Shapes 19 | // 20 | // shape_element's implementation below needs to handle these two cases. 21 | 22 | 23 | // case 2: Shape is a Tuple-like type 24 | template 25 | struct shape_element_impl : std::tuple_element {}; 26 | 27 | 28 | // case 1: Shape is an integral type. 29 | // This case only makes sense when i is 0. 30 | template 31 | struct shape_element_impl< 32 | i, 33 | Shape, 34 | typename std::enable_if< 35 | std::is_integral::value && i == 0 36 | >::type 37 | > 38 | { 39 | using type = Shape; 40 | }; 41 | 42 | 43 | template 44 | struct shape_element 45 | { 46 | using type = typename shape_element_impl::type; 47 | }; 48 | 49 | template 50 | using shape_element_t = typename shape_element::type; 51 | 52 | 53 | } // end detail 54 | } // end agency 55 | 56 | -------------------------------------------------------------------------------- /agency/agency.hpp: -------------------------------------------------------------------------------- 1 | /// \file 2 | /// \brief Include this file to use any component of Agency which is not experimental, 3 | /// nor requires C++ language extensions. 4 | /// 5 | /// Including `` recursively includes most of Agency's header files. It is provided for quick and easy 6 | /// access to most of Agency's features. Features not included by this header are either experimental, 7 | /// or require C++ language extensions which may not be supported by all compilers (such as CUDA C++ language 8 | /// extensions). 9 | /// 10 | /// Individual header files provide finer-grained access to features. Using these individual header files may 11 | /// result in shorter compilation times. 12 | /// 13 | 14 | #pragma once 15 | 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include 29 | 30 | /// \namespace agency 31 | /// \brief `agency` is the top-level namespace which contains all Agency functionality. 32 | /// 33 | 34 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/utility/blocking_bulk_twoway_execute_with_void_result.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | 11 | namespace agency 12 | { 13 | namespace detail 14 | { 15 | 16 | 17 | __agency_exec_check_disable__ 18 | template::value), 20 | __AGENCY_REQUIRES(executor_execution_depth::value == sizeof...(Factories)) 21 | > 22 | __AGENCY_ANNOTATION 23 | void blocking_bulk_twoway_execute_with_void_result(const E& exec, Function f, executor_shape_t shape, Factories... factories) 24 | { 25 | // wrap f in a functor that will ignore the unit object we pass to it 26 | ignore_unit_result_parameter_and_invoke g{f}; 27 | 28 | // just call blocking_bulk_twoway_execute() and use a result factory that creates a unit object which can be easily discarded 29 | detail::blocking_bulk_twoway_execute(exec, g, shape, unit_factory(), factories...); 30 | } 31 | 32 | 33 | } // end detail 34 | } // end agency 35 | 36 | -------------------------------------------------------------------------------- /agency/detail/control_structures/is_bulk_call_possible_via_execution_policy.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace detail 11 | { 12 | 13 | 14 | template 15 | struct is_bulk_call_possible_via_execution_policy_impl 16 | { 17 | template::value 20 | >::type, 21 | class = typename enable_if_call_possible< 22 | void, Function1, execution_policy_agent_t&, decay_parameter_t... 23 | >::type 24 | > 25 | static std::true_type test(int); 26 | 27 | template 28 | static std::false_type test(...); 29 | 30 | using type = decltype(test(0)); 31 | }; 32 | 33 | template 34 | using is_bulk_call_possible_via_execution_policy = typename is_bulk_call_possible_via_execution_policy_impl::type; 35 | 36 | 37 | } // end detail 38 | } // end agency 39 | 40 | -------------------------------------------------------------------------------- /agency/future/future_traits/is_future.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace detail 11 | { 12 | 13 | 14 | template 15 | struct has_wait_impl 16 | { 17 | template().wait() 20 | )> 21 | static std::true_type test(int); 22 | 23 | template 24 | static std::false_type test(...); 25 | 26 | using type = decltype(test(0)); 27 | }; 28 | 29 | 30 | template 31 | using has_wait = typename has_wait_impl::type; 32 | 33 | 34 | template 35 | struct has_get_impl 36 | { 37 | template().get()) 39 | > 40 | static std::true_type test(int); 41 | 42 | template 43 | static std::false_type test(...); 44 | 45 | using type = decltype(test(0)); 46 | }; 47 | 48 | 49 | template 50 | using has_get = typename has_get_impl::type; 51 | 52 | 53 | } // end detail 54 | 55 | 56 | // XXX should probably also check for make_ready() and possibly then() 57 | template 58 | struct is_future : detail::conjunction, detail::has_get> {}; 59 | 60 | 61 | } // end agency 62 | 63 | -------------------------------------------------------------------------------- /agency/execution/executor/vector_executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | namespace agency 9 | { 10 | namespace this_thread 11 | { 12 | 13 | 14 | class vector_executor 15 | { 16 | public: 17 | template 18 | using future = always_ready_future; 19 | 20 | template 21 | future> 22 | bulk_twoway_execute(Function f, size_t n, ResultFactory result_factory, SharedFactory shared_factory) const 23 | { 24 | auto result = result_factory(); 25 | auto shared_parm = shared_factory(); 26 | 27 | // ivdep requires gcc 4.9+ 28 | #if !defined(__INTEL_COMPILER) && !defined(__NVCC__) && (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 9) 29 | #pragma GCC ivdep 30 | #elif defined(__INTEL_COMPILER) 31 | #pragma simd 32 | #endif 33 | for(size_t i = 0; i < n; ++i) 34 | { 35 | f(i, result, shared_parm); 36 | } 37 | 38 | return agency::make_always_ready_future(std::move(result)); 39 | } 40 | }; 41 | 42 | 43 | } // end this_thread 44 | 45 | 46 | // XXX consider a flattened nesting similar to parallel_executor 47 | using vector_executor = this_thread::vector_executor; 48 | 49 | 50 | } // end agency 51 | 52 | -------------------------------------------------------------------------------- /agency/cuda/execution/executor/concurrent_grid_executor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | 9 | namespace agency 10 | { 11 | namespace cuda 12 | { 13 | 14 | 15 | class concurrent_grid_executor : public detail::basic_grid_executor 16 | { 17 | private: 18 | using super_t = detail::basic_grid_executor; 19 | 20 | public: 21 | using super_t::super_t; 22 | 23 | __host__ __device__ 24 | shape_type unit_shape() const 25 | { 26 | return shape_type{detail::number_of_multiprocessors(device()), 256}; 27 | } 28 | 29 | using super_t::max_shape_dimensions; 30 | 31 | // XXX does any part of Agency actually use this function? maybe we should just get rid of it 32 | // in favor of something that works more like the overload below 33 | __host__ __device__ 34 | shape_type max_shape_dimensions() const 35 | { 36 | // XXX it's not clear that this is correct 37 | return shape_type{detail::maximum_grid_size_x(device()), detail::maximum_block_size_x(device())}; 38 | } 39 | }; 40 | 41 | 42 | } // end cuda 43 | } // end agency 44 | 45 | -------------------------------------------------------------------------------- /testing/execution/executor/cuda/grid_executor.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int main() 12 | { 13 | using namespace agency; 14 | 15 | // XXX fill out this function with appropriate unit tests 16 | 17 | static_assert(is_executor::value, 18 | "grid_executor should be an executor"); 19 | 20 | static_assert(detail::is_detected_exact, executor_future_t, cuda::grid_executor, int>::value, 21 | "grid_executor should have cuda::async_future future type"); 22 | 23 | static_assert(detail::is_detected_exact, executor_allocator_t, cuda::grid_executor, int>::value, 24 | "grid_executor should have cuda::allocator type"); 25 | 26 | static_assert(detail::is_detected_exact, detail::member_barrier_type_or_t, cuda::grid_executor, void>::value, 27 | "grid_executor::barrier_type should be scoped_in_place_type_t 2 | 3 | 4 | namespace agency 5 | { 6 | namespace cuda 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template 13 | class heterogeneous_barrier 14 | { 15 | public: 16 | using host_barrier_type = HostBarrier; 17 | using device_barrier_type = DeviceBarrier; 18 | 19 | __agency_exec_check_disable__ 20 | __AGENCY_ANNOTATION 21 | heterogeneous_barrier(size_t num_threads) : 22 | #ifndef __CUDA_ARCH__ 23 | host_barrier_(num_threads) 24 | #else 25 | device_barrier_(num_threads) 26 | #endif 27 | {} 28 | 29 | __agency_exec_check_disable__ 30 | __AGENCY_ANNOTATION 31 | std::size_t count() const 32 | { 33 | #ifndef __CUDA_ARCH__ 34 | return host_barrier_.count(); 35 | #else 36 | return device_barrier_.count(); 37 | #endif 38 | } 39 | 40 | __agency_exec_check_disable__ 41 | __AGENCY_ANNOTATION 42 | void arrive_and_wait() 43 | { 44 | #ifndef __CUDA_ARCH__ 45 | host_barrier_.arrive_and_wait(); 46 | #else 47 | device_barrier_.arrive_and_wait(); 48 | #endif 49 | } 50 | 51 | private: 52 | #ifndef __CUDA_ARCH__ 53 | host_barrier_type host_barrier_; 54 | #else 55 | device_barrier_type device_barrier_; 56 | #endif 57 | }; 58 | 59 | 60 | } // end detail 61 | } // end cuda 62 | } // end agency 63 | 64 | -------------------------------------------------------------------------------- /testing/unorganized/cuda/cuda_grid.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | struct kernel 7 | { 8 | __device__ 9 | void operator()(agency::parallel_group& self) 10 | { 11 | printf("hello from {%d, %d}\n", (int)self.outer().index(), (int)self.inner().index()); 12 | } 13 | 14 | __device__ 15 | void operator()(agency::parallel_group_2d& self) 16 | { 17 | auto outer_idx = self.outer().index(); 18 | auto inner_idx = self.inner().index(); 19 | 20 | printf("hello from {{%d, %d}, {%d, %d}}\n", (int)outer_idx[0], (int)outer_idx[1], (int)inner_idx[0], (int)inner_idx[1]); 21 | } 22 | }; 23 | 24 | 25 | auto grid(size_t num_blocks, size_t num_threads) 26 | -> decltype( 27 | agency::cuda::par(num_blocks, agency::cuda::con(num_threads)) 28 | ) 29 | { 30 | return agency::cuda::par(num_blocks, agency::cuda::con(num_threads)); 31 | } 32 | 33 | 34 | auto grid(agency::size2 num_blocks, agency::size2 num_threads) 35 | -> decltype( 36 | agency::cuda::par2d(num_blocks, agency::cuda::con2d(num_threads)) 37 | ) 38 | { 39 | return agency::cuda::par2d(num_blocks, agency::cuda::con2d(num_threads)); 40 | } 41 | 42 | 43 | int main() 44 | { 45 | agency::bulk_invoke(grid(2,32), kernel()); 46 | 47 | agency::bulk_invoke(grid({1,2}, {1,32}), kernel()); 48 | 49 | return 0; 50 | } 51 | 52 | -------------------------------------------------------------------------------- /agency/experimental/ranges/tile.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace experimental 9 | { 10 | 11 | 12 | 13 | // tile() is a synonym for chunk() 14 | // introduce this while we bikeshed the names 15 | template 16 | __AGENCY_ANNOTATION 17 | auto tile(Range&& rng, Difference tile_size) -> 18 | decltype( 19 | agency::experimental::chunk(std::forward(rng), tile_size) 20 | ) 21 | { 22 | return agency::experimental::chunk(std::forward(rng), tile_size); 23 | } 24 | 25 | 26 | // tile_evenly() is a synonym for chunk_evenly() 27 | // introduce this while we bikeshed the names 28 | template 29 | __AGENCY_ANNOTATION 30 | auto tile_evenly(Range&& rng, Difference desired_number_of_tiles) -> 31 | decltype( 32 | agency::experimental::tile(std::forward(rng), std::declval()) 33 | ) 34 | { 35 | // note that this calculation will not necessarily result in the desired number of tiles 36 | // in general, there is no way to partition a range into exactly N-1 equally-sized tiles plus a single odd-sized tile 37 | Difference tile_size = (rng.size() + desired_number_of_tiles - 1) / desired_number_of_tiles; 38 | return agency::experimental::tile(std::forward(rng), tile_size); 39 | } 40 | 41 | 42 | } // end experimental 43 | } // end agency 44 | 45 | -------------------------------------------------------------------------------- /agency/memory/allocator/detail/allocator_traits/destroy.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | namespace agency 10 | { 11 | namespace detail 12 | { 13 | namespace allocator_traits_detail 14 | { 15 | 16 | 17 | __agency_exec_check_disable__ 18 | template::value) 20 | > 21 | __AGENCY_ANNOTATION 22 | void destroy(Alloc& a, Pointer p) 23 | { 24 | a.destroy(p); 25 | } // end destroy() 26 | 27 | 28 | __agency_exec_check_disable__ 29 | template::value) 31 | > 32 | __AGENCY_ANNOTATION 33 | void destroy(Alloc&, Pointer p) 34 | { 35 | using element_type = typename std::pointer_traits::element_type; 36 | 37 | p->~element_type(); 38 | } // end destroy() 39 | 40 | 41 | } // end allocator_traits_detail 42 | 43 | 44 | template 45 | template 46 | __AGENCY_ANNOTATION 47 | void allocator_traits 48 | ::destroy(Alloc& alloc, Pointer p) 49 | { 50 | allocator_traits_detail::destroy(alloc, p); 51 | } // end allocator_traits::destroy() 52 | 53 | 54 | } // end detail 55 | } // end agency 56 | 57 | -------------------------------------------------------------------------------- /agency/memory/allocator/detail/allocator_traits.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | template 14 | struct allocator_traits : std::allocator_traits 15 | { 16 | using pointer = typename std::allocator_traits::pointer; 17 | using size_type = typename std::allocator_traits::size_type; 18 | 19 | __agency_exec_check_disable__ 20 | __AGENCY_ANNOTATION 21 | static pointer allocate(Alloc& a, size_type n) 22 | { 23 | return a.allocate(n); 24 | } 25 | 26 | __agency_exec_check_disable__ 27 | __AGENCY_ANNOTATION 28 | static void deallocate(Alloc& a, pointer p, size_type n) 29 | { 30 | a.deallocate(p, n); 31 | } 32 | 33 | template 34 | __AGENCY_ANNOTATION 35 | static void construct(Alloc& alloc, Pointer p, Args&&... args); 36 | 37 | template 38 | __AGENCY_ANNOTATION 39 | static void destroy(Alloc& a, Pointer p); 40 | 41 | __AGENCY_ANNOTATION 42 | static size_type max_size(const Alloc& a); 43 | }; // end allocator_traits 44 | 45 | 46 | } // end detail 47 | } // end agency 48 | 49 | #include 50 | #include 51 | #include 52 | 53 | -------------------------------------------------------------------------------- /testing/execution/executor/cuda/concurrent_grid_executor.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int main() 11 | { 12 | using namespace agency; 13 | 14 | // XXX fill out this function with appropriate unit tests 15 | 16 | static_assert(is_executor::value, 17 | "concurrent_grid_executor should be an executor"); 18 | 19 | static_assert(detail::is_detected_exact, executor_future_t, cuda::concurrent_grid_executor, int>::value, 20 | "concurrent_grid_executor should have cuda::async_future future type"); 21 | 22 | static_assert(detail::is_detected_exact, executor_allocator_t, cuda::concurrent_grid_executor, int>::value, 23 | "concurrent_grid_executor should have cuda::allocator type"); 24 | 25 | static_assert(detail::is_detected_exact, detail::member_barrier_type_or_t, cuda::concurrent_grid_executor, void>::value, 26 | "concurrent_grid_executor::barrier_type should be scoped_in_place_type_t 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #include "../test_executors.hpp" 12 | 13 | 14 | template 15 | void test(Executor exec) 16 | { 17 | using shape_type = agency::executor_shape_t; 18 | using index_type = agency::executor_index_t; 19 | 20 | shape_type shape = 10; 21 | 22 | auto result = agency::detail::blocking_bulk_twoway_execute(exec, 23 | [](index_type idx, std::vector& results, std::vector& shared_arg) 24 | { 25 | results[idx] = 7 + shared_arg[idx]; 26 | }, 27 | shape, 28 | [=]{ return std::vector(shape); }, // results 29 | [=]{ return std::vector(shape, 13); } // shared_arg 30 | ); 31 | 32 | assert(std::vector(10, 7 + 13) == result); 33 | } 34 | 35 | 36 | int main() 37 | { 38 | test(bulk_twoway_executor()); 39 | test(bulk_then_executor()); 40 | 41 | test(not_a_bulk_twoway_executor()); 42 | test(not_a_bulk_then_executor()); 43 | 44 | test(complete_bulk_executor()); 45 | 46 | std::cout << "OK" << std::endl; 47 | 48 | return 0; 49 | } 50 | 51 | 52 | -------------------------------------------------------------------------------- /testing/execution/execution_policy/cuda/on.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | template 6 | void test(const ExecutionPolicy& policy, const Executor& ex) 7 | { 8 | auto p1 = policy.on(ex); 9 | assert(p1.executor() == ex); 10 | } 11 | 12 | 13 | int main() 14 | { 15 | { 16 | // test seq 17 | test(agency::seq, agency::sequenced_executor()); 18 | } 19 | 20 | { 21 | // test par 22 | test(agency::par, agency::sequenced_executor()); 23 | test(agency::par, agency::parallel_executor()); 24 | test(agency::par, agency::concurrent_executor()); 25 | } 26 | 27 | { 28 | // test con 29 | test(agency::con, agency::concurrent_executor()); 30 | } 31 | 32 | 33 | { 34 | // test CUDA-specific policies and executors 35 | using namespace agency; 36 | 37 | { 38 | // test par 39 | test(cuda::par, cuda::parallel_executor()); 40 | 41 | test(par, cuda::grid_executor()); 42 | test(cuda::grid(1,1), cuda::grid_executor()); 43 | } 44 | 45 | { 46 | // test par2d(con2d) 47 | test(cuda::par2d(size2(1,1), cuda::con2d(size2(1,1))), cuda::grid_executor_2d()); 48 | } 49 | 50 | { 51 | // test grid 52 | auto g = agency::cuda::grid(1,1); 53 | 54 | test(g, agency::cuda::grid_executor()); 55 | } 56 | } 57 | 58 | std::cout << "OK" << std::endl; 59 | } 60 | 61 | -------------------------------------------------------------------------------- /testing/execution/executor/execution_functions/bulk_twoway_execute.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #include "../test_executors.hpp" 12 | 13 | 14 | template 15 | void test(Executor exec) 16 | { 17 | using shape_type = agency::executor_shape_t; 18 | using index_type = agency::executor_index_t; 19 | 20 | shape_type shape = 10; 21 | 22 | auto f = agency::detail::bulk_twoway_execute(exec, 23 | [](index_type idx, std::vector& results, std::vector& shared_arg) 24 | { 25 | results[idx] = 7 + shared_arg[idx]; 26 | }, 27 | shape, 28 | [=]{ return std::vector(shape); }, // results 29 | [=]{ return std::vector(shape, 13); } // shared_arg 30 | ); 31 | 32 | auto result = f.get(); 33 | 34 | assert(std::vector(10, 7 + 13) == result); 35 | } 36 | 37 | 38 | int main() 39 | { 40 | test(bulk_twoway_executor()); 41 | test(bulk_then_executor()); 42 | 43 | test(not_a_bulk_twoway_executor()); 44 | test(not_a_bulk_then_executor()); 45 | 46 | test(complete_bulk_executor()); 47 | 48 | std::cout << "OK" << std::endl; 49 | 50 | return 0; 51 | } 52 | 53 | -------------------------------------------------------------------------------- /agency/cuda/memory/allocator/heterogeneous_allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | namespace agency 12 | { 13 | namespace cuda 14 | { 15 | 16 | 17 | // heterogeneous_allocator uses a different primitive resource depending on whether 18 | // its operations are called from __host__ or __device__ code. 19 | template 20 | class heterogeneous_allocator : public agency::detail::allocator_adaptor> 21 | { 22 | private: 23 | using super_t = agency::detail::allocator_adaptor>; 24 | 25 | public: 26 | heterogeneous_allocator() = default; 27 | 28 | heterogeneous_allocator(const heterogeneous_allocator&) = default; 29 | 30 | template 31 | __host__ __device__ 32 | heterogeneous_allocator(const heterogeneous_allocator& other) 33 | : super_t(other) 34 | {} 35 | }; // end heterogeneous_allocator 36 | 37 | 38 | } // end cuda 39 | } // end agency 40 | 41 | -------------------------------------------------------------------------------- /agency/detail/algorithm/move/uninitialized_move_n.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | namespace agency 11 | { 12 | namespace detail 13 | { 14 | 15 | 16 | template::type>::value 19 | )> 20 | __AGENCY_ANNOTATION 21 | Iterator2 uninitialized_move_n(ExecutionPolicy&& policy, Allocator& alloc, Iterator1 first, Size n, Iterator2 result) 22 | { 23 | return detail::uninitialized_copy_n(std::forward(policy), alloc, detail::make_move_iterator(first), n, result); 24 | } 25 | 26 | 27 | template 28 | __AGENCY_ANNOTATION 29 | Iterator2 uninitialized_move_n(Allocator& alloc, Iterator1 first, Size n, Iterator2 result) 30 | { 31 | // pass this instead of agency::seq to work around the prohibition on 32 | // taking the address of a global constexpr object (i.e., agency::seq) from a CUDA __device__ function 33 | sequenced_execution_policy seq; 34 | return detail::uninitialized_move_n(seq, alloc, first, n, result); 35 | } 36 | 37 | 38 | } // end detail 39 | } // end agency 40 | 41 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/utility/blocking_bulk_twoway_execute_with_collected_result.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | 13 | namespace agency 14 | { 15 | namespace detail 16 | { 17 | 18 | 19 | template::value), 21 | __AGENCY_REQUIRES(executor_execution_depth::value == sizeof...(SharedFactories)), 22 | __AGENCY_REQUIRES(!std::is_void, result_of_t&...)>>::value) 23 | > 24 | __AGENCY_ANNOTATION 25 | result_of_t 26 | blocking_bulk_twoway_execute_with_collected_result(const E& exec, Function f, executor_shape_t shape, ResultFactory result_factory, SharedFactories... shared_factories) 27 | { 28 | // wrap f in a functor that will collect f's result and call blocking_bulk_twoway_execute() 29 | return detail::blocking_bulk_twoway_execute(exec, invoke_and_collect_result{f}, shape, result_factory, shared_factories...); 30 | } 31 | 32 | 33 | } // end detail 34 | } // end agency 35 | 36 | -------------------------------------------------------------------------------- /testing/container/vector/move_constructor.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | void test_move_constructor() 8 | { 9 | using namespace agency; 10 | 11 | { 12 | // test move construct empty vector 13 | vector other; 14 | 15 | vector v = std::move(other); 16 | 17 | assert(other.begin() == other.end()); 18 | assert(other.cbegin() == other.cend()); 19 | assert(other.size() == 0); 20 | assert(other.empty()); 21 | 22 | assert(v.begin() == v.end()); 23 | assert(v.cbegin() == v.cend()); 24 | assert(v.size() == 0); 25 | assert(v.empty()); 26 | } 27 | 28 | { 29 | // test move construct non-empty vector 30 | 31 | size_t num_elements = 10; 32 | 33 | vector other(num_elements, 13); 34 | 35 | vector v = std::move(other); 36 | 37 | assert(other.begin() == other.end()); 38 | assert(other.cbegin() == other.cend()); 39 | assert(other.size() == 0); 40 | assert(other.empty()); 41 | 42 | ptrdiff_t expected_difference = num_elements; 43 | 44 | assert(v.end() - v.begin() == expected_difference); 45 | assert(v.cend() - v.cbegin() == expected_difference); 46 | assert(v.size() == num_elements); 47 | assert(!v.empty()); 48 | assert(std::count(v.begin(), v.end(), 13) == 10); 49 | } 50 | } 51 | 52 | int main() 53 | { 54 | test_move_constructor(); 55 | 56 | std::cout << "OK" << std::endl; 57 | 58 | return 0; 59 | } 60 | 61 | -------------------------------------------------------------------------------- /agency/cuda/execution/execution_policy/concurrent_grid_execution_policy.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | namespace agency 10 | { 11 | namespace cuda 12 | { 13 | 14 | 15 | // XXX consider making this a global object like the other execution policies 16 | inline auto con_grid(size_t num_blocks, size_t num_threads) -> 17 | decltype( 18 | con(num_blocks, con(num_threads)) 19 | ) 20 | { 21 | return con(num_blocks, con(num_threads)); 22 | }; 23 | 24 | 25 | // XXX consider making this a unique type instead of an alias 26 | using con_grid_agent = concurrent_group; 27 | 28 | 29 | // this overload is called on e.g. con(con).on(device(0)) 30 | // XXX this function needs to account for the dimensionality of ParallelPolicy's agents 31 | template::value 34 | )> 35 | __AGENCY_ANNOTATION 36 | basic_execution_policy 37 | replace_executor(const ConcurrentGridPolicy& policy, device_id device) 38 | { 39 | cuda::concurrent_grid_executor exec(device); 40 | 41 | return policy.on(exec); 42 | } 43 | 44 | 45 | } // end cuda 46 | } // end agency 47 | 48 | -------------------------------------------------------------------------------- /agency/execution/execution_agent/experimental/detail/basic_static_execution_agent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | namespace agency 9 | { 10 | namespace experimental 11 | { 12 | namespace detail 13 | { 14 | 15 | 16 | template 17 | class basic_static_execution_agent : public BaseAgent 18 | { 19 | private: 20 | using base_agent_type = BaseAgent; 21 | using base_traits = agency::execution_agent_traits; 22 | using base_param_type = typename base_traits::param_type; 23 | 24 | public: 25 | using base_agent_type::base_agent_type; 26 | 27 | static constexpr std::size_t static_group_size = static_group_size_; 28 | static constexpr std::size_t static_grain_size = static_grain_size_; 29 | 30 | __AGENCY_ANNOTATION 31 | constexpr std::size_t group_size() const 32 | { 33 | return static_group_size; 34 | } 35 | 36 | __AGENCY_ANNOTATION 37 | constexpr std::size_t grain_size() const 38 | { 39 | return static_grain_size; 40 | } 41 | 42 | class param_type : public base_param_type 43 | { 44 | public: 45 | using base_param_type::base_param_type; 46 | 47 | __AGENCY_ANNOTATION 48 | param_type() : base_param_type(0, static_group_size_) {} 49 | }; 50 | }; 51 | 52 | 53 | } // end detail 54 | } // end experimental 55 | } // end agency 56 | 57 | -------------------------------------------------------------------------------- /testing/algorithm/cuda/async_copy_n.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | template 11 | void test(ExecutionPolicy policy) 12 | { 13 | Container source(policy, 10, 7); 14 | Container dest(policy, source.size(), 13); 15 | 16 | agency::cuda::async_copy_n(policy, source.begin(), source.size(), dest.begin()).wait(); 17 | 18 | assert(Container(10, 7) == dest); 19 | } 20 | 21 | struct non_trivial 22 | { 23 | __host__ __device__ 24 | non_trivial(int v) 25 | : value(v) 26 | {} 27 | 28 | __host__ __device__ 29 | non_trivial(const non_trivial& other) 30 | : value(other.value) 31 | {} 32 | 33 | __host__ __device__ 34 | bool operator==(const non_trivial& other) 35 | { 36 | return value == other.value; 37 | } 38 | 39 | int value; 40 | }; 41 | 42 | int main() 43 | { 44 | using namespace agency; 45 | 46 | test>>(seq); 47 | test>>(par); 48 | test>>(cuda::par); 49 | 50 | // XXX disable this while operator== used in test() above executes in the current thread 51 | //test>>(cuda::par); 52 | 53 | std::cout << "OK" << std::endl; 54 | } 55 | 56 | -------------------------------------------------------------------------------- /testing/execution/executor/execution_functions/then_execute.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | #include "../test_executors.hpp" 10 | 11 | 12 | template 13 | void test_with_non_void_predecessor(Executor exec) 14 | { 15 | auto predecessor_future = agency::make_ready_future(exec, 7); 16 | 17 | auto f = agency::detail::then_execute(exec, [](int& predecessor) 18 | { 19 | return predecessor + 13; 20 | }, 21 | predecessor_future); 22 | 23 | auto result = f.get(); 24 | 25 | assert(7 + 13 == result); 26 | } 27 | 28 | 29 | template 30 | void test_with_void_predecessor(Executor exec) 31 | { 32 | auto predecessor_future = agency::make_ready_future(exec); 33 | 34 | auto f = agency::detail::then_execute(exec, []{ return 13; }, predecessor_future); 35 | 36 | auto result = f.get(); 37 | 38 | assert(13 == result); 39 | } 40 | 41 | 42 | int main() 43 | { 44 | test_with_non_void_predecessor(then_executor()); 45 | test_with_non_void_predecessor(bulk_then_executor()); 46 | // XXX call test_with_non_void_predecessor() with all the other types of executors 47 | 48 | test_with_void_predecessor(then_executor()); 49 | test_with_void_predecessor(bulk_then_executor()); 50 | // XXX call test_with_void_predecessor() with all the other types of executors 51 | 52 | std::cout << "OK" << std::endl; 53 | 54 | return 0; 55 | } 56 | 57 | -------------------------------------------------------------------------------- /agency/detail/algorithm/copy/uninitialized_copy.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | namespace agency 11 | { 12 | namespace detail 13 | { 14 | 15 | 16 | template::type>::value 19 | )> 20 | __AGENCY_ANNOTATION 21 | OutputIterator uninitialized_copy(ExecutionPolicy&& policy, Allocator& alloc, ForwardIterator first, ForwardIterator last, OutputIterator result) 22 | { 23 | return agency::detail::uninitialized_copy_n(std::forward(policy), alloc, first, agency::detail::distance(first,last), result); 24 | } 25 | 26 | 27 | template 28 | __AGENCY_ANNOTATION 29 | OutputIterator uninitialized_copy(Allocator& alloc, ForwardIterator first, ForwardIterator last, OutputIterator result) 30 | { 31 | // pass this instead of agency::seq to work around the prohibition on 32 | // taking the address of a global constexpr object (i.e., agency::seq) from a CUDA __device__ function 33 | agency::sequenced_execution_policy seq; 34 | return agency::detail::uninitialized_copy(seq, alloc, first, last, result); 35 | } 36 | 37 | 38 | } // end detail 39 | } // end agency 40 | 41 | -------------------------------------------------------------------------------- /agency/cuda/detail/terminate.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | namespace agency 11 | { 12 | namespace cuda 13 | { 14 | namespace detail 15 | { 16 | 17 | 18 | __host__ __device__ 19 | inline void print_error_message(cudaError_t e, const char* message) 20 | { 21 | #if (__cuda_lib_has_printf && __cuda_lib_has_cudart) 22 | printf("Error after %s: %s\n", message, cudaGetErrorString(e)); 23 | #elif __cuda_lib_has_printf 24 | printf("Error: %s\n", message); 25 | #endif 26 | } 27 | 28 | 29 | __host__ __device__ 30 | inline void print_error_message_if(cudaError_t e, const char* message) 31 | { 32 | if(e) 33 | { 34 | agency::cuda::detail::print_error_message(e, message); 35 | } 36 | } 37 | 38 | 39 | __host__ __device__ 40 | inline void terminate_on_error(cudaError_t e, const char* message) 41 | { 42 | if(e) 43 | { 44 | agency::cuda::detail::print_error_message(e, message); 45 | 46 | agency::detail::terminate(); 47 | } 48 | } 49 | 50 | 51 | inline __host__ __device__ 52 | void throw_on_error(cudaError_t e, const char* message) 53 | { 54 | if(e) 55 | { 56 | #ifndef __CUDA_ARCH__ 57 | throw thrust::system_error(e, thrust::cuda_category(), message); 58 | #else 59 | agency::cuda::detail::print_error_message(e, message); 60 | 61 | agency::detail::terminate(); 62 | #endif 63 | } 64 | } 65 | 66 | 67 | } // end detail 68 | } // cuda 69 | } // end agency 70 | 71 | -------------------------------------------------------------------------------- /agency/cuda/memory/resource/pinned_resource.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | 9 | namespace agency 10 | { 11 | namespace cuda 12 | { 13 | 14 | 15 | class pinned_resource 16 | { 17 | public: 18 | inline void* allocate(size_t num_bytes) 19 | { 20 | void* result = nullptr; 21 | 22 | cudaError_t error = cudaHostAlloc(&result, num_bytes, cudaHostAllocPortable); 23 | 24 | if(error != cudaSuccess) 25 | { 26 | throw thrust::system_error(error, thrust::cuda_category(), "pinned_resource::allocate(): cudaMallocManaged"); 27 | } 28 | 29 | return result; 30 | } 31 | 32 | inline void deallocate(void* ptr, size_t) 33 | { 34 | cudaError_t error = cudaFreeHost(ptr); 35 | 36 | if(error != cudaSuccess) 37 | { 38 | throw thrust::system_error(error, thrust::cuda_category(), "pinned_resource::deallocate(): cudaFree"); 39 | } 40 | } 41 | 42 | inline bool is_equal(const pinned_resource&) const 43 | { 44 | return true; 45 | } 46 | }; 47 | 48 | 49 | inline bool operator==(const pinned_resource& a, const pinned_resource& b) 50 | { 51 | return a.is_equal(b); 52 | } 53 | 54 | inline bool operator!=(const pinned_resource& a, const pinned_resource& b) 55 | { 56 | return !(a == b); 57 | } 58 | 59 | inline bool operator<(const pinned_resource&, const pinned_resource&) 60 | { 61 | return false; 62 | } 63 | 64 | 65 | } // end cuda 66 | } // end agency 67 | 68 | -------------------------------------------------------------------------------- /agency/detail/singleton.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | // this is a container for a value which takes an external flag 14 | // tracking whether or not the value has been destroyed 15 | // when the container is destroyed, the flag is set to indicate 16 | // the object's lifetime has ended 17 | template 18 | class intrusive_optional 19 | { 20 | public: 21 | intrusive_optional(bool& has_value) : has_value_(has_value) 22 | { 23 | has_value_ = true; 24 | } 25 | 26 | ~intrusive_optional() 27 | { 28 | has_value_ = false; 29 | } 30 | 31 | T& value() 32 | { 33 | return value_; 34 | } 35 | 36 | private: 37 | T value_; 38 | bool& has_value_; 39 | }; 40 | 41 | 42 | template 43 | __AGENCY_ANNOTATION 44 | inline T* singleton() 45 | { 46 | #ifndef __CUDA_ARCH__ 47 | // singleton() may be called after static destructors have completed 48 | // so the object by resource may no longer exist. track its lifetime with intrusive_optional 49 | // this is also why we return a pointer instead of a reference 50 | static bool has_value = false; 51 | static intrusive_optional resource(has_value); 52 | 53 | return has_value ? &resource.value() : nullptr; 54 | #else 55 | agency::cuda::detail::terminate_with_message("singleton(): This function is undefined in __device__ code."); 56 | return nullptr; 57 | #endif 58 | } 59 | 60 | 61 | } // end detail 62 | } // end agency 63 | 64 | -------------------------------------------------------------------------------- /agency/cuda/experimental/multidevice_array.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | namespace agency 12 | { 13 | namespace cuda 14 | { 15 | namespace experimental 16 | { 17 | namespace detail 18 | { 19 | 20 | 21 | // this function returns a std::vector of managed_allocators, one 22 | // corresponding to each device in the system 23 | template 24 | std::vector> all_devices_managed_allocators() 25 | { 26 | auto devices = cuda::all_devices(); 27 | 28 | std::vector> result; 29 | 30 | for(auto d : devices) 31 | { 32 | result.emplace_back(d); 33 | } 34 | 35 | return result; 36 | } 37 | 38 | 39 | } // end detail 40 | 41 | 42 | template 43 | class multidevice_array : public agency::experimental::tiled_array 44 | { 45 | private: 46 | using super_t = agency::experimental::tiled_array; 47 | 48 | public: 49 | multidevice_array(size_t n, const T& val = T{}) 50 | : super_t(n, val, detail::all_devices_managed_allocators()) 51 | {} 52 | }; 53 | 54 | 55 | template 56 | auto all(multidevice_array& a) 57 | -> decltype(a.all()) 58 | { 59 | return a.all(); 60 | } 61 | 62 | 63 | } // end experimental 64 | } // end cuda 65 | } // end agency 66 | 67 | -------------------------------------------------------------------------------- /agency/detail/algorithm/move/uninitialized_move.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | namespace agency 11 | { 12 | namespace detail 13 | { 14 | 15 | 16 | template::type>::value 19 | )> 20 | __AGENCY_ANNOTATION 21 | OutputIterator uninitialized_move(ExecutionPolicy&& policy, Allocator& alloc, ForwardIterator first, ForwardIterator last, OutputIterator result) 22 | { 23 | return detail::uninitialized_copy(std::forward(policy), alloc, detail::make_move_iterator(first), detail::make_move_iterator(last), result); 24 | } 25 | 26 | 27 | template 28 | __AGENCY_ANNOTATION 29 | OutputIterator uninitialized_move(Allocator& alloc, ForwardIterator first, ForwardIterator last, OutputIterator result) 30 | { 31 | // pass this instead of agency::seq to work around the prohibition on 32 | // taking the address of a global constexpr object (i.e., agency::seq) from a CUDA __device__ function 33 | agency::sequenced_execution_policy seq; 34 | return agency::detail::uninitialized_move(seq, alloc, first, last, result); 35 | } 36 | 37 | 38 | } // end detail 39 | } // end agency 40 | 41 | -------------------------------------------------------------------------------- /agency/detail/make_tuple_if.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | namespace agency 11 | { 12 | namespace detail 13 | { 14 | 15 | 16 | template 17 | __AGENCY_ANNOTATION 18 | agency::tuple make_tuple_if_impl(std::true_type, const T& x) 19 | { 20 | return agency::make_tuple(x); 21 | } 22 | 23 | 24 | template 25 | __AGENCY_ANNOTATION 26 | T make_tuple_if_impl(std::false_type, const T& x) 27 | { 28 | return x; 29 | } 30 | 31 | 32 | template 33 | __AGENCY_ANNOTATION 34 | auto make_tuple_if(const T& x) 35 | -> decltype(agency::detail::make_tuple_if_impl(std::integral_constant(), x)) 36 | { 37 | return agency::detail::make_tuple_if_impl(std::integral_constant(), x); 38 | } 39 | 40 | 41 | 42 | template 43 | __AGENCY_ANNOTATION 44 | auto tie_if(std::false_type, T&& x) 45 | -> decltype(std::forward(x)) 46 | { 47 | return std::forward(x); 48 | } 49 | 50 | 51 | template 52 | __AGENCY_ANNOTATION 53 | auto tie_if(std::true_type, T&& x) 54 | -> decltype(agency::tie(std::forward(x))) 55 | { 56 | return agency::tie(std::forward(x)); 57 | } 58 | 59 | 60 | template 61 | __AGENCY_ANNOTATION 62 | auto tie_if(T&& x) 63 | -> decltype(tie_if(std::integral_constant(), std::forward(x))) 64 | { 65 | return tie_if(std::integral_constant(), std::forward(x)); 66 | } 67 | 68 | 69 | } // end detail 70 | } // end agency 71 | 72 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | # Copyright (c) 2014, NVIDIA CORPORATION. All rights reserved. 2 | # 3 | # Redistribution and use in source and binary forms, with or without 4 | # modification, are permitted provided that the following conditions 5 | # are met: 6 | # * Redistributions of source code must retain the above copyright 7 | # notice, this list of conditions and the following disclaimer. 8 | # * Redistributions in binary form must reproduce the above copyright 9 | # notice, this list of conditions and the following disclaimer in the 10 | # documentation and/or other materials provided with the distribution. 11 | # * Neither the name of NVIDIA CORPORATION nor the names of its 12 | # contributors may be used to endorse or promote products derived 13 | # from this software without specific prior written permission. 14 | # 15 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY 16 | # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 | # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 18 | # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 19 | # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 20 | # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 | # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 22 | # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 23 | # OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | -------------------------------------------------------------------------------- /testing/execution/executor/execution_functions/cuda/then_execute.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | #include "../../test_executors.hpp" 10 | 11 | 12 | template 13 | void test_with_non_void_predecessor(Executor exec) 14 | { 15 | auto predecessor_future = agency::make_ready_future(exec, 7); 16 | 17 | auto f = agency::detail::then_execute(exec, [] __host__ __device__ (int& predecessor) 18 | { 19 | return predecessor + 13; 20 | }, 21 | predecessor_future); 22 | 23 | auto result = f.get(); 24 | 25 | assert(7 + 13 == result); 26 | } 27 | 28 | 29 | template 30 | void test_with_void_predecessor(Executor exec) 31 | { 32 | auto predecessor_future = agency::make_ready_future(exec); 33 | 34 | auto f = agency::detail::then_execute(exec, [] __host__ __device__ 35 | { 36 | return 13; 37 | }, 38 | predecessor_future); 39 | 40 | auto result = f.get(); 41 | 42 | assert(13 == result); 43 | } 44 | 45 | 46 | int main() 47 | { 48 | test_with_non_void_predecessor(then_executor()); 49 | test_with_non_void_predecessor(bulk_then_executor()); 50 | 51 | test_with_non_void_predecessor(agency::cuda::grid_executor()); 52 | 53 | test_with_void_predecessor(then_executor()); 54 | test_with_void_predecessor(bulk_then_executor()); 55 | 56 | test_with_void_predecessor(agency::cuda::grid_executor()); 57 | 58 | std::cout << "OK" << std::endl; 59 | 60 | return 0; 61 | } 62 | 63 | -------------------------------------------------------------------------------- /agency/async.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | namespace agency 14 | { 15 | 16 | 17 | template 18 | __AGENCY_ANNOTATION 19 | executor_future_t< 20 | Executor, 21 | detail::result_of_t< 22 | typename std::decay::type(typename std::decay::type...) 23 | > 24 | > 25 | async(const Executor& exec, Function&& f, Args&&... args) 26 | { 27 | auto g = detail::bind(std::forward(f), std::forward(args)...); 28 | 29 | // grab a reference to avoid creating a copy of exec 30 | detail::executor_ref exec_ref{exec}; 31 | 32 | return agency::require(exec_ref, single, twoway).twoway_execute(std::move(g)); 33 | } 34 | 35 | 36 | template 37 | executor_future_t< 38 | agency::detail::thread_pool_executor, 39 | detail::result_of_t< 40 | typename std::decay::type(typename std::decay::type...) 41 | > 42 | > 43 | async(Function&& f, Args&&... args) 44 | { 45 | agency::detail::thread_pool_executor exec; 46 | return agency::async(exec, std::forward(f), std::forward(args)...); 47 | } 48 | 49 | 50 | } // end agency 51 | 52 | -------------------------------------------------------------------------------- /agency/memory/allocator/allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace agency 8 | { 9 | namespace detail 10 | { 11 | 12 | 13 | __AGENCY_ANNOTATION 14 | inline void throw_bad_alloc() 15 | { 16 | #ifdef __CUDA_ARCH__ 17 | printf("bad_alloc"); 18 | assert(0); 19 | #else 20 | throw std::bad_alloc(); 21 | #endif 22 | } 23 | 24 | 25 | } // end detail 26 | 27 | 28 | template 29 | struct allocator 30 | { 31 | using value_type = T; 32 | using propagate_on_container_move_assignment = std::true_type; 33 | using is_always_equal = std::true_type; 34 | 35 | allocator() = default; 36 | 37 | allocator(const allocator&) = default; 38 | 39 | template 40 | __AGENCY_ANNOTATION 41 | allocator(const allocator&){} 42 | 43 | __AGENCY_ANNOTATION 44 | ~allocator(){} 45 | 46 | __AGENCY_ANNOTATION 47 | T* allocate(std::size_t n) 48 | { 49 | T* result = static_cast(::operator new(sizeof(value_type) * n)); 50 | if(result == nullptr) 51 | { 52 | detail::throw_bad_alloc(); 53 | } 54 | 55 | return result; 56 | } 57 | 58 | __AGENCY_ANNOTATION 59 | void deallocate(T* p, std::size_t) 60 | { 61 | ::operator delete(p); 62 | } 63 | }; 64 | 65 | 66 | template 67 | __AGENCY_ANNOTATION 68 | bool operator==(const allocator&, const allocator&) 69 | { 70 | return true; 71 | } 72 | 73 | 74 | template 75 | __AGENCY_ANNOTATION 76 | bool operator!=(const allocator&, const allocator&) 77 | { 78 | return false; 79 | } 80 | 81 | 82 | } // end agency 83 | 84 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/utility/bulk_twoway_execute_with_collected_result.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | 14 | namespace agency 15 | { 16 | namespace detail 17 | { 18 | 19 | 20 | template::value), 22 | __AGENCY_REQUIRES(executor_execution_depth::value == sizeof...(SharedFactories)), 23 | __AGENCY_REQUIRES(!std::is_void, result_of_t&...)>>::value) 24 | > 25 | __AGENCY_ANNOTATION 26 | executor_future_t> 27 | bulk_twoway_execute_with_collected_result(const E& exec, Function f, executor_shape_t shape, ResultFactory result_factory, SharedFactories... shared_factories) 28 | { 29 | // get a reference to avoid copies in agency::require 30 | executor_ref exec_ref{exec}; 31 | 32 | // wrap f in a functor that will collect f's result and call bulk_twoway_execute() 33 | return agency::require(exec_ref, bulk, twoway).bulk_twoway_execute(invoke_and_collect_result{f}, shape, result_factory, shared_factories...); 34 | } 35 | 36 | 37 | } // end detail 38 | } // end agency 39 | 40 | -------------------------------------------------------------------------------- /agency/execution/executor/detail/utility/blocking_bulk_twoway_execute.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | 16 | namespace agency 17 | { 18 | namespace detail 19 | { 20 | 21 | 22 | __agency_exec_check_disable__ 23 | template::value), 25 | __AGENCY_REQUIRES(executor_execution_depth::value == sizeof...(Factories)) 26 | > 27 | __AGENCY_ANNOTATION 28 | detail::result_of_t 29 | blocking_bulk_twoway_execute(const E& exec, Function f, executor_shape_t shape, ResultFactory result_factory, Factories... shared_factories) 30 | { 31 | // grab a reference to exec so that a copy is not created inside of require 32 | detail::executor_ref exec_ref(exec); 33 | 34 | return agency::require(exec_ref, always_blocking, bulk, twoway).bulk_twoway_execute(f, shape, result_factory, shared_factories...).get(); 35 | } 36 | 37 | 38 | } // end detail 39 | } // end agency 40 | 41 | -------------------------------------------------------------------------------- /agency/cuda/execution/execution_policy/grid_execution_policy.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | 13 | namespace agency 14 | { 15 | namespace cuda 16 | { 17 | 18 | 19 | // XXX consider making this a global object like the other execution policies 20 | inline auto grid(size_t num_blocks, size_t num_threads) -> 21 | decltype( 22 | par(num_blocks, con(num_threads)) 23 | ) 24 | { 25 | return par(num_blocks, con(num_threads)); 26 | }; 27 | 28 | 29 | // XXX consider making this a unique type instead of an alias 30 | using grid_agent = parallel_group; 31 | 32 | 33 | // XXX need to figure out how to make this par(con) select grid_executor_2d automatically 34 | // XXX consider making this a global object like the other execution policies 35 | inline auto grid(size2 grid_dim, size2 block_dim) -> 36 | decltype( 37 | par2d(grid_dim, con2d(block_dim)).on(grid_executor_2d()) 38 | ) 39 | { 40 | return par2d(grid_dim, con2d(block_dim)).on(grid_executor_2d()); 41 | } 42 | 43 | // XXX consider making this a unique type instead of an alias 44 | using grid_agent_2d = parallel_group_2d; 45 | 46 | 47 | } // end cuda 48 | } // end agency 49 | 50 | -------------------------------------------------------------------------------- /agency/memory/allocator/detail/allocator_traits/construct.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | namespace agency 10 | { 11 | namespace detail 12 | { 13 | namespace allocator_traits_detail 14 | { 15 | 16 | 17 | __agency_exec_check_disable__ 18 | template 19 | __AGENCY_ANNOTATION 20 | typename std::enable_if< 21 | has_construct::value 22 | >::type 23 | construct(Alloc& a, Pointer p, Args&&... args) 24 | { 25 | a.construct(p, std::forward(args)...); 26 | } // end construct() 27 | 28 | 29 | __agency_exec_check_disable__ 30 | template 31 | __AGENCY_ANNOTATION 32 | typename std::enable_if< 33 | !has_construct::value 34 | >::type 35 | construct(Alloc&, Pointer p, Args&&... args) 36 | { 37 | using element_type = typename std::pointer_traits::element_type; 38 | 39 | ::new(p) element_type(std::forward(args)...); 40 | } // end construct() 41 | 42 | 43 | } // end allocator_traits_detail 44 | 45 | 46 | template 47 | template 48 | __AGENCY_ANNOTATION 49 | void allocator_traits 50 | ::construct(Alloc& alloc, Pointer p, Args&&... args) 51 | { 52 | allocator_traits_detail::construct(alloc, p, std::forward(args)...); 53 | } // end allocator_traits::construct() 54 | 55 | 56 | } // end detail 57 | } // end agency 58 | 59 | -------------------------------------------------------------------------------- /testing/unorganized/reduce.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | template 11 | T reduce(agency::sequenced_execution_policy, Iterator first, Iterator last, T init, BinaryFunction binary_op) 12 | { 13 | return std::accumulate(first, last, init, binary_op); 14 | } 15 | 16 | 17 | template 18 | T reduce(Iterator first, Iterator last, T init, BinaryFunction binary_op) 19 | { 20 | auto n = std::distance(first, last); 21 | 22 | // chop up data into partitions 23 | auto partition_size = 10000; 24 | auto num_partitions = (n + partition_size - 1) / partition_size; 25 | 26 | auto partial_sums = agency::bulk_invoke(agency::par(num_partitions), [=](agency::parallel_agent& g) 27 | { 28 | auto i = g.index(); 29 | 30 | auto partition_begin = first + partition_size * i; 31 | auto partition_end = std::min(last, partition_begin + partition_size); 32 | 33 | return reduce(agency::seq, partition_begin + 1, partition_end, *partition_begin, binary_op); 34 | }); 35 | 36 | return reduce(agency::seq, partial_sums.begin(), partial_sums.end(), init, binary_op); 37 | } 38 | 39 | 40 | int main() 41 | { 42 | size_t n = 1 << 20; 43 | std::vector data(n); 44 | std::generate(data.begin(), data.end(), [](){ return std::rand() % 20; }); 45 | 46 | assert(reduce(data.begin(), data.end(), 0, std::plus()) == accumulate(data.begin(), data.end(), 0, std::plus())); 47 | 48 | std::cout << "OK" << std::endl; 49 | 50 | return 0; 51 | } 52 | 53 | -------------------------------------------------------------------------------- /agency/memory/detail/resource/tiered_resource.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace agency 7 | { 8 | namespace detail 9 | { 10 | 11 | 12 | template 13 | class tiered_resource : private MemoryResource1, private MemoryResource2 14 | { 15 | public: 16 | using primary_resource_type = MemoryResource1; 17 | using fallback_resource_type = MemoryResource2; 18 | 19 | __AGENCY_ANNOTATION 20 | void* allocate(std::size_t n) 21 | { 22 | void* result = primary_resource_type::allocate(n); 23 | if(!result) 24 | { 25 | result = fallback_resource_type::allocate(n); 26 | } 27 | 28 | return result; 29 | } 30 | 31 | __AGENCY_ANNOTATION 32 | void deallocate(void* ptr, std::size_t n) 33 | { 34 | if(primary_resource_type::owns(ptr, n)) 35 | { 36 | primary_resource_type::deallocate(ptr, n); 37 | } 38 | else 39 | { 40 | fallback_resource_type::deallocate(ptr, n); 41 | } 42 | } 43 | 44 | __AGENCY_ANNOTATION 45 | bool owns(void* ptr, std::size_t n) const 46 | { 47 | return primary_resource_type::owns(ptr, n) || fallback_resource_type::owns(ptr, n); 48 | } 49 | 50 | __AGENCY_ANNOTATION 51 | bool operator==(const tiered_resource& other) const 52 | { 53 | return static_cast(*this) == static_cast(other) && 54 | static_cast(*this) == static_cast(other); 55 | } 56 | }; 57 | 58 | 59 | } // end detail 60 | } // end agency 61 | 62 | -------------------------------------------------------------------------------- /testing/bulk_invoke/void_result.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | template 6 | void test() 7 | { 8 | using execution_policy_type = ExecutionPolicy; 9 | 10 | { 11 | // bulk_invoke with no parameters 12 | 13 | execution_policy_type policy; 14 | 15 | std::atomic counter{0}; 16 | 17 | agency::bulk_invoke(policy(10), 18 | [&](typename execution_policy_type::execution_agent_type&) 19 | { 20 | ++counter; 21 | }); 22 | 23 | assert(counter == 10); 24 | } 25 | 26 | { 27 | // bulk_invoke with one parameter 28 | 29 | execution_policy_type policy; 30 | 31 | int val = 13; 32 | 33 | std::atomic counter{0}; 34 | 35 | agency::bulk_invoke(policy(10), 36 | [&](typename execution_policy_type::execution_agent_type&, int val) 37 | { 38 | counter += val; 39 | }, 40 | val 41 | ); 42 | 43 | assert(counter == 10 * 13); 44 | } 45 | 46 | { 47 | // bulk_invoke with one shared parameter 48 | 49 | execution_policy_type policy; 50 | 51 | int val = 13; 52 | 53 | std::atomic counter{0}; 54 | 55 | agency::bulk_invoke(policy(10), 56 | [&](typename execution_policy_type::execution_agent_type&, int& val) 57 | { 58 | counter += val; 59 | }, 60 | agency::share(val) 61 | ); 62 | 63 | assert(counter == 10 * 13); 64 | } 65 | } 66 | 67 | int main() 68 | { 69 | test(); 70 | test(); 71 | test(); 72 | 73 | std::cout << "OK" << std::endl; 74 | 75 | return 0; 76 | } 77 | 78 | -------------------------------------------------------------------------------- /agency/detail/control_structures/decay_parameter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace agency 9 | { 10 | namespace detail 11 | { 12 | 13 | 14 | // this type trait computes the type of the parameter passed to a user function 15 | // given then type of parameter passed to bulk_invoke/bulk_async/etc. 16 | // parameters are passed by value unless they are special parameters like 17 | // shared parameters. These are passed by reference. 18 | template 19 | struct decay_parameter 20 | { 21 | template 22 | struct lazy_add_lvalue_reference 23 | { 24 | using type = typename std::add_lvalue_reference::type; 25 | }; 26 | 27 | // first decay the parameter 28 | using decayed_type = typename std::decay::type; 29 | 30 | // when passing a parameter to the user's function: 31 | // if the parameter is a future, then we pass a reference to its value type 32 | // otherwise, we pass a copy of the decayed_type 33 | using type = typename detail::lazy_conditional< 34 | is_future::value, 35 | lazy_add_lvalue_reference>, 36 | identity 37 | >::type; 38 | }; 39 | 40 | template 41 | using decay_parameter_t = typename decay_parameter::type; 42 | 43 | 44 | template 45 | struct decay_parameter> 46 | { 47 | // shared_parameters are passed to the user function by reference 48 | using type = typename shared_parameter::value_type &; 49 | }; 50 | 51 | 52 | } // end detail 53 | } // end agency 54 | 55 | --------------------------------------------------------------------------------