81 lines
1.7 KiB
C++
81 lines
1.7 KiB
C++
#include "../ufbx.h"
|
|
#include <thread>
|
|
#include <atomic>
|
|
#include <vector>
|
|
#include <chrono>
|
|
#include <cstdlib>
|
|
#include <stdio.h>
|
|
|
|
std::atomic_int32_t atomic_count { 0 };
|
|
int32_t race_count = 0;
|
|
bool allocator_freed = false;
|
|
|
|
void free_allocator(void*)
|
|
{
|
|
allocator_freed = true;
|
|
}
|
|
|
|
void worker(ufbx_scene *scene)
|
|
{
|
|
std::this_thread::sleep_for(std::chrono::milliseconds{100});
|
|
for (uint32_t i = 0; i < 0x1000000; i++) {
|
|
ufbx_retain_scene(scene);
|
|
ufbx_free_scene(scene);
|
|
atomic_count.fetch_add(1, std::memory_order_relaxed);
|
|
race_count++;
|
|
}
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
if (argc < 3) {
|
|
fprintf(stderr, "Usage: check_threads <file.fbx> <num-threads>\n");
|
|
return 1;
|
|
}
|
|
|
|
if (!ufbx_is_thread_safe()) {
|
|
fprintf(stderr, "WARNING: Not thread safe, expect failure!\n");
|
|
}
|
|
|
|
size_t num_threads = (size_t)atoi(argv[2]);
|
|
|
|
ufbx_load_opts opts = { };
|
|
opts.result_allocator.allocator.free_allocator_fn = &free_allocator;
|
|
|
|
ufbx_error error;
|
|
ufbx_scene *scene = ufbx_load_file(argv[1], &opts, &error);
|
|
if (!scene) {
|
|
fprintf(stderr, "Failed to load scene: %s\n", error.description.data);
|
|
return 1;
|
|
}
|
|
|
|
if (allocator_freed) {
|
|
fprintf(stderr, "Allocator prematurely freed\n");
|
|
return 1;
|
|
}
|
|
|
|
for (uint32_t run = 0; run < 8; run++) {
|
|
std::vector<std::thread> threads;
|
|
for (size_t i = 0; i < num_threads; i++) {
|
|
threads.push_back(std::thread(worker, scene));
|
|
}
|
|
|
|
for (std::thread &thread : threads) {
|
|
thread.join();
|
|
}
|
|
|
|
int32_t delta = std::abs(atomic_count.load(std::memory_order_relaxed) - race_count);
|
|
printf("Race delta: %d\n", delta);
|
|
if (delta >= 1000) break;
|
|
}
|
|
|
|
ufbx_free_scene(scene);
|
|
|
|
if (!allocator_freed) {
|
|
fprintf(stderr, "Scene not freed\n");
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|