diff --git a/README.md b/README.md index d033ff4..b8bab61 100644 --- a/README.md +++ b/README.md @@ -180,16 +180,17 @@ the `--kernel-replayer-dump` command line flag: ### Repeating a replay with the same inputs -```cpp -krepe::ScopeGuard replay_scope(argc, argv, /*enable_input_reset=*/true); -Kokkos::ScopeGuard kokkos_scope(argc, argv); +It is possible to reset the input views in the replayed program to their +original value, by calling `krepe::reset_inputs()`. In order to enable this +functionality, you should add the `--kernel-replayer-enable-input-reset` when +launching the replayed program. -replay_scope.reset_inputs(); +```sh +./replay_prog --kernel-replayer-dump=krepe_scale_2.h5 --kernel-replayer-enable-input-reset ``` -This option stores a copy of the inputs in host memory. `reset_inputs()` waits -for previous work and restores those bytes at the same addresses, completing -all copies before returning. +Note that calling `reset_inputs` will fence before and after the memory copies +required to restore the data. ### Modifying the execution policy diff --git a/src/krepe/replay/kernel_replayer.cpp b/src/krepe/replay/kernel_replayer.cpp index 5482519..5ea4e2a 100644 --- a/src/krepe/replay/kernel_replayer.cpp +++ b/src/krepe/replay/kernel_replayer.cpp @@ -34,8 +34,8 @@ void remove_cli_args(int& argc, char* argv[], int pos, int n) { argc -= n; } -std::string_view find_flag_argument(int& argc, char* argv[], - std::string_view flag) { +std::string_view find_cli_option(int& argc, char* argv[], + std::string_view flag) { std::string_view argument; for (int i = 1; i < argc; i++) { std::string_view current_arg{argv[i]}; @@ -62,6 +62,17 @@ std::string_view find_flag_argument(int& argc, char* argv[], return argument; } +bool find_cli_flag(int& argc, char* argv[], std::string_view flag) { + for (int i = 1; i < argc; i++) { + if (argv[i] == flag) { + remove_cli_args(argc, argv, i, 1); + return true; + } + } + + return false; +} + void device_init() { int device_supports_virtual_address = 0; #if defined(KOKKOS_ENABLE_CUDA) @@ -128,6 +139,13 @@ namespace impl { static const ReplayAllocations* replay_allocations = nullptr; static std::unordered_map metadata; +static bool krepe_is_initialized = false; +static bool input_reset_enabled = false; +// ScopeGuard used internally by krepe::initialize and krepe::finalize +static std::unique_ptr initialize_internal_scope_guard; +// Pointer to the ScopeGuard that was either created by the user or by +// krepe::initialize +static ScopeGuard* scope_guard = nullptr; static void check_replay_allocations( [[maybe_unused]] MemorySpaceType memory_space) { @@ -749,10 +767,17 @@ std::vector> compute_allocations( } } // namespace impl -ScopeGuard::ScopeGuard(int& argc, char* argv[], bool enable_input_reset) - : enable_input_reset_(enable_input_reset) { +ScopeGuard::ScopeGuard(int& argc, char* argv[]) { + if (impl::krepe_is_initialized) { + throw std::runtime_error( + "Constructing a ScopeGuard but krepe has already been initialized"); + } + + impl::input_reset_enabled = + find_cli_flag(argc, argv, "--kernel-replayer-enable-input-reset"); + std::string_view hdf5_filename = - find_flag_argument(argc, argv, "--kernel-replayer-dump"); + find_cli_option(argc, argv, "--kernel-replayer-dump"); if (hdf5_filename.data() == nullptr) { throw std::runtime_error( "The kernel replayer expects the flag --kernel-replayer-dump"); @@ -814,7 +839,7 @@ ScopeGuard::ScopeGuard(int& argc, char* argv[], bool enable_input_reset) const auto space = impl::memory_space_type_from_string(entry.space); if (entry.size != 0) { impl::copy_data(space, entry.address, data, entry.size); - if (enable_input_reset_) { + if (impl::input_reset_enabled) { input_snapshots_.push_back( {space, entry.address, std::vector(data, data + entry.size)}); @@ -872,19 +897,26 @@ ScopeGuard::ScopeGuard(int& argc, char* argv[], bool enable_input_reset) file.close_checked(); impl::replay_allocations = &replay_allocations_; + + impl::krepe_is_initialized = true; + impl::scope_guard = this; } ScopeGuard::~ScopeGuard() { if (impl::replay_allocations == &replay_allocations_) { impl::replay_allocations = nullptr; } + impl::scope_guard = nullptr; } void ScopeGuard::reset_inputs() { - if (!enable_input_reset_) { + if (!impl::input_reset_enabled) { throw std::runtime_error( - "Input reset must be enabled when constructing krepe::ScopeGuard"); + "Input reset must be enabled via the " + "--kernel-replayer-enable-input-reset flag in order to be able to call " + "krepe::reset_inputs()"); } + // FIXME: remove once the scopeguard requires kokkos to be initialized if (!Kokkos::is_initialized() || Kokkos::is_finalized()) { throw std::runtime_error( "reset_inputs can be called only inside Kokkos execution environment"); @@ -948,4 +980,46 @@ void ScopeGuard::allocate_output(impl::StoredAllocation& allocation, descriptor.reference_data = allocation.reference.get(); } +void initialize(int& argc, char* argv[]) { + if (impl::krepe_is_initialized) { + throw std::runtime_error( + "Trying to initialize krepe, but it has already been initialized"); + } + + impl::initialize_internal_scope_guard = + std::make_unique(argc, argv); +} + +void finalize() { + if (!impl::krepe_is_initialized) { + throw std::runtime_error( + "Trying to finalize krepe, but it has not been initialized"); + } + + // if the internal ScopeGuard is null, either krepe has been initialized by + // the user constructing a ScopeGuard (in which case impl::scope_guard is + // non-null) or krepe has already been finalized (impl::scope_guard is null) + if (!impl::initialize_internal_scope_guard) { + if (impl::scope_guard) { + throw std::runtime_error( + "Trying to call krepe::finalize, but krepe has been initialized by a " + "ScopeGuard"); + } else { + throw std::runtime_error( + "Trying to call krepe::finalize, but krepe has already been " + "finalized"); + } + } + + impl::initialize_internal_scope_guard.reset(); +} + +void reset_inputs() { + if (impl::scope_guard == nullptr) { + throw std::runtime_error("krepe::reset_inputs(): krepe is not initialized"); + } + + impl::scope_guard->reset_inputs(); +} + } // namespace krepe diff --git a/src/krepe/replay/kernel_replayer.hpp b/src/krepe/replay/kernel_replayer.hpp index 13012c2..86b28c8 100644 --- a/src/krepe/replay/kernel_replayer.hpp +++ b/src/krepe/replay/kernel_replayer.hpp @@ -424,7 +424,6 @@ class ScopeGuard { std::vector data; }; - bool enable_input_reset_; std::vector input_snapshots_; impl::ReplayAllocations replay_allocations_; std::vector host_raw_allocations; @@ -439,18 +438,26 @@ class ScopeGuard { const impl::SnapshotAllocation& snapshot, const std::byte* data); + void reset_inputs(); + public: // Enabling input reset keeps a host copy of all input allocation bytes. - ScopeGuard(int& argc, char* argv[], bool enable_input_reset = false); + ScopeGuard(int& argc, char* argv[]); ScopeGuard(const ScopeGuard&) = delete; ScopeGuard& operator=(const ScopeGuard&) = delete; ~ScopeGuard(); - // Restore inputs at their original addresses without reloading the dump. - // Requires input reset to be enabled and Kokkos to be initialized. - void reset_inputs(); + friend void reset_inputs(); }; +void initialize(int& argc, char* argv[]); + +void finalize(); + +// Restore inputs at their original addresses without reloading the dump. +// Requires input reset to be enabled and Kokkos to be initialized. +void reset_inputs(); + std::optional get_metadata(const std::string& key); template diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index c6e9537..2c0d29f 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -9,18 +9,22 @@ set(TEST_LAUNCHER "${CMAKE_CURRENT_LIST_DIR}/launcher.sh") # the same replay tests inside a single Slurm allocation. add_custom_target(krepe_run_replay_tests) -function(add_replay_test TEST_NAME COMPARE_OUTPUT) +function(add_replay_test TEST_NAME) + cmake_parse_arguments(PARSE_ARGV 1 arg "COMPARE_OUTPUT" "" "TOOL_FLAGS;REPLAY_FLAGS") set(TEST_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/work/${TEST_NAME}") file(MAKE_DIRECTORY "${TEST_WORKING_DIRECTORY}") - if(COMPARE_OUTPUT) - set(COMPARE_OUTPUT TRUE) - else() - set(COMPARE_OUTPUT FALSE) + if(NOT arg_TOOL_FLAGS) + set(arg_TOOL_FLAGS "\"\"") endif() - set(TEST_COMMAND "${TEST_LAUNCHER}" "$" "$" - "$" "${COMPARE_OUTPUT}" ${ARGN} + if(NOT arg_REPLAY_FLAGS) + set(arg_REPLAY_FLAGS "\"\"") + endif() + + set(TEST_COMMAND + "${TEST_LAUNCHER}" "$" "$" + "$" "${arg_COMPARE_OUTPUT}" "${arg_TOOL_FLAGS}" "${arg_REPLAY_FLAGS}" ) add_test(NAME "${TEST_NAME}" COMMAND ${TEST_COMMAND} WORKING_DIRECTORY "${TEST_WORKING_DIRECTORY}") @@ -60,6 +64,7 @@ add_subdirectory(team_policy) add_subdirectory(non_default_execution_space) add_subdirectory(index_type) add_subdirectory(empty_view) +add_subdirectory(initialize_finalize) if(Kokkos_ENABLE_CUDA OR Kokkos_ENABLE_HIP) add_subdirectory(gpu_memory_spaces) diff --git a/tests/empty_view/CMakeLists.txt b/tests/empty_view/CMakeLists.txt index 13194cc..ced4d6b 100644 --- a/tests/empty_view/CMakeLists.txt +++ b/tests/empty_view/CMakeLists.txt @@ -9,7 +9,7 @@ target_link_libraries( empty_view_replay PRIVATE krepe_warnings krepe_sanitizers Kokkos::kokkos kernel_replayer_sanitized ) -add_replay_test(empty_view FALSE) +add_replay_test(empty_view) add_executable(empty_view_without_extent without_extent_main.cpp) target_link_libraries(empty_view_without_extent PRIVATE krepe_warnings krepe_sanitizers Kokkos::kokkos kernel_extractor) @@ -19,4 +19,4 @@ target_link_libraries( empty_view_without_extent_replay PRIVATE krepe_warnings krepe_sanitizers Kokkos::kokkos kernel_replayer_sanitized ) -add_replay_test(empty_view_without_extent FALSE) +add_replay_test(empty_view_without_extent) diff --git a/tests/force_policy/CMakeLists.txt b/tests/force_policy/CMakeLists.txt index 91febf5..38cf1c8 100644 --- a/tests/force_policy/CMakeLists.txt +++ b/tests/force_policy/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(force_policy PRIVATE krepe_warnings krepe_sanitizers Kokko add_executable(force_policy_replay replay_main.cpp) target_link_libraries(force_policy_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(force_policy "") +add_replay_test(force_policy) diff --git a/tests/force_policy/view_capture/CMakeLists.txt b/tests/force_policy/view_capture/CMakeLists.txt deleted file mode 100644 index d3c23b6..0000000 --- a/tests/force_policy/view_capture/CMakeLists.txt +++ /dev/null @@ -1,10 +0,0 @@ -# SPDX-License-Identifier: MIT -# SPDX-FileCopyrightText: Copyright Contributors to the KREPE project - -add_executable(view_capture main.cpp) -target_link_libraries(view_capture PRIVATE krepe_warnings krepe_sanitizers Kokkos::kokkos kernel_extractor) - -add_executable(view_capture_replay replay_main.cpp) -target_link_libraries(view_capture_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) - -add_replay_test(view_capture "") diff --git a/tests/force_policy/view_capture/main.cpp b/tests/force_policy/view_capture/main.cpp deleted file mode 100644 index ac2e488..0000000 --- a/tests/force_policy/view_capture/main.cpp +++ /dev/null @@ -1,25 +0,0 @@ -// SPDX-License-Identifier: MIT -// SPDX-FileCopyrightText: Copyright Contributors to the KREPE project - -#include - -#include - -int main(int argc, char* argv[]) { - Kokkos::ScopeGuard kokkos_scope(argc, argv); - - const int N = 1024; - Kokkos::View values("values", N); - Kokkos::parallel_for( - "init", values.size(), KOKKOS_LAMBDA(int i) { values(i) = i; }); - - krepe::parallel_for( - "test_kernel", N, KOKKOS_LAMBDA(int i) { values(i) *= 2; }); - Kokkos::fence(); - - auto h_values = - Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), values); - Kokkos::printf("values(5) = %d\n", h_values(5)); - - return 0; -} diff --git a/tests/force_policy/view_capture/replay_main.cpp b/tests/force_policy/view_capture/replay_main.cpp deleted file mode 100644 index 3771a0e..0000000 --- a/tests/force_policy/view_capture/replay_main.cpp +++ /dev/null @@ -1,43 +0,0 @@ -// SPDX-License-Identifier: MIT -// SPDX-FileCopyrightText: Copyright Contributors to the KREPE project - -#include - -#include - -int main(int argc, char* argv[]) { - krepe::ScopeGuard replay_scope(argc, argv); - Kokkos::ScopeGuard kokkos_scope(argc, argv); - - const int N = 1024; - Kokkos::View values; - // Kokkos::parallel_for( - // "init", values.size(), KOKKOS_LAMBDA(int i) { values(i) = i; }); - - krepe::parallel_for( - "test_kernel", 0, KOKKOS_LAMBDA(int i) { values(i) *= 2; }); - Kokkos::fence(); - - // auto h_values = - // Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), values); - // Kokkos::printf("values(5) = %d\n", h_values(5)); - - krepe::compare_views( - "values", std::make_tuple(1024), [](auto ref_values, auto replay_values) { - auto h_replay_values = Kokkos::create_mirror_view_and_copy( - Kokkos::HostSpace(), replay_values); - - auto h_ref_values = Kokkos::create_mirror_view_and_copy( - Kokkos::HostSpace(), ref_values); - - for (int i = 0; i < N; i++) { - if (h_replay_values(i) != h_ref_values(i)) { - Kokkos::printf("At index %d, expected %d but got %d\n", i, - h_ref_values(i), h_replay_values(i)); - std::exit(1); - } - } - }); - - return 0; -} diff --git a/tests/gpu_memory_spaces/CMakeLists.txt b/tests/gpu_memory_spaces/CMakeLists.txt index fe890c0..c622629 100644 --- a/tests/gpu_memory_spaces/CMakeLists.txt +++ b/tests/gpu_memory_spaces/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(gpu_memory_spaces PRIVATE krepe_warnings krepe_sanitizers add_executable(gpu_memory_spaces_replay replay_main.cpp) target_link_libraries(gpu_memory_spaces_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(gpu_memory_spaces FALSE) +add_replay_test(gpu_memory_spaces REPLAY_FLAGS --kernel-replayer-enable-input-reset) diff --git a/tests/gpu_memory_spaces/replay_main.cpp b/tests/gpu_memory_spaces/replay_main.cpp index 20d75c5..4cefe77 100644 --- a/tests/gpu_memory_spaces/replay_main.cpp +++ b/tests/gpu_memory_spaces/replay_main.cpp @@ -106,7 +106,7 @@ void compare_values(const krepe::ReplayAllocation& allocation) { } // namespace int main(int argc, char* argv[]) { - krepe::ScopeGuard replay_scope(argc, argv, true); + krepe::ScopeGuard replay_scope(argc, argv); Kokkos::ScopeGuard kokkos_scope(argc, argv); Kokkos::View device_values; @@ -114,7 +114,7 @@ int main(int argc, char* argv[]) { Kokkos::View host_pinned_values; for (int repetition = 0; repetition < 3; ++repetition) { - replay_scope.reset_inputs(); + krepe::reset_inputs(); krepe::parallel_for( "test_kernel", 0, KOKKOS_LAMBDA(const int i) { device_values(i) *= 2; diff --git a/tests/index_type/CMakeLists.txt b/tests/index_type/CMakeLists.txt index 06a3b3d..69d273f 100644 --- a/tests/index_type/CMakeLists.txt +++ b/tests/index_type/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(index_type PRIVATE krepe_warnings krepe_sanitizers Kokkos: add_executable(index_type_replay replay_main.cpp) target_link_libraries(index_type_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(index_type FALSE) +add_replay_test(index_type) diff --git a/tests/initialize_finalize/CMakeLists.txt b/tests/initialize_finalize/CMakeLists.txt new file mode 100644 index 0000000..f168e8e --- /dev/null +++ b/tests/initialize_finalize/CMakeLists.txt @@ -0,0 +1,10 @@ +# SPDX-License-Identifier: MIT +# SPDX-FileCopyrightText: Copyright Contributors to the KREPE project + +add_executable(initialize_finalize main.cpp) +target_link_libraries(initialize_finalize PRIVATE krepe_warnings krepe_sanitizers Kokkos::kokkos kernel_extractor) + +add_executable(initialize_finalize_replay replay_main.cpp) +target_link_libraries(initialize_finalize_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) + +add_replay_test(initialize_finalize) diff --git a/tests/initialize_finalize/main.cpp b/tests/initialize_finalize/main.cpp new file mode 100644 index 0000000..14f0783 --- /dev/null +++ b/tests/initialize_finalize/main.cpp @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: MIT +// SPDX-FileCopyrightText: Copyright Contributors to the KREPE project + +#include + +#include + +int main(int argc, char* argv[]) { + Kokkos::initialize(argc, argv); + { + const int N = 1024; + Kokkos::View values("values", N); + Kokkos::parallel_for( + "init", values.size(), KOKKOS_LAMBDA(int i) { values(i) = i; }); + + krepe::parallel_for( + "test_kernel", N, KOKKOS_LAMBDA(int i) { values(i) *= 2; }); + Kokkos::fence(); + + auto h_values = + Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), values); + Kokkos::printf("values(5) = %d\n", h_values(5)); + } + Kokkos::finalize(); + return 0; +} diff --git a/tests/initialize_finalize/replay_main.cpp b/tests/initialize_finalize/replay_main.cpp new file mode 100644 index 0000000..c4714fe --- /dev/null +++ b/tests/initialize_finalize/replay_main.cpp @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: MIT +// SPDX-FileCopyrightText: Copyright Contributors to the KREPE project + +#include + +#include + +// FIXME: properly test that krepe cannot be used when not initialized or when +// finalized +int main(int argc, char* argv[]) { + krepe::initialize(argc, argv); + Kokkos::initialize(argc, argv); + { + const int N = 1024; + Kokkos::View values; + // Kokkos::parallel_for( + // "init", values.size(), KOKKOS_LAMBDA(int i) { values(i) = i; }); + + krepe::parallel_for( + "test_kernel", 0, KOKKOS_LAMBDA(int i) { values(i) *= 2; }); + Kokkos::fence(); + + // auto h_values = + // Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), values); + // Kokkos::printf("values(5) = %d\n", h_values(5)); + + krepe::compare_views( + "values", std::make_tuple(1024), + [](auto ref_values, auto replay_values) { + auto h_replay_values = Kokkos::create_mirror_view_and_copy( + Kokkos::HostSpace(), replay_values); + + auto h_ref_values = Kokkos::create_mirror_view_and_copy( + Kokkos::HostSpace(), ref_values); + + for (int i = 0; i < N; i++) { + if (h_replay_values(i) != h_ref_values(i)) { + Kokkos::printf("At index %d, expected %d but got %d\n", i, + h_ref_values(i), h_replay_values(i)); + std::exit(1); + } + } + }); + } + Kokkos::finalize(); + krepe::finalize(); + return 0; +} diff --git a/tests/launcher.sh b/tests/launcher.sh index 0d8c8f5..4c8f806 100755 --- a/tests/launcher.sh +++ b/tests/launcher.sh @@ -3,8 +3,8 @@ set -o pipefail shopt -s nullglob -if [ $# -lt 3 ]; then - echo "The script expects at least 3 arguments" +if [ $# -ne 6 ]; then + echo "The script expects 6 arguments" exit 1 fi @@ -15,13 +15,8 @@ COMPARE_OUTPUT=0 if [ "${4:-}" = "TRUE" ]; then COMPARE_OUTPUT=1 fi - -if [ $# -ge 4 ]; then - shift 4 -else - shift 3 -fi -EXTRA_KOKKOS_TOOLS_ARGS="$*" +EXTRA_KOKKOS_TOOLS_ARGS=$5 +REPLAYER_ARGS=$6 OUTPUT_DIR=$(mktemp -d) REFERENCE_OUTPUT="$OUTPUT_DIR/reference.txt" @@ -54,7 +49,7 @@ if (( ${#DUMP_FILES[@]} != 1 )); then clean_exit 1 fi -$REPLAY_EXECUTABLE --kernel-replayer-dump="${DUMP_FILES[0]}" | tee "$REPLAY_OUTPUT" +$REPLAY_EXECUTABLE --kernel-replayer-dump="${DUMP_FILES[0]}" $REPLAYER_ARGS | tee "$REPLAY_OUTPUT" EXIT_CODE=$? if [ $EXIT_CODE -ne 0 ]; then clean_exit $EXIT_CODE diff --git a/tests/manual_extraction/CMakeLists.txt b/tests/manual_extraction/CMakeLists.txt index 173d28f..1d2e3c1 100644 --- a/tests/manual_extraction/CMakeLists.txt +++ b/tests/manual_extraction/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(manual_extraction PRIVATE krepe_warnings krepe_sanitizers add_executable(manual_extraction_replay replay_main.cpp) target_link_libraries(manual_extraction_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(manual_extraction "") +add_replay_test(manual_extraction) diff --git a/tests/mdrange_iteration_pattern/CMakeLists.txt b/tests/mdrange_iteration_pattern/CMakeLists.txt index de2c684..b2259c4 100644 --- a/tests/mdrange_iteration_pattern/CMakeLists.txt +++ b/tests/mdrange_iteration_pattern/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(mdrange_iteration_pattern PRIVATE krepe_warnings krepe_san add_executable(mdrange_iteration_pattern_replay replay_main.cpp) target_link_libraries(mdrange_iteration_pattern_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(mdrange_iteration_pattern TRUE) +add_replay_test(mdrange_iteration_pattern COMPARE_OUTPUT) diff --git a/tests/mdrange_policy/CMakeLists.txt b/tests/mdrange_policy/CMakeLists.txt index a817888..a4d8a52 100644 --- a/tests/mdrange_policy/CMakeLists.txt +++ b/tests/mdrange_policy/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(mdrange_policy PRIVATE krepe_warnings krepe_sanitizers Kok add_executable(mdrange_policy_replay replay_main.cpp) target_link_libraries(mdrange_policy_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(mdrange_policy FALSE) +add_replay_test(mdrange_policy) diff --git a/tests/metadata/CMakeLists.txt b/tests/metadata/CMakeLists.txt index eae8461..4aa1b6a 100644 --- a/tests/metadata/CMakeLists.txt +++ b/tests/metadata/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(metadata PRIVATE krepe_warnings krepe_sanitizers Kokkos::k add_executable(metadata_replay replay_main.cpp) target_link_libraries(metadata_replay PRIVATE krepe_warnings krepe_sanitizers Kokkos::kokkos kernel_replayer_sanitized) -add_replay_test(metadata TRUE) +add_replay_test(metadata COMPARE_OUTPUT) diff --git a/tests/missing_output/CMakeLists.txt b/tests/missing_output/CMakeLists.txt index 3c8243b..edd962d 100644 --- a/tests/missing_output/CMakeLists.txt +++ b/tests/missing_output/CMakeLists.txt @@ -8,4 +8,4 @@ target_link_libraries(missing_output PRIVATE krepe_warnings krepe_sanitizers Kok add_executable(missing_output_replay replay_main.cpp) target_link_libraries(missing_output_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(missing_output FALSE) +add_replay_test(missing_output) diff --git a/tests/multiple_views_capture/CMakeLists.txt b/tests/multiple_views_capture/CMakeLists.txt index 5070ca1..bac75fa 100644 --- a/tests/multiple_views_capture/CMakeLists.txt +++ b/tests/multiple_views_capture/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(multiple_views_capture PRIVATE krepe_warnings krepe_saniti add_executable(multiple_views_capture_replay replay_main.cpp) target_link_libraries(multiple_views_capture_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(multiple_views_capture FALSE) +add_replay_test(multiple_views_capture) diff --git a/tests/no_capture/CMakeLists.txt b/tests/no_capture/CMakeLists.txt index 0796ee5..a0e3baf 100644 --- a/tests/no_capture/CMakeLists.txt +++ b/tests/no_capture/CMakeLists.txt @@ -9,4 +9,4 @@ target_link_libraries( no_capture_replay PRIVATE krepe_warnings krepe_sanitizers Kokkos::kokkos kernel_replayer_sanitized ) -add_replay_test(no_capture TRUE) +add_replay_test(no_capture COMPARE_OUTPUT) diff --git a/tests/non_default_execution_space/CMakeLists.txt b/tests/non_default_execution_space/CMakeLists.txt index 616c39c..55215c9 100644 --- a/tests/non_default_execution_space/CMakeLists.txt +++ b/tests/non_default_execution_space/CMakeLists.txt @@ -9,4 +9,4 @@ target_link_libraries( add_executable(non_default_execution_space_replay replay_main.cpp) target_link_libraries(non_default_execution_space_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(non_default_execution_space FALSE) +add_replay_test(non_default_execution_space) diff --git a/tests/overloaded_functor/CMakeLists.txt b/tests/overloaded_functor/CMakeLists.txt index e1e0196..1e131b3 100644 --- a/tests/overloaded_functor/CMakeLists.txt +++ b/tests/overloaded_functor/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(overloaded_functor PRIVATE krepe_warnings krepe_sanitizers add_executable(overloaded_functor_replay replay_main.cpp) target_link_libraries(overloaded_functor_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(overloaded_functor FALSE) +add_replay_test(overloaded_functor) diff --git a/tests/range_policy/CMakeLists.txt b/tests/range_policy/CMakeLists.txt index dddf8ca..8c78d9e 100644 --- a/tests/range_policy/CMakeLists.txt +++ b/tests/range_policy/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(range_policy PRIVATE krepe_warnings krepe_sanitizers Kokko add_executable(range_policy_replay replay_main.cpp) target_link_libraries(range_policy_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(range_policy FALSE) +add_replay_test(range_policy) diff --git a/tests/repeated_kernel_invocation/CMakeLists.txt b/tests/repeated_kernel_invocation/CMakeLists.txt index dc6466a..afe944a 100644 --- a/tests/repeated_kernel_invocation/CMakeLists.txt +++ b/tests/repeated_kernel_invocation/CMakeLists.txt @@ -9,4 +9,7 @@ target_link_libraries( add_executable(repeated_kernel_invocation_replay replay_main.cpp) target_link_libraries(repeated_kernel_invocation_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(repeated_kernel_invocation FALSE "--krepe-dump-kernel-invocation=2") +add_replay_test( + repeated_kernel_invocation TOOL_FLAGS --krepe-dump-kernel-invocation=2 REPLAY_FLAGS + --kernel-replayer-enable-input-reset +) diff --git a/tests/repeated_kernel_invocation/replay_main.cpp b/tests/repeated_kernel_invocation/replay_main.cpp index c7434e7..d377ecd 100644 --- a/tests/repeated_kernel_invocation/replay_main.cpp +++ b/tests/repeated_kernel_invocation/replay_main.cpp @@ -13,14 +13,14 @@ struct MultiplyFunctor { }; int main(int argc, char* argv[]) { - krepe::ScopeGuard replay_scope(argc, argv, true); + krepe::ScopeGuard replay_scope(argc, argv); Kokkos::ScopeGuard kokkos_scope(argc, argv); const int N = 1024; Kokkos::View values; for (int repetition = 0; repetition < 3; ++repetition) { - replay_scope.reset_inputs(); + krepe::reset_inputs(); krepe::parallel_for("test_kernel", N, MultiplyFunctor{0, values}); Kokkos::fence(); diff --git a/tests/scalar_capture/CMakeLists.txt b/tests/scalar_capture/CMakeLists.txt index 735ab9f..781167b 100644 --- a/tests/scalar_capture/CMakeLists.txt +++ b/tests/scalar_capture/CMakeLists.txt @@ -9,4 +9,4 @@ target_link_libraries( scalar_capture_replay PRIVATE krepe_warnings krepe_sanitizers Kokkos::kokkos kernel_replayer_sanitized ) -add_replay_test(scalar_capture TRUE) +add_replay_test(scalar_capture COMPARE_OUTPUT) diff --git a/tests/small_struct_functor/CMakeLists.txt b/tests/small_struct_functor/CMakeLists.txt index f15a89f..3cee0c1 100644 --- a/tests/small_struct_functor/CMakeLists.txt +++ b/tests/small_struct_functor/CMakeLists.txt @@ -9,4 +9,4 @@ target_link_libraries( small_struct_functor_replay PRIVATE krepe_warnings krepe_sanitizers Kokkos::kokkos kernel_replayer_sanitized ) -add_replay_test(small_struct_functor TRUE) +add_replay_test(small_struct_functor COMPARE_OUTPUT) diff --git a/tests/struct_functor/CMakeLists.txt b/tests/struct_functor/CMakeLists.txt index b620dee..7847365 100644 --- a/tests/struct_functor/CMakeLists.txt +++ b/tests/struct_functor/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(struct_functor PRIVATE krepe_warnings krepe_sanitizers Kok add_executable(struct_functor_replay replay_main.cpp) target_link_libraries(struct_functor_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(struct_functor FALSE) +add_replay_test(struct_functor) diff --git a/tests/team_policy/CMakeLists.txt b/tests/team_policy/CMakeLists.txt index c0fb965..06b0f16 100644 --- a/tests/team_policy/CMakeLists.txt +++ b/tests/team_policy/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(team_policy PRIVATE krepe_warnings krepe_sanitizers Kokkos add_executable(team_policy_replay replay_main.cpp) target_link_libraries(team_policy_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(team_policy FALSE) +add_replay_test(team_policy) diff --git a/tests/view_capture/CMakeLists.txt b/tests/view_capture/CMakeLists.txt index 6a1087a..8f15914 100644 --- a/tests/view_capture/CMakeLists.txt +++ b/tests/view_capture/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(view_capture PRIVATE krepe_warnings krepe_sanitizers Kokko add_executable(view_capture_replay replay_main.cpp) target_link_libraries(view_capture_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(view_capture FALSE) +add_replay_test(view_capture) diff --git a/tests/view_capture/replay_main.cpp b/tests/view_capture/replay_main.cpp index c620642..1473ff9 100644 --- a/tests/view_capture/replay_main.cpp +++ b/tests/view_capture/replay_main.cpp @@ -11,7 +11,7 @@ int main(int argc, char* argv[]) { bool rejected = false; try { - replay_scope.reset_inputs(); + krepe::reset_inputs(); } catch (const std::runtime_error&) { rejected = true; } diff --git a/tests/view_comparison/CMakeLists.txt b/tests/view_comparison/CMakeLists.txt index 328433b..017cd4c 100644 --- a/tests/view_comparison/CMakeLists.txt +++ b/tests/view_comparison/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(view_comparison PRIVATE krepe_warnings krepe_sanitizers Ko add_executable(view_comparison_replay replay_main.cpp) target_link_libraries(view_comparison_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(view_comparison FALSE) +add_replay_test(view_comparison) diff --git a/tests/view_scalar_capture/CMakeLists.txt b/tests/view_scalar_capture/CMakeLists.txt index baf5975..d6f18ff 100644 --- a/tests/view_scalar_capture/CMakeLists.txt +++ b/tests/view_scalar_capture/CMakeLists.txt @@ -7,4 +7,4 @@ target_link_libraries(view_scalar_capture PRIVATE krepe_warnings krepe_sanitizer add_executable(view_scalar_capture_replay replay_main.cpp) target_link_libraries(view_scalar_capture_replay PRIVATE krepe_warnings Kokkos::kokkos kernel_replayer) -add_replay_test(view_scalar_capture FALSE) +add_replay_test(view_scalar_capture)