Ejemplos de atomic_flag_clear en C++ (Cpp)

Ejemplo n.º 1

Archivo: testatomics.c Proyecto: Improbus/CPEG614

int main(int argc, char** argv)
{
  atomic_flag flag;

  atomic_flag_clear(&flag);
  assert( false == atomic_flag_test_and_set(&flag) );
  assert( true == atomic_flag_test_and_set(&flag) );

  atomic_thread_fence(memory_order_seq_cst);
  atomic_signal_thread_fence(memory_order_seq_cst);

  {
    atomic_uint_least8_t tmp;
    atomic_load_uint_least8_t(&tmp);
  }
  /*
  test(uint_least8_t);
  test(uint_least16_t);
  test(uint_least32_t);
  test(uint_least64_t);
  test(uintptr_t);
  */
  return 0;
}

Ejemplo n.º 2

Archivo: flowmap.c Proyecto: rfujiyama/netmap-test

flowmap* flowmap_new(uint32_t capacity) {
  flowmap *m;
  uint64_t array_len;
  uint32_t i;

  if (!capacity)
    return NULL;

  array_len = _next_power2(capacity / 
              (FLOWMAP_FILL_RATIO * FLOWMAP_ENTRIES_PER_NODE));
  if (array_len == 0)
    return NULL;

  if (array_len > UINT32_MAX)
    return NULL;

  if (array_len < FLOWMAP_MIN_LEN)
    array_len = FLOWMAP_MIN_LEN;

  m = malloc(sizeof(*m));
  if (!m)
    return NULL;

  m->array = aligned_alloc(LEVEL1_DCACHE_LINESIZE,
                            sizeof(flowmap_node) * array_len);
  if (!m->array) {
    free(m);
    return NULL;
  }

  m->n_overflow = capacity * FLOWMAP_OVERFLOW_RATIO;
  if (m->n_overflow < 1)
    m->n_overflow = 1;

  m->overflow = calloc(m->n_overflow, sizeof(flowmap_overflow_node));
  if (!m->overflow) {
    free(m->array);
    free(m);
    return NULL;
  }

  m->capacity = capacity;
  m->array_mask = array_len - 1;
  m->elem_count = ATOMIC_VAR_INIT(0);
  m->seed = 0;
  m->hash = stafford_mix64;
  m->overflow_list_head = 0;
  m->overflow_count = 0;
  m->overflow_idx = 0;
  atomic_flag_clear(&m->overflow_lock);

  // initialize array
  memset(m->array, 0, sizeof(flowmap_node) * array_len);
  for (i=0; i < array_len; i++) {
    m->array[i].next = ATOMIC_VAR_INIT(FLOWMAP_NODE_NEXT_INITIALIZER);
  }

  // initialize overflow free list
  for (i=0; i < m->n_overflow; i++) {
    m->overflow[i].next = i+1;
  }
  m->overflow[m->n_overflow-1].next = FLOWMAP_NODE_NEXT_INITIALIZER;

  return m;
}