From e9fe09b3d651fac192210287f57ec1d587056b63 Mon Sep 17 00:00:00 2001 From: Wesley Maxey <71408887+wmaxey@users.noreply.github.com> Date: Mon, 13 May 2024 02:48:37 -0700 Subject: [PATCH] Enable testing for the other half of the heterogeneous managed memory tests on MSVC. (#1729) * Make tests work when full path is specified to lit. * Remove unused alias and simplify managed memory launcher path. * Make rest of managed memory tests work in MSVC. * [pre-commit.ci] auto code formatting --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> --- .../test/libcudacxx/heterogeneous/helpers.h | 90 ++++++++----------- 1 file changed, 39 insertions(+), 51 deletions(-) diff --git a/libcudacxx/test/libcudacxx/heterogeneous/helpers.h b/libcudacxx/test/libcudacxx/heterogeneous/helpers.h index 3b6759d61c..d0d5929e17 100644 --- a/libcudacxx/test/libcudacxx/heterogeneous/helpers.h +++ b/libcudacxx/test/libcudacxx/heterogeneous/helpers.h @@ -313,9 +313,6 @@ void host_validate(T& object) } } -template -using creator = T& (*) (Args...); - template using performer = void (*)(T&); @@ -430,7 +427,7 @@ void validate_device_dynamic(tester_list testers, Args... args) permute_tests(test_harness, initial_launcher_list{}); } -#if __cplusplus >= 201402L +#if _CCCL_STD_VER >= 2014 template struct manual_object { @@ -474,16 +471,15 @@ template __managed__ manual_object managed_variable{}; #endif -template -void validate_in_managed_memory_helper( - creator creator_, performer destroyer, initializer_validator (&performers)[N], Args... args) +template +void validate_in_managed_memory_helper(const Creator& creator, const Destroyer& destroyer, Validator (&performers)[N]) { - T& object = creator_(args...); + auto object = creator(); for (auto&& performer : performers) { - performer.initializer(object); - performer.validator(object); + performer.initializer(*object); + performer.validator(*object); } HETEROGENEOUS_SAFE_CALL(cudaGetLastError()); @@ -501,74 +497,66 @@ void validate_managed(tester_list, Args... args) initializer_validator device_init_host_check[] = {{device_initialize, host_validate}...}; - creator host_constructor = [](Args... args) -> T& { + auto host_constructor = [args...]() -> T* { void* pointer; HETEROGENEOUS_SAFE_CALL(cudaMallocManaged(&pointer, sizeof(T))); - return *new (pointer) T(args...); + return new (pointer) T(args...); }; - creator device_constructor = [](Args... args) -> T& { + auto device_constructor = [args...]() -> T* { void* pointer; HETEROGENEOUS_SAFE_CALL(cudaMallocManaged(&pointer, sizeof(T))); - return *device_construct(pointer, args...); + return device_construct(pointer, args...); }; - performer host_destructor = [](T& object) { - object.~T(); - HETEROGENEOUS_SAFE_CALL(cudaFree(&object)); + auto host_destructor = [](T* object) { + object->~T(); + HETEROGENEOUS_SAFE_CALL(cudaFree(object)); }; - performer device_destructor = [](T& object) { - device_destroy(&object); - HETEROGENEOUS_SAFE_CALL(cudaFree(&object)); + auto device_destructor = [](T* object) { + device_destroy(object); + HETEROGENEOUS_SAFE_CALL(cudaFree(object)); }; - validate_in_managed_memory_helper(host_constructor, host_destructor, host_init_device_check, args...); - validate_in_managed_memory_helper(host_constructor, host_destructor, device_init_host_check, args...); - validate_in_managed_memory_helper(host_constructor, device_destructor, host_init_device_check, args...); - validate_in_managed_memory_helper(host_constructor, device_destructor, device_init_host_check, args...); - validate_in_managed_memory_helper(device_constructor, host_destructor, host_init_device_check, args...); - validate_in_managed_memory_helper(device_constructor, host_destructor, device_init_host_check, args...); - validate_in_managed_memory_helper(device_constructor, device_destructor, host_init_device_check, args...); - validate_in_managed_memory_helper(device_constructor, device_destructor, device_init_host_check, args...); + validate_in_managed_memory_helper(host_constructor, host_destructor, host_init_device_check); + validate_in_managed_memory_helper(host_constructor, host_destructor, device_init_host_check); + validate_in_managed_memory_helper(host_constructor, device_destructor, host_init_device_check); + validate_in_managed_memory_helper(host_constructor, device_destructor, device_init_host_check); + validate_in_managed_memory_helper(device_constructor, host_destructor, host_init_device_check); + validate_in_managed_memory_helper(device_constructor, host_destructor, device_init_host_check); + validate_in_managed_memory_helper(device_constructor, device_destructor, host_init_device_check); + validate_in_managed_memory_helper(device_constructor, device_destructor, device_init_host_check); -#if __cplusplus >= 201402L && !defined(__clang__) +#if _CCCL_STD_VER >= 2014 && !defined(__clang__) // The managed variable template part of this test is disabled under clang, pending nvbug 2790305 being fixed. - creator host_variable_constructor = [](Args... args) -> T& { + auto host_variable_constructor = [args...]() -> T* { managed_variable.construct(args...); - return managed_variable.get(); + return &managed_variable.get(); }; - creator device_variable_constructor = [](Args... args) -> T& { + auto device_variable_constructor = [args...]() -> T* { managed_variable.device_construct(args...); - return managed_variable.get(); + return &managed_variable.get(); }; - performer host_variable_destructor = [](T&) { + auto host_variable_destructor = [](T*) { managed_variable.destroy(); }; - performer device_variable_destructor = [](T&) { + auto device_variable_destructor = [](T*) { managed_variable.device_destroy(); }; - validate_in_managed_memory_helper( - host_variable_constructor, host_variable_destructor, host_init_device_check, args...); - validate_in_managed_memory_helper( - host_variable_constructor, host_variable_destructor, device_init_host_check, args...); - validate_in_managed_memory_helper( - host_variable_constructor, device_variable_destructor, host_init_device_check, args...); - validate_in_managed_memory_helper( - host_variable_constructor, device_variable_destructor, device_init_host_check, args...); - validate_in_managed_memory_helper( - device_variable_constructor, host_variable_destructor, host_init_device_check, args...); - validate_in_managed_memory_helper( - device_variable_constructor, host_variable_destructor, device_init_host_check, args...); - validate_in_managed_memory_helper( - device_variable_constructor, device_variable_destructor, host_init_device_check, args...); - validate_in_managed_memory_helper( - device_variable_constructor, device_variable_destructor, device_init_host_check, args...); + validate_in_managed_memory_helper(host_variable_constructor, host_variable_destructor, host_init_device_check); + validate_in_managed_memory_helper(host_variable_constructor, host_variable_destructor, device_init_host_check); + validate_in_managed_memory_helper(host_variable_constructor, device_variable_destructor, host_init_device_check); + validate_in_managed_memory_helper(host_variable_constructor, device_variable_destructor, device_init_host_check); + validate_in_managed_memory_helper(device_variable_constructor, host_variable_destructor, host_init_device_check); + validate_in_managed_memory_helper(device_variable_constructor, host_variable_destructor, device_init_host_check); + validate_in_managed_memory_helper(device_variable_constructor, device_variable_destructor, host_init_device_check); + validate_in_managed_memory_helper(device_variable_constructor, device_variable_destructor, device_init_host_check); #endif }