haiwan
/
ck
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'jsridhar-dev/ck_swlock' into ck_swlock

Browse Source 
Conflicts:
	include/ck_swlock.h
	regressions/ck_swlock/validate/validate.c
ck_pring
Jaidev Sridhar 11 years ago
parent 240d30c8c4 1f03809acb
commit 8646990847
2 changed files with 236 additions and 9 deletions
Show Stats Download Patch File Download Diff File

23
include/ck_swlock.h
Unescape View File

@ -138,7 +138,14 @@ CK_CC_INLINE static void
ck_swlock_write_unlatch(ck_swlock_t *rw) ck_swlock_write_unlatch(ck_swlock_t *rw)
{ {
ck_pr_store_32(&rw->n_readers, 0); uint32_t snapshot = ck_pr_load_32(&rw->n_readers);
uint32_t delta = snapshot & CK_SWLOCK_READER_BITS;
while (ck_pr_cas_32_value(&rw->n_readers, snapshot, delta, &snapshot) == false) {
delta = snapshot & CK_SWLOCK_READER_BITS;
ck_pr_stall();
}
ck_swlock_write_unlock(rw); ck_swlock_write_unlock(rw);
return; return;
} }
@ -207,7 +214,6 @@ ck_swlock_read_lock(ck_swlock_t *rw)
CK_CC_INLINE static void CK_CC_INLINE static void
ck_swlock_read_latchlock(ck_swlock_t *rw) ck_swlock_read_latchlock(ck_swlock_t *rw)
{ {
for (;;) { for (;;) {
while (ck_pr_load_32(&rw->writer) != 0) while (ck_pr_load_32(&rw->writer) != 0)
ck_pr_stall(); ck_pr_stall();
@ -278,7 +284,7 @@ ck_swlock_recursive_write_lock(ck_swlock_recursive_t *rw)
ck_pr_store_32(&rw->rw.writer, 1); ck_pr_store_32(&rw->rw.writer, 1);
ck_pr_fence_store_load(); ck_pr_fence_store_load();
while (ck_pr_load_32(&rw->rw.n_readers) != 0) while (ck_pr_load_32(&rw->rw.n_readers) & CK_SWLOCK_READER_BITS != 0)
ck_pr_stall(); ck_pr_stall();
rw->wc++; rw->wc++;
@ -288,7 +294,6 @@ ck_swlock_recursive_write_lock(ck_swlock_recursive_t *rw)
CK_CC_INLINE static void CK_CC_INLINE static void
ck_swlock_recursive_write_latch(ck_swlock_recursive_t *rw) ck_swlock_recursive_write_latch(ck_swlock_recursive_t *rw)
{ {
ck_pr_store_32(&rw->rw.writer, 1); ck_pr_store_32(&rw->rw.writer, 1);
ck_pr_fence_store_load(); ck_pr_fence_store_load();
@ -309,7 +314,7 @@ ck_swlock_recursive_write_trylock(ck_swlock_recursive_t *rw)
ck_pr_store_32(&rw->rw.writer, 1); ck_pr_store_32(&rw->rw.writer, 1);
ck_pr_fence_store_load(); ck_pr_fence_store_load();
if (ck_pr_load_32(&rw->rw.n_readers) != 0) { if (ck_pr_load_32(&rw->rw.n_readers) & CK_SWLOCK_READER_BITS != 0) {
ck_pr_store_32(&rw->rw.writer, 0); ck_pr_store_32(&rw->rw.writer, 0);
return false; return false;
} }
@ -333,8 +338,14 @@ ck_swlock_recursive_write_unlock(ck_swlock_recursive_t *rw)
CK_CC_INLINE static void CK_CC_INLINE static void
ck_swlock_recursive_write_unlatch(ck_swlock_recursive_t *rw) ck_swlock_recursive_write_unlatch(ck_swlock_recursive_t *rw)
{ {
uint32_t snapshot = ck_pr_load_32(&rw->rw.n_readers);
uint32_t delta = snapshot & CK_SWLOCK_READER_BITS;
while (ck_pr_cas_32_value(&rw->rw.n_readers, snapshot, delta, &snapshot) == false) {
delta = snapshot & CK_SWLOCK_READER_BITS;
ck_pr_stall();
}
ck_pr_store_32(&rw->rw.n_readers, 0);
ck_swlock_recursive_write_unlock(rw); ck_swlock_recursive_write_unlock(rw);
return; return;
} }

222
regressions/ck_swlock/validate/validate.c
Unescape View File

@ -125,13 +125,222 @@ thread_recursive(void *arg)
return (NULL); return (NULL);
} }
#ifdef CK_F_PR_RTM
static void *
thread_rtm_adaptive(void *null CK_CC_UNUSED)
{
unsigned int i = ITERATE;
unsigned int l;
struct ck_elide_config config = CK_ELIDE_CONFIG_DEFAULT_INITIALIZER;
struct ck_elide_stat st = CK_ELIDE_STAT_INITIALIZER;
if (aff_iterate(&a)) {
perror("ERROR: Could not affine thread");
exit(EXIT_FAILURE);
}
while (i--) {
CK_ELIDE_LOCK_ADAPTIVE(ck_swlock_write, &st, &config, &lock);
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
l = ck_pr_load_uint(&locked);
if (l != 8) {
ck_error("ERROR [WR:%d]: %u != 2\n", __LINE__, l);
}
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
l = ck_pr_load_uint(&locked);
if (l != 0) {
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
}
CK_ELIDE_UNLOCK_ADAPTIVE(ck_swlock_write, &st, &lock);
CK_ELIDE_LOCK(ck_swlock_read, &lock);
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
ck_error("ERROR [RD:%d]: %u != 0\n", __LINE__, l);
}
}
CK_ELIDE_UNLOCK(ck_swlock_read, &lock);
}
return NULL;
}
static void *
thread_rtm_mix(void *null CK_CC_UNUSED)
{
unsigned int i = ITERATE;
unsigned int l;
if (aff_iterate(&a)) {
perror("ERROR: Could not affine thread");
exit(EXIT_FAILURE);
}
while (i--) {
if (i & 1) {
CK_ELIDE_LOCK(ck_swlock_write, &lock);
} else {
ck_swlock_write_lock(&lock);
}
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
l = ck_pr_load_uint(&locked);
if (l != 8) {
ck_error("ERROR [WR:%d]: %u != 2\n", __LINE__, l);
}
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
l = ck_pr_load_uint(&locked);
if (l != 0) {
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
}
if (i & 1) {
CK_ELIDE_UNLOCK(ck_swlock_write, &lock);
} else {
ck_swlock_write_unlock(&lock);
}
if (i & 1) {
CK_ELIDE_LOCK(ck_swlock_read, &lock);
} else {
ck_swlock_read_lock(&lock);
}
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
ck_error("ERROR [RD:%d]: %u != 0\n", __LINE__, l);
}
}
if (i & 1) {
CK_ELIDE_UNLOCK(ck_swlock_read, &lock);
} else {
ck_swlock_read_unlock(&lock);
}
}
return (NULL);
}
static void *
thread_rtm(void *null CK_CC_UNUSED)
{
unsigned int i = ITERATE;
unsigned int l;
if (aff_iterate(&a)) {
perror("ERROR: Could not affine thread");
exit(EXIT_FAILURE);
}
while (i--) {
CK_ELIDE_LOCK(ck_swlock_write, &lock);
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
ck_pr_inc_uint(&locked);
l = ck_pr_load_uint(&locked);
if (l != 8) {
ck_error("ERROR [WR:%d]: %u != 2\n", __LINE__, l);
}
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
ck_pr_dec_uint(&locked);
l = ck_pr_load_uint(&locked);
if (l != 0) {
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
}
CK_ELIDE_UNLOCK(ck_swlock_write, &lock);
CK_ELIDE_LOCK(ck_swlock_read, &lock);
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
ck_error("ERROR [RD:%d]: %u != 0\n", __LINE__, l);
}
}
CK_ELIDE_UNLOCK(ck_swlock_read, &lock);
}
return (NULL);
}
#endif /* CK_F_PR_RTM */
static void * static void *
thread(void *arg) thread(void *arg)
{ {
unsigned int i = ITERATE; unsigned int i = ITERATE;
unsigned int l; unsigned int l;
int tid = *(int *)arg; int tid = ck_pr_load_int(arg);
if (aff_iterate(&a)) { if (aff_iterate(&a)) {
perror("ERROR: Could not affine thread"); perror("ERROR: Could not affine thread");
@ -195,11 +404,12 @@ thread(void *arg)
static void static void
swlock_test(pthread_t *threads, void *(*f)(void *), const char *test) swlock_test(pthread_t *threads, void *(*f)(void *), const char *test)
{ {
int i; int i, tid[nthr];
fprintf(stderr, "Creating threads (%s)...", test); fprintf(stderr, "Creating threads (%s)...", test);
for (i = 0; i < nthr; i++) { for (i = 0; i < nthr; i++) {
if (pthread_create(&threads[i], NULL, f, &i)) { ck_pr_store_int(&tid[i], i);
if (pthread_create(&threads[i], NULL, f, &tid[i])) {
ck_error("ERROR: Could not create thread %d\n", i); ck_error("ERROR: Could not create thread %d\n", i);
} }
} }
@ -233,6 +443,12 @@ main(int argc, char *argv[])
a.delta = atoi(argv[2]); a.delta = atoi(argv[2]);
swlock_test(threads, thread, "regular"); swlock_test(threads, thread, "regular");
#ifdef CK_F_PR_RTM
swlock_test(threads, thread_rtm, "rtm");
swlock_test(threads, thread_rtm_mix, "rtm-mix");
swlock_test(threads, thread_rtm_adaptive, "rtm-adaptive");
#endif
swlock_test(threads, thread_recursive, "recursive"); swlock_test(threads, thread_recursive, "recursive");
return 0; return 0;
} }

Write Preview
Loading…
Cancel
Save