#include "db_config.h"
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
#include <pthread.h>
#endif
#include "db_int.h"
void exec_proc();
void tm_file_init();
void map_file();
void run_proc();
void *run_thread();
void *run_thread_wake();
void tm_mutex_destroy();
void tm_mutex_init();
void tm_mutex_stats();
void unmap_file();
#define MUTEX_WAKEME 0x80
DB_ENV dbenv;
size_t len;
int align;
int quit;
char *file = "mutex.file";
int maxlocks = 20;
int nlocks = 10000;
int nprocs = 20;
int child;
int nthreads = 1;
int verbose;
int
main(argc, argv)
int argc;
char *argv[];
{
extern int optind;
extern char *optarg;
pid_t pid;
int ch, eval, i, status;
char *tmpath;
tmpath = argv[0];
while ((ch = getopt(argc, argv, "l:n:p:st:v")) != EOF)
switch(ch) {
case 'l':
maxlocks = atoi(optarg);
break;
case 'n':
nlocks = atoi(optarg);
break;
case 'p':
nprocs = atoi(optarg);
break;
case 's':
child = 1;
break;
case 't':
nthreads = atoi(optarg);
#if !defined(HAVE_MUTEX_PTHREADS) && !defined(BUILD_PTHREADS_ANYWAY)
if (nthreads != 1) {
(void)fprintf(stderr,
"tm: pthreads not available or not compiled for this platform.\n");
return (EXIT_FAILURE);
}
#endif
break;
case 'v':
verbose = 1;
break;
case '?':
default:
(void)fprintf(stderr,
"usage: tm [-v] [-l maxlocks] [-n locks] [-p procs] [-t threads]\n");
return (EXIT_FAILURE);
}
argc -= optind;
argv += optind;
align = ALIGN(sizeof(DB_MUTEX) * 2, MUTEX_ALIGN);
len =
align * (1 + nthreads + maxlocks) + sizeof(u_long) * maxlocks * 2;
printf(
"mutex alignment %d, structure alignment %d, backing file %lu bytes\n",
MUTEX_ALIGN, align, (u_long)len);
if (child) {
run_proc();
return (EXIT_SUCCESS);
}
tm_file_init();
tm_mutex_init();
printf(
"%d proc, %d threads/proc, %d lock requests from %d locks:\n",
nprocs, nthreads, nlocks, maxlocks);
for (i = 0; i < nprocs; ++i)
switch (fork()) {
case -1:
perror("fork");
return (EXIT_FAILURE);
case 0:
exec_proc(tmpath);
break;
default:
break;
}
eval = EXIT_SUCCESS;
while ((pid = wait(&status)) != (pid_t)-1) {
fprintf(stderr,
"%lu: exited %d\n", (u_long)pid, WEXITSTATUS(status));
if (WEXITSTATUS(status) != 0)
eval = EXIT_FAILURE;
}
tm_mutex_stats();
tm_mutex_destroy();
printf("tm: exit status: %s\n",
eval == EXIT_SUCCESS ? "success" : "failed!");
return (eval);
}
void
exec_proc(tmpath)
char *tmpath;
{
char *argv[10], **ap, b_l[10], b_n[10], b_t[10];
ap = &argv[0];
*ap++ = "tm";
sprintf(b_l, "-l%d", maxlocks);
*ap++ = b_l;
sprintf(b_n, "-n%d", nlocks);
*ap++ = b_n;
*ap++ = "-s";
sprintf(b_t, "-t%d", nthreads);
*ap++ = b_t;
if (verbose)
*ap++ = "-v";
*ap = NULL;
execvp(tmpath, argv);
fprintf(stderr, "%s: %s\n", tmpath, strerror(errno));
exit(EXIT_FAILURE);
}
void
run_proc()
{
#if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
pthread_t *kidsp, wakep;
int i, status;
void *retp;
#endif
__os_sleep(&dbenv, 3, 0);
srand((u_int)time(NULL) / getpid());
if (nthreads == 1)
exit((int)run_thread((void *)0));
#if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
if ((kidsp =
(pthread_t *)calloc(sizeof(pthread_t), nthreads)) == NULL) {
fprintf(stderr, "tm: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
for (i = 0; i < nthreads; i++)
if ((errno = pthread_create(
&kidsp[i], NULL, run_thread, (void *)i)) != 0) {
fprintf(stderr, "tm: failed spawning thread %d: %s\n",
i, strerror(errno));
exit(EXIT_FAILURE);
}
if ((errno = pthread_create(
&wakep, NULL, run_thread_wake, (void *)0)) != 0) {
fprintf(stderr, "tm: failed spawning wakeup thread: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
status = 0;
for (i = 0; i < nthreads; i++) {
pthread_join(kidsp[i], &retp);
if (retp != NULL) {
fprintf(stderr,
"tm: thread %d exited with error\n", i);
status = EXIT_FAILURE;
}
}
free(kidsp);
quit = 1;
pthread_join(wakep, &retp);
if (retp != NULL) {
fprintf(stderr, "tm: wakeup thread exited with error\n");
status = EXIT_FAILURE;
}
exit(status);
#endif
}
void *
run_thread(arg)
void *arg;
{
DB_MUTEX *gm_addr, *lm_addr, *tm_addr, *mp;
u_long gid1, gid2, *id_addr;
int fd, i, lock, id, nl, remap;
id = (int)arg;
gid1 = (u_long)getpid();
#if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
gid2 = (u_long)pthread_self();
#else
gid2 = 0;
#endif
printf("\tPID: %lu; TID: %lx; ID: %d\n", gid1, gid2, id);
nl = nlocks;
for (gm_addr = NULL, remap = 0;;) {
if (gm_addr == NULL) {
map_file(&gm_addr, &tm_addr, &lm_addr, &id_addr, &fd);
remap = (rand() % 100) + 35;
}
lock = rand() % maxlocks;
mp = (DB_MUTEX *)((u_int8_t *)lm_addr + lock * align);
if (verbose)
printf("%lu/%lx: %03d\n", gid1, gid2, lock);
if (__db_mutex_lock(&dbenv, mp)) {
fprintf(stderr,
"%lu/%lx: never got lock\n", gid1, gid2);
return ((void *)EXIT_FAILURE);
}
if (id_addr[lock * 2] != 0) {
fprintf(stderr,
"RACE! (%lu/%lx granted lock %d held by %lu/%lx)\n",
gid1, gid2,
lock, id_addr[lock * 2], id_addr[lock * 2 + 1]);
return ((void *)EXIT_FAILURE);
}
id_addr[lock * 2] = gid1;
id_addr[lock * 2 + 1] = gid2;
for (i = 0; i < 3; ++i) {
__os_sleep(&dbenv, 0, rand() % 3);
if (id_addr[lock * 2] != gid1 ||
id_addr[lock * 2 + 1] != gid2) {
fprintf(stderr,
"RACE! (%lu/%lx stole lock %d from %lu/%lx)\n",
id_addr[lock * 2],
id_addr[lock * 2 + 1], lock, gid1, gid2);
return ((void *)EXIT_FAILURE);
}
}
#if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
if (__db_mutex_lock(&dbenv, gm_addr)) {
fprintf(stderr, "%lu/%lx: global lock\n", gid1, gid2);
return ((void *)EXIT_FAILURE);
}
mp = (DB_MUTEX *)((u_int8_t *)tm_addr + id * align);
F_SET(mp, MUTEX_WAKEME);
if (__db_mutex_unlock(&dbenv, gm_addr)) {
fprintf(stderr,
"%lu/%lx: per-thread wakeup failed\n", gid1, gid2);
return ((void *)EXIT_FAILURE);
}
if (__db_mutex_lock(&dbenv, mp)) {
fprintf(stderr,
"%lu/%lx: per-thread lock\n", gid1, gid2);
return ((void *)EXIT_FAILURE);
}
if (F_ISSET(mp, MUTEX_WAKEME)) {
fprintf(stderr, "%lu/%lx: %03d wakeup flag still set\n",
gid1, gid2, id);
return ((void *)EXIT_FAILURE);
}
#endif
id_addr[lock * 2] = id_addr[lock * 2 + 1] = 0;
mp = (DB_MUTEX *)((u_int8_t *)lm_addr + lock * align);
if (__db_mutex_unlock(&dbenv, mp)) {
fprintf(stderr, "%lu/%lx: wakeup failed\n", gid1, gid2);
return ((void *)EXIT_FAILURE);
}
if (--nl % 100 == 0)
fprintf(stderr, "%lu/%lx: %d\n", gid1, gid2, nl);
if (nl == 0 || --remap == 0) {
unmap_file((void *)gm_addr, fd);
gm_addr = NULL;
if (nl == 0)
break;
__os_sleep(&dbenv, rand() % 3, 0);
}
}
return (NULL);
}
#if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
void *
run_thread_wake(arg)
void *arg;
{
DB_MUTEX *gm_addr, *tm_addr, *mp;
int fd, id;
arg = NULL;
map_file(&gm_addr, &tm_addr, NULL, NULL, &fd);
while (!quit) {
id = 0;
retry: if (__db_mutex_lock(&dbenv, gm_addr)) {
fprintf(stderr, "wt: global lock failed\n");
return ((void *)EXIT_FAILURE);
}
next: mp = (DB_MUTEX *)((u_int8_t *)tm_addr + id * align);
if (F_ISSET(mp, MUTEX_WAKEME)) {
F_CLR(mp, MUTEX_WAKEME);
if (__db_mutex_unlock(&dbenv, mp)) {
fprintf(stderr, "wt: wakeup failed\n");
return ((void *)EXIT_FAILURE);
}
}
if (++id < nthreads && id % 3 != 0)
goto next;
if (__db_mutex_unlock(&dbenv, gm_addr)) {
fprintf(stderr, "wt: global unlock failed\n");
return ((void *)EXIT_FAILURE);
}
__os_sleep(&dbenv, 0, 500);
if (id < nthreads)
goto retry;
}
return (NULL);
}
#endif
void
tm_file_init()
{
int fd;
printf("Create the backing file...\n");
#ifdef HAVE_QNX
(void)shm_unlink(file);
if ((fd = shm_open(file, O_CREAT | O_RDWR | O_TRUNC,
#else
(void)remove(file);
if ((fd = open(file, O_CREAT | O_RDWR | O_TRUNC,
#endif
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) == -1) {
(void)fprintf(stderr, "%s: open: %s\n", file, strerror(errno));
exit(EXIT_FAILURE);
}
if (lseek(fd, (off_t)len, SEEK_SET) != len || write(fd, &fd, 1) != 1) {
(void)fprintf(stderr,
"%s: seek/write: %s\n", file, strerror(errno));
exit(EXIT_FAILURE);
}
(void)close(fd);
}
void
tm_mutex_init()
{
DB_MUTEX *gm_addr, *lm_addr, *mp, *tm_addr;
int fd, i;
map_file(&gm_addr, &tm_addr, &lm_addr, NULL, &fd);
printf("Initialize the global mutex...\n");
if (__db_mutex_init_int(&dbenv, gm_addr, 0, 0)) {
fprintf(stderr,
"__db_mutex_init (global): %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Initialize the per-thread mutexes...\n");
for (i = 1, mp = tm_addr;
i <= nthreads; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align)) {
if (__db_mutex_init_int(&dbenv, mp, 0, MUTEX_SELF_BLOCK)) {
fprintf(stderr, "__db_mutex_init (per-thread %d): %s\n",
i, strerror(errno));
exit(EXIT_FAILURE);
}
if (__db_mutex_lock(&dbenv, mp)) {
fprintf(stderr,
"__db_mutex_init (per-thread %d) lock: %s\n",
i, strerror(errno));
exit(EXIT_FAILURE);
}
}
printf("Initialize the per-lock mutexes...\n");
for (i = 1, mp = lm_addr;
i <= maxlocks; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align))
if (__db_mutex_init_int(&dbenv, mp, 0, 0)) {
fprintf(stderr, "__db_mutex_init (per-lock: %d): %s\n",
i, strerror(errno));
exit(EXIT_FAILURE);
}
unmap_file((void *)gm_addr, fd);
}
void
tm_mutex_destroy()
{
DB_MUTEX *gm_addr, *lm_addr, *mp, *tm_addr;
int fd, i;
map_file(&gm_addr, &tm_addr, &lm_addr, NULL, &fd);
printf("Destroy the global mutex...\n");
if (__db_mutex_destroy(gm_addr)) {
fprintf(stderr,
"__db_mutex_destroy (global): %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Destroy the per-thread mutexes...\n");
for (i = 1, mp = tm_addr;
i <= nthreads; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align)) {
if (__db_mutex_destroy(mp)) {
fprintf(stderr,
"__db_mutex_destroy (per-thread %d): %s\n",
i, strerror(errno));
exit(EXIT_FAILURE);
}
}
printf("Destroy the per-lock mutexes...\n");
for (i = 1, mp = lm_addr;
i <= maxlocks; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align))
if (__db_mutex_destroy(mp)) {
fprintf(stderr,
"__db_mutex_destroy (per-lock: %d): %s\n",
i, strerror(errno));
exit(EXIT_FAILURE);
}
unmap_file((void *)gm_addr, fd);
#ifdef HAVE_QNX
(void)shm_unlink(file);
#endif
}
void
tm_mutex_stats()
{
DB_MUTEX *gm_addr, *lm_addr, *mp;
int fd, i;
map_file(&gm_addr, NULL, &lm_addr, NULL, &fd);
printf("Per-lock mutex statistics...\n");
for (i = 1, mp = lm_addr;
i <= maxlocks; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align))
printf("mutex %2d: wait: %lu; no wait %lu\n", i,
(u_long)mp->mutex_set_wait, (u_long)mp->mutex_set_nowait);
unmap_file((void *)gm_addr, fd);
}
void
map_file(gm_addrp, tm_addrp, lm_addrp, id_addrp, fdp)
DB_MUTEX **gm_addrp, **tm_addrp, **lm_addrp;
u_long **id_addrp;
int *fdp;
{
void *maddr;
int fd;
#ifndef MAP_FAILED
#define MAP_FAILED (void *)-1
#endif
#ifndef MAP_FILE
#define MAP_FILE 0
#endif
#ifdef HAVE_QNX
if ((fd = shm_open(file, O_RDWR, 0)) == -1) {
#else
if ((fd = open(file, O_RDWR, 0)) == -1) {
#endif
fprintf(stderr, "%s: open %s\n", file, strerror(errno));
exit(EXIT_FAILURE);
}
maddr = mmap(NULL, len,
PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, fd, (off_t)0);
if (maddr == MAP_FAILED) {
fprintf(stderr, "%s: mmap: %s\n", file, strerror(errno));
exit(EXIT_FAILURE);
}
if (gm_addrp != NULL)
*gm_addrp = (DB_MUTEX *)maddr;
maddr = (u_int8_t *)maddr + align;
if (tm_addrp != NULL)
*tm_addrp = (DB_MUTEX *)maddr;
maddr = (u_int8_t *)maddr + align * nthreads;
if (lm_addrp != NULL)
*lm_addrp = (DB_MUTEX *)maddr;
maddr = (u_int8_t *)maddr + align * maxlocks;
if (id_addrp != NULL)
*id_addrp = (u_long *)maddr;
if (fdp != NULL)
*fdp = fd;
}
void
unmap_file(maddr, fd)
void *maddr;
int fd;
{
if (munmap(maddr, len) != 0) {
fprintf(stderr, "munmap: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
if (close(fd) != 0) {
fprintf(stderr, "close: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
}