static INLINE void
abi_init(void)
{
/* thread safe */
reload:
if (ATOMIC_LOAD_ACQ(&global_abi.status) == ABI_NOT_INITIALIZED) {
if (ATOMIC_CAS_FULL(&global_abi.status, ABI_NOT_INITIALIZED, ABI_INITIALIZING) != 0) {
/* TODO temporary to be sure to use tinySTM */
printf("TinySTM-ABI v%s.\n", _ITM_libraryVersion());
atexit((void (*)(void))(_ITM_finalizeProcess));
/* TinySTM initialization */
stm_init();
mod_mem_init(0);
mod_alloc_cpp();
mod_log_init();
mod_cb_init();
ATOMIC_STORE(&global_abi.status, ABI_INITIALIZED);
/* Also initialize thread as specify in the specification */
abi_init_thread();
return;
} else {
goto reload;
}
} else if (ATOMIC_LOAD_ACQ(&global_abi.status) != ABI_INITIALIZED) {
/* Wait the end of the initialization */
goto reload;
}
return;
}
int main (int argc, char *argv[]) {
pthread_t threads[NUM_THREADS];
int rc, i;
struct tdata id[NUM_THREADS];
/* Init tinySTM */
stm_init();
for(i=0; i<NUM_THREADS; i++){
id[i].tid = i;
rc = pthread_create(&threads[i], NULL, count, (void *) &id[i]);
}
for(i=0; i<NUM_THREADS; i++){
pthread_join(threads[i], NULL);
}
printf("Counter value: %d Expected: %d\n", counter, MAX_COUNT/10);
stm_exit();
return 0;
}
int main(int argc, char **argv)
{
/* Init STM */
stm_init();
mod_mem_init(0);
/* Create transaction */
stm_init_thread();
/* Testing */
test1load(1);
test1load(0);
testnload(1, 100);
testnload(0, 100);
testnloadnstore(100, 20);
testnloadnstore(100, 20);
/* Free transaction */
stm_exit_thread();
/* Cleanup STM */
stm_exit();
return 0;
}
int main(int argc, char **argv)
{
struct option long_options[] = {
// These options don't set a flag
{"help", no_argument, NULL, 'h'},
{"contention-manager", required_argument, NULL, 'c'},
{"duration", required_argument, NULL, 'd'},
{"irrevocable-percent", required_argument, NULL, 'i'},
{"num-threads", required_argument, NULL, 'n'},
{NULL, 0, NULL, 0}
};
int i, c;
unsigned long aborts, aborts_1, aborts_2,
aborts_locked_read, aborts_locked_write,
aborts_validate_read, aborts_validate_write, aborts_validate_commit,
aborts_invalid_memory, aborts_killed,
locked_reads_ok, locked_reads_failed, max_retries;
thread_data_t *td;
pthread_t *threads;
pthread_attr_t attr;
struct timespec timeout;
int duration = DEFAULT_DURATION;
int irrevocable_percent = DEFAULT_IRREVOCABLE_PERCENT;
int nb_threads = DEFAULT_NB_THREADS;
char *cm = NULL;
while(1) {
i = 0;
c = getopt_long(argc, argv, "hc:d:i:n:", long_options, &i);
if(c == -1)
break;
if(c == 0 && long_options[i].flag == 0)
c = long_options[i].val;
switch(c) {
case 0:
/* Flag is automatically set */
break;
case 'h':
printf("irrevocability -- STM stress test "
"\n"
"Usage:\n"
" irrevocability [options...]\n"
"\n"
"Options:\n"
" -h, --help\n"
" Print this message\n"
" -c, --contention-manager <string>\n"
" Contention manager for resolving conflicts (default=suicide)\n"
" -d, --duration <int>\n"
" Test duration in milliseconds (0=infinite, default=" XSTR(DEFAULT_DURATION) ")\n"
" -i, --irrevocable-percent <int>\n"
" (default=" XSTR(DEFAULT_IRREVOCABLE_PERCENT) ")\n"
" -n, --num-threads <int>\n"
" Number of threads (default=" XSTR(DEFAULT_NB_THREADS) ")\n"
);
exit(0);
case 'c':
cm = optarg;
break;
case 'd':
duration = atoi(optarg);
break;
case 'n':
nb_threads = atoi(optarg);
break;
case 'i':
irrevocable_percent = atoi(optarg);
break;
case '?':
printf("Use -h or --help for help\n");
exit(0);
default:
exit(1);
}
}
assert(duration >= 0);
assert(nb_threads > 0);
assert(irrevocable_percent >= 0 && irrevocable_percent <= 100);
printf("CM : %s\n", (cm == NULL ? "DEFAULT" : cm));
printf("Duration : %d\n", duration);
printf("Irrevocable : %d\%%\n", irrevocable_percent);
printf("Nb threads : %d\n", nb_threads);
for (i = 0; i < NB_ELEMENTS; i++)
data[i] = 0;
/* Init STM */
printf("Initializing STM\n");
stm_init();
/* Set contention manager */
if (cm != NULL) {
if (stm_set_parameter("cm_policy", cm) == 0)
printf("WARNING: cannot set contention manager \"%s\"\n", cm);
}
printf("int/long/ptr/word size: %d/%d/%d/%d\n",
(int)sizeof(int),
(int)sizeof(long),
(int)sizeof(void *),
(int)sizeof(stm_word_t));
stop = 0;
printf("TESTING CONCURRENT UPDATES...\n");
timeout.tv_sec = duration / 1000;
timeout.tv_nsec = (duration % 1000) * 1000000;
if ((td = (thread_data_t *)malloc(nb_threads * sizeof(thread_data_t))) == NULL) {
perror("malloc");
exit(1);
}
if ((threads = (pthread_t *)malloc(nb_threads * sizeof(pthread_t))) == NULL) {
perror("malloc");
exit(1);
}
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
for (i = 0; i < nb_threads; i++) {
td[i].nb_aborts = 0;
td[i].nb_aborts_1 = 0;
td[i].nb_aborts_2 = 0;
td[i].nb_aborts_locked_read = 0;
td[i].nb_aborts_locked_write = 0;
td[i].nb_aborts_validate_read = 0;
td[i].nb_aborts_validate_write = 0;
td[i].nb_aborts_validate_commit = 0;
td[i].nb_aborts_invalid_memory = 0;
td[i].nb_aborts_killed = 0;
td[i].locked_reads_ok = 0;
td[i].locked_reads_failed = 0;
td[i].max_retries = 0;
td[i].irrevocable_percent = irrevocable_percent;
if (pthread_create(&threads[i], &attr, test, (void *)(&td[i])) != 0) {
fprintf(stderr, "Error creating thread\n");
exit(1);
}
}
pthread_attr_destroy(&attr);
nanosleep(&timeout, NULL);
printf("STOPPING...\n");
stop = 1;
for (i = 0; i < nb_threads; i++) {
if (pthread_join(threads[i], NULL) != 0) {
fprintf(stderr, "Error waiting for thread completion\n");
exit(1);
}
}
printf("PASSED\n");
printf("Number of successful irrevocable-serial executions : %ld\n", nb_irrevocable_serial);
printf("Number of successful irrevocable-parallel executions : %ld\n", nb_irrevocable_parallel);
aborts = 0;
aborts_1 = 0;
aborts_2 = 0;
aborts_locked_read = 0;
aborts_locked_write = 0;
aborts_validate_read = 0;
aborts_validate_write = 0;
aborts_validate_commit = 0;
aborts_invalid_memory = 0;
aborts_killed = 0;
locked_reads_ok = 0;
locked_reads_failed = 0;
max_retries = 0;
for (i = 0; i < nb_threads; i++) {
printf("Thread %d\n", i);
printf(" #aborts : %lu\n", td[i].nb_aborts);
printf(" #lock-r : %lu\n", td[i].nb_aborts_locked_read);
printf(" #lock-w : %lu\n", td[i].nb_aborts_locked_write);
printf(" #val-r : %lu\n", td[i].nb_aborts_validate_read);
printf(" #val-w : %lu\n", td[i].nb_aborts_validate_write);
printf(" #val-c : %lu\n", td[i].nb_aborts_validate_commit);
printf(" #inv-mem : %lu\n", td[i].nb_aborts_invalid_memory);
printf(" #killed : %lu\n", td[i].nb_aborts_killed);
printf(" #aborts>=1 : %lu\n", td[i].nb_aborts_1);
printf(" #aborts>=2 : %lu\n", td[i].nb_aborts_2);
printf(" #lr-ok : %lu\n", td[i].locked_reads_ok);
printf(" #lr-failed : %lu\n", td[i].locked_reads_failed);
printf(" Max retries : %lu\n", td[i].max_retries);
aborts += td[i].nb_aborts;
aborts_1 += td[i].nb_aborts_1;
aborts_2 += td[i].nb_aborts_2;
aborts_locked_read += td[i].nb_aborts_locked_read;
aborts_locked_write += td[i].nb_aborts_locked_write;
aborts_validate_read += td[i].nb_aborts_validate_read;
aborts_validate_write += td[i].nb_aborts_validate_write;
aborts_validate_commit += td[i].nb_aborts_validate_commit;
aborts_invalid_memory += td[i].nb_aborts_invalid_memory;
aborts_killed += td[i].nb_aborts_killed;
locked_reads_ok += td[i].locked_reads_ok;
locked_reads_failed += td[i].locked_reads_failed;
if (max_retries < td[i].max_retries)
max_retries = td[i].max_retries;
}
printf("Duration : %d (ms)\n", duration);
printf("#aborts : %lu (%f / s)\n", aborts, aborts * 1000.0 / duration);
printf(" #lock-r : %lu (%f / s)\n", aborts_locked_read, aborts_locked_read * 1000.0 / duration);
printf(" #lock-w : %lu (%f / s)\n", aborts_locked_write, aborts_locked_write * 1000.0 / duration);
printf(" #val-r : %lu (%f / s)\n", aborts_validate_read, aborts_validate_read * 1000.0 / duration);
printf(" #val-w : %lu (%f / s)\n", aborts_validate_write, aborts_validate_write * 1000.0 / duration);
printf(" #val-c : %lu (%f / s)\n", aborts_validate_commit, aborts_validate_commit * 1000.0 / duration);
printf(" #inv-mem : %lu (%f / s)\n", aborts_invalid_memory, aborts_invalid_memory * 1000.0 / duration);
printf(" #killed : %lu (%f / s)\n", aborts_killed, aborts_killed * 1000.0 / duration);
printf("#aborts>=1 : %lu (%f / s)\n", aborts_1, aborts_1 * 1000.0 / duration);
printf("#aborts>=2 : %lu (%f / s)\n", aborts_2, aborts_2 * 1000.0 / duration);
printf("#lr-ok : %lu (%f / s)\n", locked_reads_ok, locked_reads_ok * 1000.0 / duration);
printf("#lr-failed : %lu (%f / s)\n", locked_reads_failed, locked_reads_failed * 1000.0 / duration);
printf("Max retries : %lu\n", max_retries);
/* Cleanup STM */
stm_exit();
return 0;
}