From b187ac9551e2c3ef5edc0aba17c2edf44bba7266 Mon Sep 17 00:00:00 2001 From: Sam Clegg Date: Fri, 9 Feb 2024 01:56:32 -0800 Subject: [PATCH] [test] Remove some unnecessary usage of TOTAL_MEMORY and INITIAL_MEMORY. NFC --- test/pthread/test_pthread_sbrk.cpp | 68 +++++++++++++++++------------- test/test_browser.py | 8 ++-- 2 files changed, 43 insertions(+), 33 deletions(-) diff --git a/test/pthread/test_pthread_sbrk.cpp b/test/pthread/test_pthread_sbrk.cpp index d06f6c906ee4..04a7cc96f925 100644 --- a/test/pthread/test_pthread_sbrk.cpp +++ b/test/pthread/test_pthread_sbrk.cpp @@ -14,17 +14,20 @@ #define NUM_THREADS 8 #define NUM_ALLOCATIONS 10240 #if ABORTING_MALLOC -#define ALLOCATION_SIZE 1280 // Malloc aborts, so allocate a bit less of memory so all fits +// Malloc aborts, so allocate a bit less of memory so all fits +#define ALLOCATION_SIZE 1280 #else -#define ALLOCATION_SIZE 2560 // Malloc doesn't abort, allocate a bit more memory to test graceful allocation failures +// Malloc doesn't abort, allocate a bit more memory to test graceful allocation +// failures +#define ALLOCATION_SIZE 2560 #endif #define RESULT_OK 0 #define RESULT_EXPECTED_FAILS 1 #define RESULT_BAD_FAIL 2 -// Use barriers to make each thread synchronize their execution points, to maximize the possibility of seeing race conditions -// if those might occur. +// Use barriers to make each thread synchronize their execution points, to +// maximize the possibility of seeing race conditions if those might occur. static pthread_barrier_t barrierWaitToAlloc; static pthread_barrier_t barrierWaitToVerify; static pthread_barrier_t barrierWaitToFree; @@ -32,8 +35,7 @@ static pthread_barrier_t barrierWaitToFree; // Use a mutex for logging. static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; -static void *thread_start(void *arg) -{ +static void *thread_start(void *arg) { #if DEBUG pthread_mutex_lock( &mutex ); printf("thread started, will try %d allocations of size %d\n", NUM_ALLOCATIONS, ALLOCATION_SIZE); @@ -48,47 +50,57 @@ static void *thread_start(void *arg) int some_allocations_failed = 0; size_t allocated = 0; - pthread_barrier_wait(&barrierWaitToAlloc); // Halt until all threads reach here, then proceed synchronously. - for(int i = 0; i < NUM_ALLOCATIONS; ++i) - { + // Halt until all threads reach here, then proceed synchronously. + pthread_barrier_wait(&barrierWaitToAlloc); + for (int i = 0; i < NUM_ALLOCATIONS; ++i) { allocated_buffers[i] = (uint8_t*)malloc(ALLOCATION_SIZE); if (allocated_buffers[i]) { memset(allocated_buffers[i], id, ALLOCATION_SIZE); allocated += ALLOCATION_SIZE; - } else + } else { some_allocations_failed = 1; + } } #if DEBUG pthread_mutex_lock( &mutex ); printf("total allocations: %u (%d of size %d tried), some failed? %d\n", allocated, NUM_ALLOCATIONS, ALLOCATION_SIZE, some_allocations_failed); pthread_mutex_unlock( &mutex ); #endif - pthread_barrier_wait(&barrierWaitToVerify); // Halt until all threads reach here, then proceed synchronously. + // Halt until all threads reach here, then proceed synchronously. + pthread_barrier_wait(&barrierWaitToVerify); int reported_once = 0; - for(int i = 0; i < NUM_ALLOCATIONS; ++i) - { + for (int i = 0; i < NUM_ALLOCATIONS; ++i) { if (!allocated_buffers[i]) continue; - for(int j = 0; j < ALLOCATION_SIZE; ++j) - if (allocated_buffers[i][j] != id) - { - ++return_code; // Failed! (but run to completion so that the barriers will all properly proceed without hanging) + for (int j = 0; j < ALLOCATION_SIZE; ++j) + if (allocated_buffers[i][j] != id) { + // Failed! (but run to completion so that the barriers will all properly + // proceed without hanging) + ++return_code; if (!reported_once) { emscripten_errf("Memory corrupted! mem[i]: %d != %ld, i: %d, j: %d", allocated_buffers[i][j], id, i, j); - reported_once = 1; // Avoid print flood that makes debugging hard. + // Avoid print flood that makes debugging hard. + reported_once = 1; } } } pthread_barrier_wait(&barrierWaitToFree); // Halt until all threads reach here, then proceed synchronously. - for(int i = 0; i < NUM_ALLOCATIONS; ++i) + for (int i = 0; i < NUM_ALLOCATIONS; ++i) { free(allocated_buffers[i]); + } #if ABORTING_MALLOC - if (some_allocations_failed) - return_code = RESULT_BAD_FAIL; // We expect allocations not to fail (if they did, shouldn't reach here, but we should have aborted) + if (some_allocations_failed) { + // We expect allocations not to fail (if they did, shouldn't reach here, but + // we should have aborted) + return_code = RESULT_BAD_FAIL; + } #else - if (some_allocations_failed) - return_code = RESULT_EXPECTED_FAILS; // We expect to be allocating so much memory that some of the allocations fail. + if (some_allocations_failed) { + // We expect to be allocating so much memory that some of the allocations + // fail. + return_code = RESULT_EXPECTED_FAILS; + } // Otherwise, the fails might happen in another thread, that's cool. #endif #if DEBUG @@ -99,8 +111,7 @@ static void *thread_start(void *arg) pthread_exit((void*)return_code); } -int main() -{ +int main() { printf("starting test, aborting? %d\n", ABORTING_MALLOC); int ret = pthread_barrier_init(&barrierWaitToAlloc, NULL, NUM_THREADS); @@ -110,9 +121,8 @@ int main() ret = pthread_barrier_init(&barrierWaitToFree, NULL, NUM_THREADS); assert(ret == 0); - pthread_t thr[8/*NUM_THREADS*/]; - for(intptr_t i = 0; i < NUM_THREADS; ++i) - { + pthread_t thr[NUM_THREADS]; + for (intptr_t i = 0; i < NUM_THREADS; ++i) { pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setstacksize(&attr, NUM_ALLOCATIONS*80); @@ -122,7 +132,7 @@ int main() int seen_expected_fails = 0; - for(int i = 0; i < NUM_THREADS; ++i) { + for (int i = 0; i < NUM_THREADS; ++i) { int res = 0; ret = pthread_join(thr[i], (void**)&res); assert(ret == 0); diff --git a/test/test_browser.py b/test/test_browser.py index 8fb6550edd29..e7bb32ae1610 100644 --- a/test/test_browser.py +++ b/test/test_browser.py @@ -3880,17 +3880,17 @@ def prep_no_SAB(self): @requires_threads def test_pthread_c11_threads(self): self.btest_exit('pthread/test_pthread_c11_threads.c', - args=['-gsource-map', '-std=gnu11', '-pthread', '-sPROXY_TO_PTHREAD', '-sTOTAL_MEMORY=64mb']) + args=['-gsource-map', '-std=gnu11', '-pthread', '-sPROXY_TO_PTHREAD']) @requires_threads def test_pthread_pool_size_strict(self): # Check that it doesn't fail with sufficient number of threads in the pool. self.btest_exit('pthread/test_pthread_c11_threads.c', - args=['-g2', '-std=gnu11', '-pthread', '-sPTHREAD_POOL_SIZE=4', '-sPTHREAD_POOL_SIZE_STRICT=2', '-sTOTAL_MEMORY=64mb']) + args=['-g2', '-std=gnu11', '-pthread', '-sPTHREAD_POOL_SIZE=4', '-sPTHREAD_POOL_SIZE_STRICT=2']) # Check that it fails instead of deadlocking on insufficient number of threads in the pool. self.btest('pthread/test_pthread_c11_threads.c', expected='abort:Assertion failed: thrd_create(&t4, thread_main, NULL) == thrd_success', - args=['-g2', '-std=gnu11', '-pthread', '-sPTHREAD_POOL_SIZE=3', '-sPTHREAD_POOL_SIZE_STRICT=2', '-sTOTAL_MEMORY=64mb']) + args=['-g2', '-std=gnu11', '-pthread', '-sPTHREAD_POOL_SIZE=3', '-sPTHREAD_POOL_SIZE_STRICT=2']) @requires_threads def test_pthread_in_pthread_pool_size_strict(self): @@ -3911,7 +3911,7 @@ def test_pthread_atomics(self, args): # Test 64-bit atomics. @requires_threads def test_pthread_64bit_atomics(self): - self.btest_exit('pthread/test_pthread_64bit_atomics.c', args=['-sINITIAL_MEMORY=64MB', '-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8']) + self.btest_exit('pthread/test_pthread_64bit_atomics.c', args=['-O3', '-pthread', '-sPTHREAD_POOL_SIZE=8']) # Test 64-bit C++11 atomics. @parameterized({