#include <stdio.h>

#include <stdlib.h>

#include <memory.h>

#include <pthread.h>

#include <emscripten.h>

#include <emscripten/threading.h>

#include <assert.h>

#if !defined(__EMSCRIPTEN_PTHREADS__) || __EMSCRIPTEN_PTHREADS__ != 1

#error __EMSCRIPTEN_PTHREADS__ should have been defined to be equal to 1 when building with pthreads support enabled!

#endif

#define NUM_THREADS 8

volatile unsigned char globalUchar = 0;

volatile unsigned short globalUshort = 0;

volatile unsigned int globalUint = 0;

volatile float globalFloat = 0.0f;

volatile double globalDouble = 0.0;

volatile uint64_t globalU64 = 0;

const int N = 10;

int sharedData[N] = {};

struct Test

};

uint64_t threadCasAccumulatedWrittenData[NUM_THREADS] = {};

uint64_t threadCasAccumulatedReadData[NUM_THREADS] = {};

int rand_32()

{

return (int)(emscripten_random() * 0x3FFFFFFF);

}

void *ThreadMain(void *arg)

{

assert(pthread_self() != 0);

assert(globalUchar == 5);

assert(globalUshort == 5);

assert(globalUint == 5);

assert(globalFloat == 5.0f);

assert(globalDouble == 5.0);

assert(globalU64 == 5);

struct Test *t = (struct Test*)arg;

EM_ASM(Module['print']('Thread ' + $0 + ' for test ' + $1 + ': starting computation.'), t->threadId, t->op);

for(int i = 0; i < 99999; ++i)

for(int j = 0; j < N; ++j)

{

switch(t->op)

{

case 0: emscripten_atomic_add_u32(&sharedData[j], 1); break;

case 1: emscripten_atomic_sub_u32(&sharedData[j], 1); break;

case 2: emscripten_atomic_and_u32(&sharedData[j], ~(1UL << t->threadId)); break;

case 3: emscripten_atomic_or_u32(&sharedData[j], 1UL << t->threadId); break;

case 4: emscripten_atomic_xor_u32(&sharedData[j], 1UL << t->threadId); break;

case 5:

{

// Atomically load and store data, and test that each individual u8 is the same.

int data = emscripten_atomic_load_u32(&sharedData[j]);

uint8_t dataU8[4];

memcpy(dataU8, &data, 4);

assert(dataU8[0] >= 10 && dataU8[0] < 10+NUM_THREADS);

assert(dataU8[0] == dataU8[1] && dataU8[0] == dataU8[2] && dataU8[0] == dataU8[3]);

dataU8[0] = dataU8[1] = dataU8[2] = dataU8[3] = 10 + t->threadId;

memcpy(&data, dataU8, 4);

emscripten_atomic_store_u32(&sharedData[j], data);

}

break;

case 6:

{

int newData = rand_32();

int data;

int prevData;

do {

data = emscripten_atomic_load_u32(&sharedData[j]);

prevData = emscripten_atomic_cas_u32(&sharedData[j], data, newData);

} while(prevData != data);

threadCasAccumulatedReadData[t->threadId] += data;

threadCasAccumulatedWrittenData[t->threadId] += newData;

}

break;

}

}

EM_ASM(Module['print']('Thread ' + $0 + ' for test ' + $1 + ': finished, exit()ing.'), t->threadId, t->op);

pthread_exit(0);

}

struct Test t[NUM_THREADS] = {};

pthread_t thread[NUM_THREADS];

void RunTest(int test)

}

int main()

}