Semaphore test: Add overhead tests.

This commit is contained in:
Joel Linn 2020-12-23 13:36:02 -08:00
parent 95a6d4e848
commit 6267b95177
1 changed files with 130 additions and 2 deletions

View File

@ -19,6 +19,10 @@
#include "SDL.h" #include "SDL.h"
#define NUM_THREADS 10 #define NUM_THREADS 10
/* This value should be smaller than the maximum count of the */
/* semaphore implementation: */
#define NUM_OVERHEAD_OPS 10000
#define NUM_OVERHEAD_OPS_MULT 10
static SDL_sem *sem; static SDL_sem *sem;
int alive; int alive;
@ -26,6 +30,7 @@ int alive;
typedef struct Thread_State { typedef struct Thread_State {
SDL_Thread * thread; SDL_Thread * thread;
int number; int number;
SDL_bool flag;
int loop_count; int loop_count;
int content_count; int content_count;
} Thread_State; } Thread_State;
@ -57,7 +62,7 @@ ThreadFuncRealWorld(void *data)
static void static void
TestRealWorld(int init_sem) { TestRealWorld(int init_sem) {
Thread_State thread_states[NUM_THREADS]; Thread_State thread_states[NUM_THREADS] = {0};
int i; int i;
int loop_count; int loop_count;
@ -71,7 +76,6 @@ TestRealWorld(int init_sem) {
char name[64]; char name[64];
SDL_snprintf(name, sizeof (name), "Thread%u", (unsigned int) i); SDL_snprintf(name, sizeof (name), "Thread%u", (unsigned int) i);
thread_states[i].number = i; thread_states[i].number = i;
thread_states[i].loop_count = 0;
thread_states[i].thread = SDL_CreateThread(ThreadFuncRealWorld, name, (void *) &thread_states[i]); thread_states[i].thread = SDL_CreateThread(ThreadFuncRealWorld, name, (void *) &thread_states[i]);
} }
@ -119,6 +123,124 @@ TestWaitTimeout(void)
SDL_DestroySemaphore(sem); SDL_DestroySemaphore(sem);
} }
static void
TestOverheadUncontended(void)
{
Uint32 start_ticks;
Uint32 end_ticks;
Uint32 duration;
int i, j;
sem = SDL_CreateSemaphore(0);
SDL_Log("Doing %d uncontended Post/Wait operations on semaphore\n", NUM_OVERHEAD_OPS * NUM_OVERHEAD_OPS_MULT);
start_ticks = SDL_GetTicks();
for (i = 0; i < NUM_OVERHEAD_OPS_MULT; i++){
for (j = 0; j < NUM_OVERHEAD_OPS; j++) {
SDL_SemPost(sem);
}
for (j = 0; j < NUM_OVERHEAD_OPS; j++) {
SDL_SemWait(sem);
}
}
end_ticks = SDL_GetTicks();
duration = end_ticks - start_ticks;
SDL_Log("Took %d milliseconds\n\n", duration);
SDL_DestroySemaphore(sem);
}
static int SDLCALL
ThreadFuncOverheadContended(void *data)
{
Thread_State *state = (Thread_State *) data;
if (state->flag) {
while(alive) {
if (SDL_SemTryWait(sem) == SDL_MUTEX_TIMEDOUT) {
++state->content_count;
}
++state->loop_count;
}
} else {
while(alive) {
/* Timeout needed to allow check on alive flag */
if (SDL_SemWaitTimeout(sem, 50) == SDL_MUTEX_TIMEDOUT) {
++state->content_count;
}
++state->loop_count;
}
}
return 0;
}
static void
TestOverheadContended(SDL_bool try_wait)
{
Uint32 start_ticks;
Uint32 end_ticks;
Uint32 duration;
Thread_State thread_states[NUM_THREADS] = {0};
char textBuffer[1024];
int loop_count;
int content_count;
int i, j;
size_t len;
sem = SDL_CreateSemaphore(0);
SDL_Log("Doing %d contended %s operations on semaphore using %d threads\n",
NUM_OVERHEAD_OPS * NUM_OVERHEAD_OPS_MULT, try_wait ? "Post/TryWait" : "Post/WaitTimeout", NUM_THREADS);
alive = 1;
/* Create multiple threads to starve the semaphore and cause contention */
for (i = 0; i < NUM_THREADS; ++i) {
char name[64];
SDL_snprintf(name, sizeof (name), "Thread%u", (unsigned int) i);
thread_states[i].flag = try_wait;
thread_states[i].thread = SDL_CreateThread(ThreadFuncOverheadContended, name, (void *) &thread_states[i]);
}
start_ticks = SDL_GetTicks();
for (i = 0; i < NUM_OVERHEAD_OPS_MULT; i++) {
for (j = 0; j < NUM_OVERHEAD_OPS; j++) {
SDL_SemPost(sem);
}
/* Make sure threads consumed everything */
while (SDL_SemValue(sem)) { }
}
end_ticks = SDL_GetTicks();
alive = 0;
loop_count = 0;
content_count = 0;
for (i = 0; i < NUM_THREADS; ++i) {
SDL_WaitThread(thread_states[i].thread, NULL);
loop_count += thread_states[i].loop_count;
content_count += thread_states[i].content_count;
}
SDL_assert_release((loop_count - content_count) == NUM_OVERHEAD_OPS * NUM_OVERHEAD_OPS_MULT);
duration = end_ticks - start_ticks;
SDL_Log("Took %d milliseconds, threads %s %d out of %d times in total (%.2f%%)\n",
duration, try_wait ? "where contended" : "timed out", content_count,
loop_count, ((float)content_count * 100) / loop_count);
/* Print how many semaphores where consumed per thread */
SDL_snprintf(textBuffer, sizeof(textBuffer), "{ ");
for (i = 0; i < NUM_THREADS; ++i) {
if (i > 0) {
len = SDL_strlen(textBuffer);
SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, ", ");
}
len = SDL_strlen(textBuffer);
SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, "%d", thread_states[i].loop_count - thread_states[i].content_count);
}
len = SDL_strlen(textBuffer);
SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, " }\n");
SDL_Log("%s\n", textBuffer);
SDL_DestroySemaphore(sem);
}
int int
main(int argc, char **argv) main(int argc, char **argv)
{ {
@ -147,6 +269,12 @@ main(int argc, char **argv)
TestWaitTimeout(); TestWaitTimeout();
TestOverheadUncontended();
TestOverheadContended(SDL_FALSE);
TestOverheadContended(SDL_TRUE);
SDL_Quit(); SDL_Quit();
return (0); return (0);
} }