diff options
Diffstat (limited to 'tests/poolTests.c')
| -rw-r--r-- | tests/poolTests.c | 193 |
1 files changed, 173 insertions, 20 deletions
diff --git a/tests/poolTests.c b/tests/poolTests.c index 00ee830154c99..9661b5299e523 100644 --- a/tests/poolTests.c +++ b/tests/poolTests.c @@ -15,11 +15,11 @@ #include <stddef.h> #include <stdio.h> -#define ASSERT_TRUE(p) \ - do { \ - if (!(p)) { \ - return 1; \ - } \ +#define ASSERT_TRUE(p) \ + do { \ + if (!(p)) { \ + return 1; \ + } \ } while (0) #define ASSERT_FALSE(p) ASSERT_TRUE(!(p)) #define ASSERT_EQ(lhs, rhs) ASSERT_TRUE((lhs) == (rhs)) @@ -32,10 +32,10 @@ struct data { void fn(void *opaque) { struct data *data = (struct data *)opaque; - pthread_mutex_lock(&data->mutex); + ZSTD_pthread_mutex_lock(&data->mutex); data->data[data->i] = data->i; ++data->i; - pthread_mutex_unlock(&data->mutex); + ZSTD_pthread_mutex_unlock(&data->mutex); } int testOrder(size_t numThreads, size_t queueSize) { @@ -43,25 +43,26 @@ int testOrder(size_t numThreads, size_t queueSize) { POOL_ctx *ctx = POOL_create(numThreads, queueSize); ASSERT_TRUE(ctx); data.i = 0; - pthread_mutex_init(&data.mutex, NULL); - { - size_t i; + ZSTD_pthread_mutex_init(&data.mutex, NULL); + { size_t i; for (i = 0; i < 16; ++i) { POOL_add(ctx, &fn, &data); } } POOL_free(ctx); ASSERT_EQ(16, data.i); - { - size_t i; + { size_t i; for (i = 0; i < data.i; ++i) { ASSERT_EQ(i, data.data[i]); } } - pthread_mutex_destroy(&data.mutex); + ZSTD_pthread_mutex_destroy(&data.mutex); return 0; } + +/* --- test deadlocks --- */ + void waitFn(void *opaque) { (void)opaque; UTIL_sleepMilli(1); @@ -72,8 +73,7 @@ int testWait(size_t numThreads, size_t queueSize) { struct data data; POOL_ctx *ctx = POOL_create(numThreads, queueSize); ASSERT_TRUE(ctx); - { - size_t i; + { size_t i; for (i = 0; i < 16; ++i) { POOL_add(ctx, &waitFn, &data); } @@ -82,25 +82,178 @@ int testWait(size_t numThreads, size_t queueSize) { return 0; } + +/* --- test POOL_resize() --- */ + +typedef struct { + ZSTD_pthread_mutex_t mut; + int val; + int max; + ZSTD_pthread_cond_t cond; +} poolTest_t; + +void waitLongFn(void *opaque) { + poolTest_t* test = (poolTest_t*) opaque; + UTIL_sleepMilli(10); + ZSTD_pthread_mutex_lock(&test->mut); + test->val = test->val + 1; + if (test->val == test->max) + ZSTD_pthread_cond_signal(&test->cond); + ZSTD_pthread_mutex_unlock(&test->mut); +} + +static int testThreadReduction_internal(POOL_ctx* ctx, poolTest_t test) +{ + int const nbWaits = 16; + UTIL_time_t startTime; + U64 time4threads, time2threads; + + test.val = 0; + test.max = nbWaits; + + startTime = UTIL_getTime(); + { int i; + for (i=0; i<nbWaits; i++) + POOL_add(ctx, &waitLongFn, &test); + } + ZSTD_pthread_mutex_lock(&test.mut); + ZSTD_pthread_cond_wait(&test.cond, &test.mut); + ASSERT_EQ(test.val, nbWaits); + ZSTD_pthread_mutex_unlock(&test.mut); + time4threads = UTIL_clockSpanNano(startTime); + + ASSERT_EQ( POOL_resize(ctx, 2/*nbThreads*/) , 0 ); + test.val = 0; + startTime = UTIL_getTime(); + { int i; + for (i=0; i<nbWaits; i++) + POOL_add(ctx, &waitLongFn, &test); + } + ZSTD_pthread_mutex_lock(&test.mut); + ZSTD_pthread_cond_wait(&test.cond, &test.mut); + ASSERT_EQ(test.val, nbWaits); + ZSTD_pthread_mutex_unlock(&test.mut); + time2threads = UTIL_clockSpanNano(startTime); + + if (time4threads >= time2threads) return 1; /* check 4 threads were effectively faster than 2 */ + return 0; +} + +static int testThreadReduction(void) { + int result; + poolTest_t test; + POOL_ctx* const ctx = POOL_create(4 /*nbThreads*/, 2 /*queueSize*/); + + ASSERT_TRUE(ctx); + + memset(&test, 0, sizeof(test)); + ASSERT_FALSE( ZSTD_pthread_mutex_init(&test.mut, NULL) ); + ASSERT_FALSE( ZSTD_pthread_cond_init(&test.cond, NULL) ); + + result = testThreadReduction_internal(ctx, test); + + ZSTD_pthread_mutex_destroy(&test.mut); + ZSTD_pthread_cond_destroy(&test.cond); + POOL_free(ctx); + + return result; +} + + +/* --- test abrupt ending --- */ + +typedef struct { + ZSTD_pthread_mutex_t mut; + int val; +} abruptEndCanary_t; + +void waitIncFn(void *opaque) { + abruptEndCanary_t* test = (abruptEndCanary_t*) opaque; + UTIL_sleepMilli(10); + ZSTD_pthread_mutex_lock(&test->mut); + test->val = test->val + 1; + ZSTD_pthread_mutex_unlock(&test->mut); +} + +static int testAbruptEnding_internal(abruptEndCanary_t test) +{ + int const nbWaits = 16; + + POOL_ctx* const ctx = POOL_create(3 /*numThreads*/, nbWaits /*queueSize*/); + ASSERT_TRUE(ctx); + test.val = 0; + + { int i; + for (i=0; i<nbWaits; i++) + POOL_add(ctx, &waitIncFn, &test); /* all jobs pushed into queue */ + } + ASSERT_EQ( POOL_resize(ctx, 1 /*numThreads*/) , 0 ); /* downsize numThreads, to try to break end condition */ + + POOL_free(ctx); /* must finish all jobs in queue before giving back control */ + ASSERT_EQ(test.val, nbWaits); + return 0; +} + +static int testAbruptEnding(void) { + int result; + abruptEndCanary_t test; + + memset(&test, 0, sizeof(test)); + ASSERT_FALSE( ZSTD_pthread_mutex_init(&test.mut, NULL) ); + + result = testAbruptEnding_internal(test); + + ZSTD_pthread_mutex_destroy(&test.mut); + return result; +} + + + +/* --- test launcher --- */ + int main(int argc, const char **argv) { size_t numThreads; + (void)argc; + (void)argv; + + if (POOL_create(0, 1)) { /* should not be possible */ + printf("FAIL: should not create POOL with 0 threads\n"); + return 1; + } + for (numThreads = 1; numThreads <= 4; ++numThreads) { size_t queueSize; for (queueSize = 0; queueSize <= 2; ++queueSize) { + printf("queueSize==%u, numThreads=%u \n", + (unsigned)queueSize, (unsigned)numThreads); if (testOrder(numThreads, queueSize)) { printf("FAIL: testOrder\n"); return 1; } + printf("SUCCESS: testOrder\n"); if (testWait(numThreads, queueSize)) { printf("FAIL: testWait\n"); return 1; } + printf("SUCCESS: testWait\n"); } } - printf("PASS: testOrder\n"); - (void)argc; - (void)argv; - return (POOL_create(0, 1)) ? printf("FAIL: testInvalid\n"), 1 - : printf("PASS: testInvalid\n"), 0; + + if (testThreadReduction()) { + printf("FAIL: thread reduction not effective \n"); + return 1; + } else { + printf("SUCCESS: thread reduction effective (slower execution) \n"); + } + + if (testAbruptEnding()) { + printf("FAIL: jobs in queue not completed on early end \n"); + return 1; + } else { + printf("SUCCESS: all jobs in queue completed on early end \n"); + } + + printf("PASS: all POOL tests\n"); + return 0; } |