stasis-aries-wal/benchmarks/linearHashNTAMultiReader.c

128 lines
2.5 KiB
C

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stasis/transactional.h>
#include <unistd.h>
#include <pthread.h>
// if we're using linux's crazy version of the pthread header,
// it probably forgot to include PTHREAD_STACK_MIN
#ifndef PTHREAD_STACK_MIN
#include <limits.h>
#endif
int i = 0;
int max_active = 0;
pthread_mutex_t mutex;
//static pthread_mutex_t hash_mutex = PTHREAD_MUTEX_INITIALIZER;
static int count;
static recordid hash;
static void * go (void * arg_ptr) {
pthread_mutex_lock(&mutex);
i++;
if(i > max_active) {
max_active = i;
}
pthread_mutex_unlock(&mutex);
// pthread_mutex_lock(&hash_mutex);
int k = *(int*)arg_ptr;
int j;
int xid = Tbegin();
unsigned int seed = k;
for(j = 0; j < count ; j++) {
unsigned int r = rand_r(&seed) % 10000;
byte * tmp = NULL;
ThashLookup(xid, hash, (byte*)&r, sizeof(int), &tmp);
assert(r == *(unsigned int*)tmp);
}
// for(j = k * count; j < (k+1) *(count) ; j++) {
// TlogicalHashInsert(xid, hash, &j, sizeof(int), &j, sizeof(int));
// printf("(%d)", k);
//}
Tcommit(xid);
/*
for(j = k * count; j < (k+1) *(count) ; j++) {
int tmp = -100;
TlogicalHashLookup(xid, hash, &j, sizeof(int), &tmp, sizeof(int));
assert(j == tmp);
} */
// pthread_mutex_unlock(&hash_mutex);
pthread_mutex_lock(&mutex);
i--;
pthread_mutex_unlock(&mutex);
return NULL;
}
int main(int argc, char** argv) {
assert(argc == 3);
int thread_count = atoi(argv[1]);
count = atoi(argv[2]);
/* unlink("storefile.txt");
unlink("logfile.txt");
unlink("blob0_file.txt");
unlink("blob1_file.txt");*/
pthread_t * workers = malloc(sizeof(pthread_t) * thread_count);
Tinit();
int xid = Tbegin();
// hash = ThashCreate(xid, sizeof(int), sizeof(int));
hash = ThashCreate(xid, VARIABLE_LENGTH, VARIABLE_LENGTH);
int k;
for(k = 0; k < 20000; k++) {
ThashInsert(xid, hash, (byte*)&k, sizeof(int), (byte*)&k, sizeof(int));
}
Tcommit(xid);
/* threads have static thread sizes. Ughh. */
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_mutex_init(&mutex, NULL);
pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN);
pthread_mutex_lock(&mutex);
for(k = 0; k < thread_count; k++) {
int * k_copy = malloc(sizeof(int));
*k_copy = k ;
pthread_create(&workers[k], &attr, go, k_copy);
}
pthread_mutex_unlock(&mutex);
for(k = 0; k < thread_count; k++) {
pthread_join(workers[k],NULL);
}
Tdeinit();
printf("Max active at once: %d\n", max_active);
}