파일
rocm-systems/tests/test-amdhip-ctor-mt.cpp
T
Jonathan R. Madsen fa4295db6b Initial Implementation: include (#10)
* Initial Implementation: include

* Initial Implementation: lib details (#11)

* Initial Implementation: lib details

* Initial Implementation: lib (#12)

* Initial Implementation: lib

* Initial Implementation: source (#13)

* Initial Implementation: source

* Initial Implementation: samples (#14)

* Initial Implementation: samples

* Initial Implementation: tests (#15)

* Initial Implementation: tests

* Initial Implementation: scripts (#16)

* Initial Implementation: scripts

* Initial Implementation: cmake (#17)

* Initial Implementation: cmake

* Initial Implementation: top-level files (#18)

* Initial Implementation: top-level files

- clang-format
- clang-tidy
- cmake-format
- ignore build and cache directories
- main CMakeLists.txt
- pyproject.toml (python formatting)
- VERSION file

* Initial Implementation: workflow (#19)

* Fix unused variable

- rocprofiler_register_warn_level
2023-08-17 14:59:24 -05:00

73 라인
1.4 KiB
C++

#include <dlfcn.h>
#include <pthread.h>
#include <cstdlib>
#include <string>
#include <thread>
#include <vector>
#include "common/fwd.hpp"
void
run(const std::string& name, pthread_barrier_t* _barrier)
{
if(_barrier) pthread_barrier_wait(_barrier);
if(hsa_init_fn)
{
if(_barrier) pthread_barrier_wait(_barrier);
hsa_init_fn();
}
if(hip_init_fn)
{
if(_barrier) pthread_barrier_wait(_barrier);
hip_init_fn();
}
if(roctxRangePush_fn)
{
if(_barrier) pthread_barrier_wait(_barrier);
roctxRangePush_fn(name.c_str());
}
if(roctxRangePop_fn)
{
if(_barrier) pthread_barrier_wait(_barrier);
roctxRangePop_fn(name.c_str());
}
}
auto
run_threads(unsigned long n)
{
resolve_symbols<ROCP_REG_TEST_HIP>();
auto threads = std::vector<std::thread>{};
auto names = std::vector<std::string>{};
for(unsigned long i = 0; i < n; ++i)
names.emplace_back(std::string{ "thread-" } + std::to_string(i));
auto _barrier = pthread_barrier_t{};
pthread_barrier_init(&_barrier, nullptr, n);
for(unsigned long i = 0; i < n; ++i)
threads.emplace_back(run, names.at(i), &_barrier);
for(auto& itr : threads)
itr.join();
pthread_barrier_destroy(&_barrier);
return n;
}
auto run_n = run_threads(4);
int
main()
{
return (run_n == 4) ? EXIT_SUCCESS : EXIT_FAILURE;
}