Exemplo n.º 1
0
void
_ojc_val_cleanup() {
    ojcVal	v;
    ojcVal	head;
    Bstr	bhead;
    Bstr	b;

    while (atomic_flag_test_and_set(&free_vals.busy)) {
    }
    head = free_vals.head;
    free_vals.head = NULL;
    free_vals.tail = NULL;
    atomic_flag_clear(&free_vals.busy);
    while (atomic_flag_test_and_set(&free_bstrs.busy)) {
    }
    bhead = free_bstrs.head;
    free_bstrs.head = NULL;
    free_bstrs.tail = NULL;
    atomic_flag_clear(&free_bstrs.busy);

    while (0 != head) {
	v = head;
	head = v->next;
	free(v);
    }

    while (0 != bhead) {
	b = bhead;
	bhead = b->next;
	free(b);
    }
}
Exemplo n.º 2
0
int avs_condvar_wait(avs_condvar_t *condvar,
                     avs_mutex_t *mutex,
                     avs_time_monotonic_t deadline) {
    // Precondition: mutex is locked by the current thread
    // although we can't check if it's the current thread that locked it :(
    AVS_ASSERT(atomic_flag_test_and_set(&mutex->locked),
               "attempted to use a condition variable with an unlocked mutex");

    bool use_deadline = avs_time_monotonic_valid(deadline);
    bool flag_value;
    condvar_waiter_node_t waiter;
    insert_new_waiter(condvar, &waiter);

    avs_mutex_unlock(mutex);
    do {
        flag_value = atomic_flag_test_and_set(&waiter.waiting);
    } while (flag_value
            && (!use_deadline
                    || avs_time_monotonic_before(avs_time_monotonic_now(),
                                                 deadline)));
    avs_mutex_lock(mutex);

    remove_waiter(condvar, &waiter);

    // flag_value == 0 -> it means it was cleared, so we've been woken up
    // flag_value == 1 -> it mean we haven't, so timeout occurred
    return flag_value ? AVS_CONDVAR_TIMEOUT : 0;
}
Exemplo n.º 3
0
int
main ()
{
  int b;

  if (!atomic_is_lock_free (&a))
    abort ();

  if (atomic_flag_test_and_set (&a))
    abort ();
  atomic_flag_clear_explicit (&a, memory_order_relaxed);
  if (atomic_flag_test_and_set (&a))
    abort ();
  atomic_flag_clear (&a);

  b = atomic_flag_test_and_set_explicit (&a, memory_order_seq_cst);
  if (!atomic_flag_test_and_set (&a) || b != 0)
    abort ();

  b = atomic_flag_test_and_set_explicit (&a, memory_order_acq_rel);
  if (!atomic_flag_test_and_set (&a) || b != 1)
    abort ();

  atomic_flag_clear_explicit (&a, memory_order_seq_cst);
  if (atomic_flag_test_and_set (&a))
    abort ();

  return 0;
}
Exemplo n.º 4
0
static void
test_atomic_flag(void)
{
    atomic_flag flag = ATOMIC_FLAG_INIT;
    ovs_assert(atomic_flag_test_and_set(&flag) == false);
    ovs_assert(atomic_flag_test_and_set(&flag) == true);
    atomic_flag_clear(&flag);
    ovs_assert(atomic_flag_test_and_set(&flag) == false);
}
Exemplo n.º 5
0
TEST(stdatomic, atomic_flag) {
  atomic_flag f = ATOMIC_FLAG_INIT;
  ASSERT_FALSE(atomic_flag_test_and_set(&f));
  ASSERT_TRUE(atomic_flag_test_and_set(&f));

  atomic_flag_clear(&f);

  ASSERT_FALSE(atomic_flag_test_and_set_explicit(&f, memory_order_relaxed));
  ASSERT_TRUE(atomic_flag_test_and_set_explicit(&f, memory_order_relaxed));

  atomic_flag_clear_explicit(&f, memory_order_relaxed);
  ASSERT_FALSE(atomic_flag_test_and_set_explicit(&f, memory_order_relaxed));
}
Exemplo n.º 6
0
void
_ojc_bstr_create_batch(size_t cnt, MList list) {
    Bstr	v;

    if (free_bstrs.head != free_bstrs.tail) {
	while (atomic_flag_test_and_set(&free_bstrs.busy)) {
	}
	if (free_bstrs.head != free_bstrs.tail) {
	    Bstr	prev = free_bstrs.head;

	    list->head = prev;
	    for (v = prev; 0 < cnt && v != free_bstrs.tail; cnt--, v = v->next) {
		prev = v;
	    }
	    free_bstrs.head = v;
	    list->tail = prev;
	    list->tail->next = 0;
	}
	atomic_flag_clear(&free_bstrs.busy);
    }
    for (; 0 < cnt; cnt--) {
	v = _ojc_bstr_create();
	v->next = 0;
	if (0 == list->head) {
	    list->head = v;
	} else {
	    list->tail->next = v;
	}
	list->tail = v;
    }
}
Exemplo n.º 7
0
ojcVal
_ojc_val_create(ojcValType type) {
    ojcVal	val = NULL;

    // Carelessly check to see if a new val is needed. It doesn't matter if we
    // get it wrong here.
    if (NULL == free_vals.head || free_vals.head == free_vals.tail) {
	val = (ojcVal)malloc(sizeof(struct _ojcVal));
    } else {
	// Looks like we need to lock it down for a moment using the atomic busy
	// flag.
	while (atomic_flag_test_and_set(&free_vals.busy)) {
	}
	if (NULL == free_vals.head || free_vals.head == free_vals.tail) {
	    val = (ojcVal)malloc(sizeof(struct _ojcVal));
	} else {
	    val = free_vals.head;
	    free_vals.head = free_vals.head->next;
	}
	atomic_flag_clear(&free_vals.busy);
    }
    val->next = NULL;
    val->key_type = STR_NONE;
    val->str_type = STR_NONE;
    val->members.head = NULL;
    val->members.tail = NULL;
    val->type = type;
    val->expect = NEXT_NONE;

    return val;
}
Exemplo n.º 8
0
void
_ojc_val_create_batch(size_t cnt, List vals) {
    ojcVal	v;

    if (free_vals.head != free_vals.tail) {
	while (atomic_flag_test_and_set(&free_vals.busy)) {
	}
	if (free_vals.head != free_vals.tail) {
	    ojcVal	prev = free_vals.head;

	    vals->head = prev;
	    for (v = prev; 0 < cnt && v != free_vals.tail; cnt--, v = v->next) {
		prev = v;
	    }
	    free_vals.head = v;
	    vals->tail = prev;
	    vals->tail->next = 0;
	}
	atomic_flag_clear(&free_vals.busy);
    }
    for (; 0 < cnt; cnt--) {
	v = _ojc_val_create(OJC_NULL);
	if (0 == vals->head) {
	    vals->head = v;
	} else {
	    vals->tail->next = v;
	}
	vals->tail = v;
    }
}
int main()
{
  atomic_flag af = ATOMIC_FLAG_INIT;

  if (!atomic_flag_test_and_set(&af))
    atomic_flag_clear(&af);

  return 0;
}
Exemplo n.º 10
0
TEST(stdatomic, init) {
  atomic_int v = ATOMIC_VAR_INIT(123);
  ASSERT_EQ(123, atomic_load(&v));

  atomic_init(&v, 456);
  ASSERT_EQ(456, atomic_load(&v));

  atomic_flag f = ATOMIC_FLAG_INIT;
  ASSERT_FALSE(atomic_flag_test_and_set(&f));
}
Exemplo n.º 11
0
static void spinhaltIfAlreadyExiting(void) {
#ifndef LAUNCHER
  volatile int temp;
  if (atomic_flag_test_and_set(&thisLocaleAlreadyExiting)) {
    // spin forever if somebody else already set it to 1
    temp = 1;
    while (temp);
  }
#endif
}
int main()
{
  atomic_flag f;
  atomic_flag* p = &f;
  memory_order m = memory_order_relaxed;

  // For position only.
  atomic_flag_test_and_set(p);
  atomic_flag_test_and_set_explicit(p, m);
  atomic_flag_clear(p);
  atomic_flag_clear_explicit(p, m);

  return 0;
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
0
void
_ojc_bstr_return(MList freed) {
    if (0 == freed->head) {
	return;
    }
    while (atomic_flag_test_and_set(&free_bstrs.busy)) {
    }
    if (0 == free_bstrs.head) {
	free_bstrs.head = freed->head;
    } else {
	free_bstrs.tail->next = freed->head;
    }
    free_bstrs.tail = freed->tail;
    atomic_flag_clear(&free_bstrs.busy);
}
Exemplo n.º 15
0
static void insert_new_waiter(avs_condvar_t *condvar,
                              condvar_waiter_node_t *waiter) {
    avs_mutex_lock(&condvar->waiters_mutex);

    // Initialize the waiting flag to true
    atomic_flag_clear(&waiter->waiting);
    bool value = atomic_flag_test_and_set(&waiter->waiting);
    assert(!value);
    (void) value;

    // Insert waiter as the first element on the list
    waiter->next = condvar->first_waiter;
    condvar->first_waiter = waiter;

    avs_mutex_unlock(&condvar->waiters_mutex);
}
Exemplo n.º 16
0
inline void tal_lock(lock_t* lock)
{
#ifdef WITH_POSIX_THREAD_PROCESS_SHARED
  if (pthread_mutex_lock(&(lock->mtx)) != 0) {
    fprintf(stderr, "Error: Could not lock\n");
  }
#else
#if LOCK_ROUND_ROBIN == 1
  while (lock->current_idx != fork_idx) {
    sched_yield();
  }
#else
  while (atomic_flag_test_and_set(&lock->cat)) {
    sched_yield();
  };
#endif
#endif
}
Exemplo n.º 17
0
int platform_poll(void *priv)
{
	struct remoteproc *rproc = priv;
	struct remoteproc_priv *prproc;
	unsigned int flags;

	prproc = rproc->priv;
	while(1) {
		flags = metal_irq_save_disable();
		if (!(atomic_flag_test_and_set(&prproc->ipi_nokick))) {
			metal_irq_restore_enable(flags);
			remoteproc_get_notification(rproc, RSC_NOTIFY_ID_ANY);
			break;
		}
		_rproc_wait();
		metal_irq_restore_enable(flags);
	}
	return 0;
}
Exemplo n.º 18
0
Bstr
_ojc_bstr_create() {
    Bstr	bstr;

    if (free_bstrs.head == free_bstrs.tail) {
	bstr = (Bstr)malloc(sizeof(union _Bstr));
    } else {
	while (atomic_flag_test_and_set(&free_bstrs.busy)) {
	}
	if (free_bstrs.head == free_bstrs.tail) {
	    bstr = (Bstr)malloc(sizeof(union _Bstr));
	} else {
	    bstr = free_bstrs.head;
	    free_bstrs.head = free_bstrs.head->next;
	}
	atomic_flag_clear(&free_bstrs.busy);
    }
    *bstr->ca = '\0';

    return bstr;
}
Exemplo n.º 19
0
void
_ojc_set_key(ojcVal val, const char *key, int klen) {
    struct _MList	freed_bstrs = { 0, 0 };

    free_key(val, &freed_bstrs);
    while (atomic_flag_test_and_set(&free_bstrs.busy)) {
    }
    if (0 != freed_bstrs.head) {
	if (0 == free_bstrs.head) {
	    free_bstrs.head = freed_bstrs.head;
	} else {
	    free_bstrs.tail->next = freed_bstrs.head;
	}
	free_bstrs.tail = freed_bstrs.tail;
    }
    atomic_flag_clear(&free_bstrs.busy);

    if (0 != key) {
	if (0 >= klen) {
	    klen = strlen(key);
	}
	if ((int)sizeof(union _Bstr) <= klen) {
	    val->key_type = STR_PTR;
	    val->key.str = strndup(key, klen);
	    val->key.str[klen] = '\0';
	} else if ((int)sizeof(val->key.ca) <= klen) {
	    val->key_type = STR_BLOCK;
	    val->key.bstr = _ojc_bstr_create();
	    memcpy(val->key.bstr->ca, key, klen);
	    val->key.bstr->ca[klen] = '\0';
	} else {
	    val->key_type = STR_ARRAY;
	    memcpy(val->key.ca, key, klen);
	    val->key.ca[klen] = '\0';
	}
    }
}
Exemplo n.º 20
0
void
_ojc_val_return(List freed, MList freed_bstrs) {
    if (0 == freed->head) {
	return;
    }
    while (atomic_flag_test_and_set(&free_vals.busy)) {
    }
    if (0 == free_vals.head) {
	free_vals.head = freed->head;
    } else {
	free_vals.tail->next = freed->head;
    }
    free_vals.tail = freed->tail;

    if (0 != freed_bstrs->head) {
	if (0 == free_bstrs.head) {
	    free_bstrs.head = freed_bstrs->head;
	} else {
	    free_bstrs.tail->next = freed_bstrs->head;
	}
	free_bstrs.tail = freed_bstrs->tail;
    }
    atomic_flag_clear(&free_vals.busy);
}
Exemplo n.º 21
0
///////////////////////////////////////////////////////////////////////////
// Fast spinlock implmentation. No backoff when busy
///////////////////////////////////////////////////////////////////////////
CAtomicSpinLock::CAtomicSpinLock(std::atomic_flag& lock) : m_Lock(lock)
{
  while (atomic_flag_test_and_set(&m_Lock)) {} // Lock
}