Page History

#include <stdatomic.h>
 
/*
 * Sets index to point to index of maximum element in array
 *  and value to contain maximum array value .
 */
void find_max_element(atomic_Atomic int array[], size_t *index, int *value);

/* ... */

_Atomic static atomic_int array[];

void func(void) {
  size_t index;
  int value;
  find_max_element( array, &index, &value);
  /* ... */
  if (!atomic_compare_exchange_weakstrong( array[index], &value, 0)) {
    /* Handle error */
  }
}

_Atomic #include <stdatomic.h>
#include <threads.h>
 
static atomic_int array[];
size_t index;
int value;
static mtx_t array_mutex;
int result;
ifvoid func((result void) {
  size_t index;
  int value;
  if (thrd_success != mtx_lock(&array_mutex)) == thrd_error) {
{
    /* Handle error */
  }
  find_max_element( array, &index, &value);
  /* ... */
  if (!atomic_compare_exchange_weakstrong( array[index], &value, 0)) {
    /* Handle error */
  }
  if ((resultthrd_success != mtx_unlock(&array_mutex)) == thrd_error) {
{
    /* Handle error */
  }
}

//* Hazard pointers types and structure */
 structure HPRecType {
   HP[K]:*Nodetype;
  Next:*HPRecType;
}
 
//* The header of the HPRec list */
 HeadHPRec: *HPRecType;
//* Per-thread private variables */
 rlist: listType; //* initiallyInitially empty */
 rcount: integer; //* initiallyInitially 0
 */

//* The retired node routine */
RetiredNode(node:*NodeType) {
  rlist.push(node);
  rcount++;
  if(rcount >= R)
    Scan(HeadHPRec);
}


//* The scan routine */
Scan(head:*HPRecType) {
  //* Stage Stage11: Scan HP list and insert non-null values in plist */
  plist.init();
  hprec<-head;
  while (hprec != nullNULL) {
    for (i<-0 to K-1) {
      hptr<-hprec^HP[i];
      if (hptr!= nullNULL)
        plist.insert(hptr);
    }
    hprec<-hprec^Next;
  }

  //* Stage 2: search plist */
  tmplist<-rlist.popAll();
  rcount<-0;
  node<-tmplist.pop();
  while (node != nullNULL) {
    if (plist.lookup(node)) {
      rlist.push(node);
      rcount++;
    }
    else {
      PrepareForReuse(node);
    }
    node<-tmplist.pop();
  }
  plist.free();
}

#include <glib.h>
#include <glib-object.h>
 
void queue_enqueue(Queue *q, gpointer data) {
  Node *node;
  Node *tail;
  Node *next;

  node = g_slice_new(Node);
  node->data = data;
  node->next = NULL;
  while (TRUE) {
    tail = q->tail;
    HAZARD_SET(0, tail);              ///* Mark tail as hazardous */
    if (tail != q->tail) {            ///* Check tail hasn't changed */
      continue;
    }
    next = tail->next;
    if (tail != q->tail) {
      continue;
    }
    if (next != NULL) {
      CAS(&q->tail, tail, next);
      continue;
    }
    if (CAS(&tail->next, null, node) {
      break;
    }
  }
  CAS(&q->tail, tail, node);
}


gpointer queue_dequeue(Queue *q) {
  Node *node;
  Node *head;
  Node *tail;
  Node *next;

  gpointer data;

  while (TRUE) {
    head = q->head;
    LF_HAZARD_SET(0, head);    //* Mark head as hazardous */
    if (head != q->head) {     //* Check head hasn't changed */
      continue;
    }
    tail = q->tail;
    next = head->next;
    LF_HAZARD_SET(1, next);    //* Mark next as hazardous */
    if (head != q->head) {
      continue;
    }
    if (next == NULL) {
      return NULL; //* Empty */
    }
    if (head == tail) {
      CAS(&q->tail, tail, next);
      continue;
    }
    data = next->data;
    if (CAS(&q->head, head, next)) {
      break;
    }
  }
  LF_HAZARD_UNSET(head);  /*
      // Retire head, and perform
                 * Retire head, and perform
              // reclamation if needed.
  return data;
        * reclamation if needed.
                           */
  return data;
}

#include <threads.h>
#include <glib-object.h>

typedef struct node_s {
  void *data;
  Node *next;
} Node;

typedef struct queue_s {
  Node *head;
  Node *tail;
  mtx_t mutex;
} Queue;

Queue* queue_new(void) {
  Queue *q = g_slice_new( sizeof(Queue));
  q->head = q->tail = g_slice_new0new( sizeof(Node));
  return q;
}

voidint queue_enqueue(Queue *q, gpointer data) {
  Node *node;
  Node *tail;
  Node *next;

  // *
   * Lock the queue before accessing the contents and
   * check the return code for success.
   */
  if (thrd_success != mtx_lock(&(q->mutex)));
 {
  node = g_slice_new(Node);
  node->data = data;
 return -1;  /* Indicate failure */
  } else {
    node = g_slice_new(Node);
    node->data = data;
    node->next = NULL;

    if(q->head == NULL) {
      q->head = node;
      q->tail = node;
    }
  else {
      q->tail->next = node;
      q->tail = node;
    }
    //* Unlock the mutex
   and check the return code */
    if (thrd_success != mtx_unlock(&(queue->mutex));
}

gpointer queue_dequeue(Queue *q) {
  Node *node;
  Node *tail;
  Node *next;

  mtx_lock(&(q->mutex));

) {
      return -1;  /* Indicate failure */
    }
  }
  return 0;
}

gpointer queue_dequeue(Queue *q) {
  Node *node;
  Node *head;
  Node *tail;
  Node *next;
  gpointer data;

  if (thrd_success != mtx_lock(&(q->mutex)) {
    return NULL;  /* Indicate failure */
  } else {
    head = q->head;
    tail = q->tail;
    next = head->next;
    data = next->data;
    q->head = next;

    g_slice_free(Node, head);
    if (thrd_success != mtx_unlock(&(queue->mutex))) {
      return NULL;  /* Indicate failure */
    }
  }
  return data;
}