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

ck_barrier: Minor changes, reorganization.

Browse Source 
Switched to using fas lock. Reorganized to match existing
style.
ck_pring
Samy Al Bahra 14 years ago
parent ba3c908fc5
commit 09bfb13762
4 changed files with 50 additions and 55 deletions
Show Stats Download Patch File Download Diff File

85
include/ck_barrier.h
Unescape View File

@ -32,8 +32,8 @@
#include <ck_pr.h>
#include <ck_spinlock.h>
#ifndef CK_BARRIER_CENTRALIZED
#define CK_BARRIER_CENTRALIZED
#ifndef CK_F_BARRIER_CENTRALIZED
#define CK_F_BARRIER_CENTRALIZED
struct ck_barrier_centralized {
unsigned int value;
@ -46,7 +46,7 @@ struct ck_barrier_centralized_state {
};
typedef struct ck_barrier_centralized_state ck_barrier_centralized_state_t;
#define CK_BARRIER_CENTRALIZED_INITIALIZER {0, 0}
#define CK_BARRIER_CENTRALIZED_INITIALIZER {0, 0}
#define CK_BARRIER_CENTRALIZED_STATE_INITIALIZER {0}
CK_CC_INLINE static void
@ -70,10 +70,10 @@ ck_barrier_centralized(struct ck_barrier_centralized *barrier,
return;
}
#endif /* CK_BARRIER_CENTRALIZED */
#endif /* CK_F_BARRIER_CENTRALIZED */
#ifndef CK_BARRIER_COMBINING
#define CK_BARRIER_COMBINING
#ifndef CK_F_BARRIER_COMBINING
#define CK_F_BARRIER_COMBINING
struct ck_barrier_combining_entry {
unsigned int k;
@ -97,32 +97,32 @@ typedef struct ck_barrier_combining_state ck_barrier_combining_state_t;
struct ck_barrier_combining {
struct ck_barrier_combining_entry *root;
ck_spinlock_cas_t mutex;
ck_spinlock_fas_t mutex;
};
typedef struct ck_barrier_combining ck_barrier_combining_t;
struct ck_barrier_ct_queue {
struct ck_barrier_combining_queue {
struct ck_barrier_combining_entry *head;
struct ck_barrier_combining_entry *tail;
};
CK_CC_INLINE static void
ck_barrier_ct_queue_init(struct ck_barrier_ct_queue *queue)
ck_barrier_combining_queue_init(struct ck_barrier_combining_queue *queue)
{
queue->head = queue->tail = NULL;
return;
}
CK_CC_INLINE static void
ck_barrier_ct_queue_enqueue(struct ck_barrier_ct_queue *queue,
struct ck_barrier_combining_entry *node_value)
ck_barrier_combining_queue_enqueue(struct ck_barrier_combining_queue *queue,
struct ck_barrier_combining_entry *node_value)
{
node_value->next = NULL;
if (queue->head == NULL) {
queue->head = queue->tail = node_value;
return;
}
@ -133,7 +133,7 @@ ck_barrier_ct_queue_enqueue(struct ck_barrier_ct_queue *queue,
}
CK_CC_INLINE static struct ck_barrier_combining_entry *
ck_barrier_ct_queue_dequeue(struct ck_barrier_ct_queue *queue)
ck_barrier_combining_queue_dequeue(struct ck_barrier_combining_queue *queue)
{
struct ck_barrier_combining_entry *front = NULL;
@ -145,24 +145,17 @@ ck_barrier_ct_queue_dequeue(struct ck_barrier_ct_queue *queue)
return (front);
}
CK_CC_INLINE static bool
ck_barrier_ct_queue_is_empty(struct ck_barrier_ct_queue *queue)
{
return (queue->head == NULL);
}
CK_CC_INLINE static void
ck_barrier_combining_init(struct ck_barrier_combining *root,
struct ck_barrier_combining_entry *init_root)
{
init_root->k = 0;
init_root->count = 0;
init_root->sense = 0;
init_root->parent = init_root->lchild = init_root->rchild = NULL;
ck_spinlock_cas_init(&root->mutex);
ck_spinlock_fas_init(&root->mutex);
root->root = init_root;
return;
}
@ -171,6 +164,7 @@ ck_barrier_combining_try_insert(struct ck_barrier_combining_entry *parent,
struct ck_barrier_combining_entry *tnode,
struct ck_barrier_combining_entry **child)
{
if (*child == NULL) {
*child = tnode;
tnode->parent = parent;
@ -187,31 +181,33 @@ ck_barrier_combining_entry_init(struct ck_barrier_combining *root,
struct ck_barrier_combining_entry *tnode)
{
struct ck_barrier_combining_entry *node;
struct ck_barrier_ct_queue queue;
struct ck_barrier_combining_queue queue;
ck_barrier_ct_queue_init(&queue);
ck_barrier_combining_queue_init(&queue);
tnode->k = 1;
tnode->count = 0;
tnode->sense = 0;
tnode->lchild = tnode->rchild = NULL;
ck_spinlock_cas_lock(&root->mutex);
ck_barrier_ct_queue_enqueue(&queue, root->root);
while (!ck_barrier_ct_queue_is_empty(&queue)) {
node = ck_barrier_ct_queue_dequeue(&queue);
if (ck_barrier_combining_try_insert(node, tnode, &node->lchild) == true) {
ck_spinlock_cas_unlock(&root->mutex);
return;
}
if (ck_barrier_combining_try_insert(node, tnode, &node->rchild) == true) {
ck_spinlock_cas_unlock(&root->mutex);
return;
}
ck_barrier_ct_queue_enqueue(&queue, node->lchild);
ck_barrier_ct_queue_enqueue(&queue, node->rchild);
ck_spinlock_fas_lock(&root->mutex);
ck_barrier_combining_queue_enqueue(&queue, root->root);
while (queue.head != NULL) {
node = ck_barrier_combining_queue_dequeue(&queue);
if (ck_barrier_combining_try_insert(node, tnode, &node->lchild) == true)
goto leave;
if (ck_barrier_combining_try_insert(node, tnode, &node->rchild) == true)
goto leave;
ck_barrier_combining_queue_enqueue(&queue, node->lchild);
ck_barrier_combining_queue_enqueue(&queue, node->rchild);
}
leave:
ck_spinlock_fas_unlock(&root->mutex);
return;
}
CK_CC_INLINE static void
@ -219,6 +215,7 @@ ck_barrier_combining_aux(struct ck_barrier_combining *barrier,
struct ck_barrier_combining_entry *tnode,
unsigned int sense)
{
/* Incrementing a leaf's count is unnecessary. */
if (tnode->lchild == NULL) {
ck_barrier_combining_aux(barrier, tnode->parent, sense);
@ -229,12 +226,13 @@ ck_barrier_combining_aux(struct ck_barrier_combining *barrier,
if (ck_pr_faa_uint(&tnode->count, 1) == tnode->k - 1) {
if (tnode->parent != NULL)
ck_barrier_combining_aux(barrier, tnode->parent, sense);
ck_pr_store_uint(&tnode->count, 0);
ck_pr_store_uint(&tnode->sense, ~tnode->sense);
} else
while (sense != ck_pr_load_uint(&tnode->sense)) {
} else {
while (sense != ck_pr_load_uint(&tnode->sense))
ck_pr_stall();
}
}
return;
}
@ -247,8 +245,7 @@ ck_barrier_combining(struct ck_barrier_combining *barrier,
ck_barrier_combining_aux(barrier, tnode, state->sense);
state->sense = ~state->sense;
}
#endif /* CK_BARRIER_COMBINING */
#endif /* CK_F_BARRIER_COMBINING */
#endif /* _CK_BARRIER_H */

12
regressions/ck_barrier/validate/Makefile
Unescape View File

@ -1,17 +1,17 @@
.PHONY: clean distribution
OBJECTS=validate combining_validate
OBJECTS=ck_barrier_centralized ck_barrier_combining
all: $(OBJECTS)
validate: validate.c ../../../include/ck_barrier.h
$(CC) $(CFLAGS) -o validate validate.c -lpthread
ck_barrier_centralized: ck_barrier_centralized.c ../../../include/ck_barrier.h
$(CC) $(CFLAGS) -o ck_barrier_centralized ck_barrier_centralized.c
combining_validate: combining_validate.c ../../../include/ck_barrier.h
$(CC) $(CFLAGS) -o combining_validate combining_validate.c -lpthread
ck_barrier_combining: ck_barrier_combining.c ../../../include/ck_barrier.h
$(CC) $(CFLAGS) -o ck_barrier_combining ck_barrier_combining.c
clean:
rm -rf *.dSYM *~ *.o $(OBJECTS)
include ../../../build/regressions.build
CFLAGS+=-D_GNU_SOURCE -O0 -ggdb
CFLAGS+=-D_GNU_SOURCE -lpthread

0
regressions/ck_barrier/validate/validate.c → regressions/ck_barrier/validate/ck_barrier_centralized.c
Unescape View File

8
regressions/ck_barrier/validate/combining_validate.c → regressions/ck_barrier/validate/ck_barrier_combining.c
Unescape View File

@ -64,6 +64,8 @@ thread(void *null CK_CC_UNUSED)
int i = 0;
int counter;
aff_iterate(&a);
tnode = malloc(sizeof(ck_barrier_combining_entry_t));
if (tnode == NULL) {
fprintf(stderr, "Could not allocate thread barrier entry\n");
@ -72,8 +74,6 @@ thread(void *null CK_CC_UNUSED)
ck_barrier_combining_entry_init(&barrier, tnode);
aff_iterate(&a);
ck_pr_inc_int(&barrier_wait);
while (ck_pr_load_int(&barrier_wait) != nthr)
ck_pr_stall();
@ -89,7 +89,6 @@ thread(void *null CK_CC_UNUSED)
}
}
free(tnode);
return (NULL);
}
@ -97,8 +96,8 @@ int
main(int argc, char *argv[])
{
pthread_t *threads;
int i;
ck_barrier_combining_entry_t *init_root;
int i;
init_root = malloc(sizeof(ck_barrier_combining_entry_t));
if (init_root == NULL) {
@ -140,7 +139,6 @@ main(int argc, char *argv[])
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
free(init_root);
return (0);
}
Write Preview
Loading…
Cancel
Save