void ctor() {
states = Allocator( sizeof(__typeof__(states[0])) * N * PADRATIO);
for ( int i = 0; i < N; i += 1 ) { // initialize shared data
states[i*PADRATIO] = ATOMIC_VAR_INIT(UNLOCKED);
} // for
turn = ATOMIC_VAR_INIT(0);
} // ctor
void mrqd_delegate_wait(void* lock,
void (*funPtr)(unsigned int, void *),
unsigned int messageSize,
void * messageAddress) {
volatile atomic_int waitVar = ATOMIC_VAR_INIT(1);
unsigned int metaDataSize = sizeof(volatile atomic_int *) +
sizeof(void (*)(unsigned int, void *));
char * buff = mrqd_delegate_or_lock(lock,
metaDataSize + messageSize);
if(buff==NULL){
funPtr(messageSize, messageAddress);
mrqd_delegate_unlock(lock);
}else{
volatile atomic_int ** waitVarPtrAddress = (volatile atomic_int **)buff;
*waitVarPtrAddress = &waitVar;
void (**funPtrAdress)(unsigned int, void *) = (void (**)(unsigned int, void *))&buff[sizeof(volatile atomic_int *)];
*funPtrAdress = funPtr;
unsigned int metaDataSize = sizeof(volatile atomic_int *) +
sizeof(void (*)(unsigned int, void *));
char * msgBuffer = (char *)messageAddress;
for(unsigned int i = metaDataSize; i < (messageSize + metaDataSize); i++){
buff[i] = msgBuffer[i - metaDataSize];
}
mrqd_close_delegate_buffer((void *)buff, mrqd_executeAndWaitCS);
while(atomic_load_explicit(&waitVar, memory_order_acquire)){
thread_yield();
}
}
}
/////////////////////////////////////////////////////////////////////////
// System Pipe Segment Code
static void
CreateSegment(
_In_ SystemPipe_t* Pipe,
_In_ SystemPipeSegment_t** Segment,
_In_ unsigned int TicketBase)
{
// Variables
SystemPipeSegment_t* Pointer;
size_t BytesToAllocate = sizeof(SystemPipeSegment_t);
int i;
// Perform the allocation
if (Pipe->Configuration & PIPE_STRUCTURED_BUFFER) {
BytesToAllocate += (sizeof(SystemPipeEntry_t) * TICKETS_PER_SEGMENT(Pipe));
}
Pointer = (SystemPipeSegment_t*)kmalloc(BytesToAllocate);
assert(Pointer != NULL);
memset((void*)Pointer, 0, BytesToAllocate);
InitializeSegmentBuffer(Pipe, &Pointer->Buffer);
Pointer->TicketBase = TicketBase;
if (Pipe->Configuration & PIPE_STRUCTURED_BUFFER) {
Pointer->ProductionSpots = ATOMIC_VAR_INIT(TICKETS_PER_SEGMENT(Pipe));
Pointer->Entries = (SystemPipeEntry_t*)((uint8_t*)Pointer + sizeof(SystemPipeSegment_t));
for (i = 0; i < TICKETS_PER_SEGMENT(Pipe); i++) {
InitializeSegmentEntry(&Pointer->Entries[i]);
}
}
*Segment = Pointer;
}
struct mutex *mutex_create(struct mutex *m, unsigned flags)
{
KOBJ_CREATE(m, flags, MT_ALLOC);
m->lock = ATOMIC_VAR_INIT(0);
m->magic = MUTEX_MAGIC;
blocklist_create(&m->blocklist, 0, "mutex");
return m;
}
static struct json *
jsonrpc_create_id(void)
{
static atomic_uint next_id = ATOMIC_VAR_INIT(0);
unsigned int id;
atomic_add(&next_id, 1, &id);
return json_integer_create(id);
}
static
void ccsynchlock_initNode(CCSynchLockNode * node){
node->requestFunction = NULL;
node->messageSize = CCSYNCH_BUFFER_SIZE + 1;
atomic_store_explicit(&node->wait, 0, memory_order_relaxed);
node->completed = false;
volatile atomic_uintptr_t tmp = ATOMIC_VAR_INIT((uintptr_t)NULL);
node->next = tmp;
}
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));
}
int main(int argc, char *argv[])
{
std::vector<std::thread> thrds;
std::atomic_int a_int = ATOMIC_VAR_INIT(0);
int raw_int = 0;
unsigned int N = std::thread::hardware_concurrency()+1;
std::cout << "Using " << N << " threads..." << std::endl;
std::generate_n(std::back_inserter(thrds), N,
[&](){return std::thread(foo, std::ref(a_int), std::ref(raw_int));});
std::for_each(thrds.begin(), thrds.end(), [](std::thread& t){ t.join(); });
std::cout << "Non-Atomic: " << raw_int << std::endl;
std::cout << "Atomic: " << a_int << std::endl;
return 0;
}
void test() {
typedef std::atomic<Tp> Atomic;
static_assert(std::is_literal_type<Atomic>::value, "");
constexpr Tp t(42);
{
constexpr Atomic a(t);
assert(a == t);
}
{
constexpr Atomic a{t};
assert(a == t);
}
{
constexpr Atomic a = ATOMIC_VAR_INIT(t);
assert(a == t);
}
}
static int atomic(void)
{
atomic_int counter = ATOMIC_VAR_INIT(0);
int value, error=0, i;
for (i = 0; i < atomic_test_count; i++) {
atomic_fetch_add(&counter, 1);
}
value = atomic_load(&counter);
value -= atomic_test_count;
if (value) {
metal_log(METAL_LOG_DEBUG, "counter mismatch, delta = %d\n", value);
error = -1;
}
return error;
}
TEST(stdatomic, atomic_fetch_sub) {
atomic_int i = ATOMIC_VAR_INIT(123);
ASSERT_EQ(123, atomic_fetch_sub(&i, 1));
ASSERT_EQ(122, atomic_fetch_sub_explicit(&i, 1, memory_order_relaxed));
ASSERT_EQ(121, atomic_load(&i));
}
#include "stdafx.h"
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <sys/types.h>
#include <sys/sem.h>
std::atomic_int isWaiting = ATOMIC_VAR_INIT(0);
std::condition_variable condVar;
std::mutex mutex;
void stepRight() {
std::unique_lock<std::mutex> lock(mutex);
for (int i = 0; i < 10; ++i) {
std::cout << "right" << std::endl;
isWaiting.fetch_add(1);
if (isWaiting.load() % 2 != 1) {
condVar.notify_one();
}
else {
condVar.wait(lock);
}
}
}
void stepLeft() {
std::unique_lock<std::mutex> lock(mutex);
for (int i = 0; i < 10; ++i) {
// atomic_signal_fence_ex.c : atomic_signal_fence() example
// -------------------------------------------------------------
#include <stdatomic.h>
// void atomic_signal_fence( memory_order order);
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <signal.h>
#include <stdatomic.h>
static_assert(ATOMIC_INT_LOCK_FREE == 2,
"atomic_int must be lock-free in the signal handler.");
atomic_int guide = ATOMIC_VAR_INIT(0),
data = ATOMIC_VAR_INIT(0);
void SIGTERM_handler(int sig)
{
if( atomic_load_explicit( &guide, memory_order_relaxed) == 1)
{
atomic_signal_fence(memory_order_acquire);
int d = atomic_load_explicit( &data, memory_order_relaxed);
assert(d == 100); // Condition fulfilled!
// ...
}
_Exit(0);
}
int main(void)
#include <arch/utils.h>
#include <interrupts.h>
#include <memory.h>
#include <assert.h>
#include <string.h>
#include <arch.h>
#include <heap.h>
#include <gdt.h>
extern void TssInstall(int GdtIndex);
GdtObject_t __GdtTableObject; // Don't make static, used in asm
static GdtDescriptor_t Descriptors[GDT_MAX_DESCRIPTORS] = { { 0 } };
static TssDescriptor_t *TssPointers[GDT_MAX_TSS] = { 0 };
static TssDescriptor_t BootTss = { 0 };
static _Atomic(int) GdtIndicer = ATOMIC_VAR_INIT(0);
static int
GdtInstallDescriptor(
_In_ uint64_t Base,
_In_ uint32_t Limit,
_In_ uint8_t Access,
_In_ uint8_t Grandularity)
{
int GdtIndex = atomic_fetch_add(&GdtIndicer, 1);
// Fill descriptor
Descriptors[GdtIndex].BaseLow = (uint16_t)(Base & 0xFFFF);
Descriptors[GdtIndex].BaseMid = (uint8_t)((Base >> 16) & 0xFF);
Descriptors[GdtIndex].BaseHigh = (uint8_t)((Base >> 24) & 0xFF);
Descriptors[GdtIndex].BaseUpper = (uint32_t)((Base >> 32) & 0xFFFFFFFF);
#include <fstream> // PZ
#include <uhd/utils/thread_priority.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/usrp/multi_usrp.hpp>
#include <uhd/device.hpp>
#include <boost/program_options.hpp>
#include <boost/format.hpp>
#include <iostream>
#include <complex>
#include <uhd/types/clock_config.hpp>
//#include <gruel/realtime.h>
#include <atomic>
extern double dummy_float;
std::atomic<int> counter = ATOMIC_VAR_INIT(0);
// The square_elements_of_array is defined in another file (normally in *.hpp file):
extern void square_elements_of_array(float data_to_harness[],int no_elements) ;
namespace po = boost::program_options;
int UHD_SAFE_MAIN(int argc, char *argv[]){
#if 0
if (!(uhd::set_thread_priority_safe(1,true))) {
std::cout << "Problem setting thread priority" << std::endl;
return 1;
};
TEST(stdatomic, atomic_fetch_xor) {
atomic_int i = ATOMIC_VAR_INIT(0x100);
ASSERT_EQ(0x100, atomic_fetch_xor(&i, 0x120));
ASSERT_EQ(0x020, atomic_fetch_xor_explicit(&i, 0x103, memory_order_relaxed));
ASSERT_EQ(0x123, atomic_load(&i));
}
#include <iostream>
#include <atomic>
#include <condition_variable>
#include <thread>
#include <chrono>
std::condition_variable cv;
std::mutex cv_m;
std::atomic<int> i = ATOMIC_VAR_INIT(0);
void waits(int idx)
{
std::unique_lock<std::mutex> lk(cv_m);
auto now = std::chrono::system_clock::now();
if(cv.wait_until(lk, now + std::chrono::milliseconds(idx*100), [](){return i == 1;}))
std::cerr << "Thread " << idx << " finished waiting. i == " << i << '\n';
else
std::cerr << "Thread " << idx << " timed out. i == " << i << '\n';
}
void signals()
{
std::this_thread::sleep_for(std::chrono::milliseconds(120));
std::cerr << "Notifying...\n";
cv.notify_all();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
i = 1;
std::cerr << "Notifying again...\n";
cv.notify_all();
}
/* VLF_FILE configuration.
*
* All of the following is protected by 'log_file_mutex', which nests inside
* pattern_rwlock. */
static struct ovs_mutex log_file_mutex = OVS_MUTEX_INITIALIZER;
static char *log_file_name OVS_GUARDED_BY(log_file_mutex);
static int log_fd OVS_GUARDED_BY(log_file_mutex) = -1;
static struct async_append *log_writer OVS_GUARDED_BY(log_file_mutex);
static bool log_async OVS_GUARDED_BY(log_file_mutex);
/* Syslog export configuration. */
static int syslog_fd OVS_GUARDED_BY(pattern_rwlock) = -1;
/* Log facility configuration. */
static atomic_int log_facility = ATOMIC_VAR_INIT(0);
/* Facility name and its value. */
struct vlog_facility {
char *name; /* Name. */
unsigned int value; /* Facility associated with 'name'. */
};
static struct vlog_facility vlog_facilities[] = {
{"kern", LOG_KERN},
{"user", LOG_USER},
{"mail", LOG_MAIL},
{"daemon", LOG_DAEMON},
{"auth", LOG_AUTH},
{"syslog", LOG_SYSLOG},
{"lpr", LOG_LPR},
{"news", LOG_NEWS},
// Copyright (c) 2016 Nuxi, https://nuxi.nl/ // // This file is distributed under a 2-clause BSD license. // See the LICENSE file for details. #include <common/pthread.h> #include <stdatomic.h> #include <stddef.h> _Atomic(struct thread_atexit *) __thread_atexit_last = ATOMIC_VAR_INIT(NULL);
/*
* Global variables
*/
int *array1;
pthread_mutex_t pmutex;
ticket_mutex_t ticketmutex;
tidex_mutex_t tidexmutex;
#define TYPE_PTHREAD_MUTEX 0
#define TYPE_TICKET_MUTEX 3
#define TYPE_TIDEX_MUTEX 5
atomic_int g_quit = ATOMIC_VAR_INIT(0);
// These two don't have to be atomic because they are set before the threads are created or read after the threads join
int g_which_lock = TYPE_PTHREAD_MUTEX;
int g_operCounters[NUM_THREADS];
static void clearOperCounters(void) {
int i;
for (i = 0; i < NUM_THREADS; i++) g_operCounters[i] = 0;
}
static void printOperationsPerSecond() {
int i;
long sum = 0;
for (i = 0; i < NUM_THREADS; i++) sum += g_operCounters[i];
printf("Operations/sec = %d\n", sum);
#include <thread>
#include <atomic>
#include <cassert>
#include <iostream>
std::atomic<bool> x = ATOMIC_VAR_INIT(false);
std::atomic<bool> y = ATOMIC_VAR_INIT(false);
std::atomic<int> z = ATOMIC_VAR_INIT(0);
void write_x()
{
// x.store(true, std::memory_order_seq_cst);
// x.store(true, std::memory_order_release);
x.store(true, std::memory_order_relaxed);
}
void write_y()
{
// y.store(true, std::memory_order_seq_cst);
// y.store(true, std::memory_order_release);
y.store(true, std::memory_order_relaxed);
}
void read_x_then_y()
{
// while (!x.load(std::memory_order_seq_cst));
// while (!x.load(std::memory_order_acquire));
while (!x.load(std::memory_order_relaxed));
// if (y.load(std::memory_order_seq_cst)) ++z;
// if (y.load(std::memory_order_acquire)) ++z;
namespace WTF {
static Variant<TextBreakIteratorICU, TextBreakIteratorPlatform> mapModeToBackingIterator(StringView string, TextBreakIterator::Mode mode, const AtomicString& locale)
{
switch (mode) {
case TextBreakIterator::Mode::Line:
return TextBreakIteratorICU(string, TextBreakIteratorICU::Mode::Line, locale.string().utf8().data());
case TextBreakIterator::Mode::Caret:
return TextBreakIteratorICU(string, TextBreakIteratorICU::Mode::Character, locale.string().utf8().data());
case TextBreakIterator::Mode::Delete:
return TextBreakIteratorICU(string, TextBreakIteratorICU::Mode::Character, locale.string().utf8().data());
default:
ASSERT_NOT_REACHED();
return TextBreakIteratorICU(string, TextBreakIteratorICU::Mode::Character, locale.string().utf8().data());
}
}
TextBreakIterator::TextBreakIterator(StringView string, Mode mode, const AtomicString& locale)
: m_backing(mapModeToBackingIterator(string, mode, locale))
, m_mode(mode)
, m_locale(locale)
{
}
// Iterator initialization
static UBreakIterator* initializeIterator(UBreakIteratorType type, const char* locale = currentTextBreakLocaleID())
{
UErrorCode openStatus = U_ZERO_ERROR;
UBreakIterator* iterator = ubrk_open(type, locale, 0, 0, &openStatus);
ASSERT_WITH_MESSAGE(U_SUCCESS(openStatus), "ICU could not open a break iterator: %s (%d)", u_errorName(openStatus), openStatus);
return iterator;
}
// Iterator text setting
static UBreakIterator* setTextForIterator(UBreakIterator& iterator, StringView string)
{
if (string.is8Bit()) {
UTextWithBuffer textLocal;
textLocal.text = UTEXT_INITIALIZER;
textLocal.text.extraSize = sizeof(textLocal.buffer);
textLocal.text.pExtra = textLocal.buffer;
UErrorCode openStatus = U_ZERO_ERROR;
UText* text = openLatin1UTextProvider(&textLocal, string.characters8(), string.length(), &openStatus);
if (U_FAILURE(openStatus)) {
LOG_ERROR("uTextOpenLatin1 failed with status %d", openStatus);
return nullptr;
}
UErrorCode setTextStatus = U_ZERO_ERROR;
ubrk_setUText(&iterator, text, &setTextStatus);
if (U_FAILURE(setTextStatus)) {
LOG_ERROR("ubrk_setUText failed with status %d", setTextStatus);
return nullptr;
}
utext_close(text);
} else {
UErrorCode setTextStatus = U_ZERO_ERROR;
ubrk_setText(&iterator, string.characters16(), string.length(), &setTextStatus);
if (U_FAILURE(setTextStatus))
return nullptr;
}
return &iterator;
}
static UBreakIterator* setContextAwareTextForIterator(UBreakIterator& iterator, StringView string, const UChar* priorContext, unsigned priorContextLength)
{
if (string.is8Bit()) {
UTextWithBuffer textLocal;
textLocal.text = UTEXT_INITIALIZER;
textLocal.text.extraSize = sizeof(textLocal.buffer);
textLocal.text.pExtra = textLocal.buffer;
UErrorCode openStatus = U_ZERO_ERROR;
UText* text = openLatin1ContextAwareUTextProvider(&textLocal, string.characters8(), string.length(), priorContext, priorContextLength, &openStatus);
if (U_FAILURE(openStatus)) {
LOG_ERROR("openLatin1ContextAwareUTextProvider failed with status %d", openStatus);
return nullptr;
}
UErrorCode setTextStatus = U_ZERO_ERROR;
ubrk_setUText(&iterator, text, &setTextStatus);
if (U_FAILURE(setTextStatus)) {
LOG_ERROR("ubrk_setUText failed with status %d", setTextStatus);
return nullptr;
}
utext_close(text);
} else {
UText textLocal = UTEXT_INITIALIZER;
UErrorCode openStatus = U_ZERO_ERROR;
UText* text = openUTF16ContextAwareUTextProvider(&textLocal, string.characters16(), string.length(), priorContext, priorContextLength, &openStatus);
if (U_FAILURE(openStatus)) {
LOG_ERROR("openUTF16ContextAwareUTextProvider failed with status %d", openStatus);
return 0;
}
UErrorCode setTextStatus = U_ZERO_ERROR;
ubrk_setUText(&iterator, text, &setTextStatus);
if (U_FAILURE(setTextStatus)) {
LOG_ERROR("ubrk_setUText failed with status %d", setTextStatus);
return nullptr;
}
utext_close(text);
}
return &iterator;
}
// Static iterators
UBreakIterator* wordBreakIterator(StringView string)
{
static UBreakIterator* staticWordBreakIterator = initializeIterator(UBRK_WORD);
if (!staticWordBreakIterator)
return nullptr;
return setTextForIterator(*staticWordBreakIterator, string);
}
UBreakIterator* sentenceBreakIterator(StringView string)
{
static UBreakIterator* staticSentenceBreakIterator = initializeIterator(UBRK_SENTENCE);
if (!staticSentenceBreakIterator)
return nullptr;
return setTextForIterator(*staticSentenceBreakIterator, string);
}
UBreakIterator* acquireLineBreakIterator(StringView string, const AtomicString& locale, const UChar* priorContext, unsigned priorContextLength, LineBreakIteratorMode mode)
{
UBreakIterator* iterator = LineBreakIteratorPool::sharedPool().take(locale, mode);
if (!iterator)
return nullptr;
return setContextAwareTextForIterator(*iterator, string, priorContext, priorContextLength);
}
void releaseLineBreakIterator(UBreakIterator* iterator)
{
ASSERT_ARG(iterator, iterator);
LineBreakIteratorPool::sharedPool().put(iterator);
}
UBreakIterator* openLineBreakIterator(const AtomicString& locale)
{
bool localeIsEmpty = locale.isEmpty();
UErrorCode openStatus = U_ZERO_ERROR;
UBreakIterator* ubrkIter = ubrk_open(UBRK_LINE, localeIsEmpty ? currentTextBreakLocaleID() : locale.string().utf8().data(), 0, 0, &openStatus);
// locale comes from a web page and it can be invalid, leading ICU
// to fail, in which case we fall back to the default locale.
if (!localeIsEmpty && U_FAILURE(openStatus)) {
openStatus = U_ZERO_ERROR;
ubrkIter = ubrk_open(UBRK_LINE, currentTextBreakLocaleID(), 0, 0, &openStatus);
}
if (U_FAILURE(openStatus)) {
LOG_ERROR("ubrk_open failed with status %d", openStatus);
return nullptr;
}
return ubrkIter;
}
void closeLineBreakIterator(UBreakIterator*& iterator)
{
UBreakIterator* ubrkIter = iterator;
ASSERT(ubrkIter);
ubrk_close(ubrkIter);
iterator = nullptr;
}
static std::atomic<UBreakIterator*> nonSharedCharacterBreakIterator = ATOMIC_VAR_INIT(nullptr);
static inline UBreakIterator* getNonSharedCharacterBreakIterator()
{
if (auto *res = nonSharedCharacterBreakIterator.exchange(nullptr, std::memory_order_acquire))
return res;
return initializeIterator(UBRK_CHARACTER);
}
static inline void cacheNonSharedCharacterBreakIterator(UBreakIterator* cacheMe)
{
if (auto *old = nonSharedCharacterBreakIterator.exchange(cacheMe, std::memory_order_release))
ubrk_close(old);
}
NonSharedCharacterBreakIterator::NonSharedCharacterBreakIterator(StringView string)
{
if ((m_iterator = getNonSharedCharacterBreakIterator()))
m_iterator = setTextForIterator(*m_iterator, string);
}
NonSharedCharacterBreakIterator::~NonSharedCharacterBreakIterator()
{
if (m_iterator)
cacheNonSharedCharacterBreakIterator(m_iterator);
}
NonSharedCharacterBreakIterator::NonSharedCharacterBreakIterator(NonSharedCharacterBreakIterator&& other)
: m_iterator(nullptr)
{
std::swap(m_iterator, other.m_iterator);
}
// Iterator implemenation.
bool isWordTextBreak(UBreakIterator* iterator)
{
int ruleStatus = ubrk_getRuleStatus(iterator);
return ruleStatus != UBRK_WORD_NONE;
}
unsigned numGraphemeClusters(StringView string)
{
unsigned stringLength = string.length();
if (!stringLength)
return 0;
// The only Latin-1 Extended Grapheme Cluster is CRLF.
if (string.is8Bit()) {
auto* characters = string.characters8();
unsigned numCRLF = 0;
for (unsigned i = 1; i < stringLength; ++i)
numCRLF += characters[i - 1] == '\r' && characters[i] == '\n';
return stringLength - numCRLF;
}
NonSharedCharacterBreakIterator iterator { string };
if (!iterator) {
ASSERT_NOT_REACHED();
return stringLength;
}
unsigned numGraphemeClusters = 0;
while (ubrk_next(iterator) != UBRK_DONE)
++numGraphemeClusters;
return numGraphemeClusters;
}
unsigned numCodeUnitsInGraphemeClusters(StringView string, unsigned numGraphemeClusters)
{
unsigned stringLength = string.length();
if (stringLength <= numGraphemeClusters)
return stringLength;
// The only Latin-1 Extended Grapheme Cluster is CRLF.
if (string.is8Bit()) {
auto* characters = string.characters8();
unsigned i, j;
for (i = 0, j = 0; i < numGraphemeClusters && j + 1 < stringLength; ++i, ++j)
j += characters[j] == '\r' && characters[j + 1] == '\n';
return j + (i < numGraphemeClusters);
}
NonSharedCharacterBreakIterator iterator { string };
if (!iterator) {
ASSERT_NOT_REACHED();
return stringLength;
}
for (unsigned i = 0; i < numGraphemeClusters; ++i) {
if (ubrk_next(iterator) == UBRK_DONE)
return stringLength;
}
return ubrk_current(iterator);
}
} // namespace WTF
EasyTreeWidgetLoader::EasyTreeWidgetLoader() : m_bDone(ATOMIC_VAR_INIT(false)), m_bInterrupt(ATOMIC_VAR_INIT(false)), m_progress(ATOMIC_VAR_INIT(0))
{
}
TEST(stdatomic, atomic_fetch_and) {
atomic_int i = ATOMIC_VAR_INIT(0x123);
ASSERT_EQ(0x123, atomic_fetch_and(&i, 0x00f));
ASSERT_EQ(0x003, atomic_fetch_and_explicit(&i, 0x2, memory_order_relaxed));
ASSERT_EQ(0x002, atomic_load(&i));
}
#include "arch/atomic.h"
#include "lpelcfg.h"
#include "decen_task.h"
#include "decen_stream.h"
#include "lpel/monitor.h"
//#define _USE_STREAM_DBG__
#ifdef _USE_STREAM_DBG__
#define STREAM_DBG printf
#else
#define STREAM_DBG //
#endif
static atomic_int stream_seq = ATOMIC_VAR_INIT(0);
/**
* Create a stream
*
* Allocate and initialize memory for a stream.
*
* @return pointer to the created stream
*/
lpel_stream_t *LpelStreamCreate(int size)
{
assert( size >= 0);
if (0==size) size = STREAM_BUFFER_SIZE;
/* allocate memory for both the stream struct and the buffer area */
lpel_stream_t *s = (lpel_stream_t *) malloc( sizeof(lpel_stream_t) );
#include <stdbool.h>
#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "ext/nets.h"
#include <libcaer/events/common.h>
#include <signal.h>
#include <stdatomic.h>
static atomic_bool globalShutdown = ATOMIC_VAR_INIT(false);
static void globalShutdownSignalHandler(int signal) {
// Simply set the running flag to false on SIGTERM and SIGINT (CTRL+C) for global shutdown.
if (signal == SIGTERM || signal == SIGINT) {
atomic_store(&globalShutdown, true);
}
}
int main(int argc, char *argv[]) {
// Install signal handler for global shutdown.
struct sigaction shutdownAction;
shutdownAction.sa_handler = &globalShutdownSignalHandler;
shutdownAction.sa_flags = 0;
sigemptyset(&shutdownAction.sa_mask);
#include <string.h>
#include <sys/types.h>
#include <android/log.h>
#include <cutils/compiler.h>
#include <cutils/properties.h>
#include <cutils/trace.h>
/**
* Maximum size of a message that can be logged to the trace buffer.
* Note this message includes a tag, the pid, and the string given as the name.
* Names should be kept short to get the most use of the trace buffer.
*/
#define ATRACE_MESSAGE_LENGTH 1024
atomic_bool atrace_is_ready = ATOMIC_VAR_INIT(false);
int atrace_marker_fd = -1;
uint64_t atrace_enabled_tags = ATRACE_TAG_NOT_READY;
static bool atrace_is_debuggable = false;
static atomic_bool atrace_is_enabled = ATOMIC_VAR_INIT(true);
static pthread_once_t atrace_once_control = PTHREAD_ONCE_INIT;
static pthread_mutex_t atrace_tags_mutex = PTHREAD_MUTEX_INITIALIZER;
// Set whether this process is debuggable, which determines whether
// application-level tracing is allowed when the ro.debuggable system property
// is not set to '1'.
void atrace_set_debuggable(bool debuggable)
{
atrace_is_debuggable = debuggable;
atrace_update_tags();
}
volatile int __kmp_init_middle = FALSE;
volatile int __kmp_init_parallel = FALSE;
#if KMP_USE_MONITOR
volatile int __kmp_init_monitor =
0; /* 1 - launched, 2 - actually started (Windows* OS only) */
#endif
volatile int __kmp_init_user_locks = FALSE;
/* list of address of allocated caches for commons */
kmp_cached_addr_t *__kmp_threadpriv_cache_list = NULL;
int __kmp_init_counter = 0;
int __kmp_root_counter = 0;
int __kmp_version = 0;
std::atomic<kmp_int32> __kmp_team_counter = ATOMIC_VAR_INIT(0);
std::atomic<kmp_int32> __kmp_task_counter = ATOMIC_VAR_INIT(0);
unsigned int __kmp_init_wait =
KMP_DEFAULT_INIT_WAIT; /* initial number of spin-tests */
unsigned int __kmp_next_wait =
KMP_DEFAULT_NEXT_WAIT; /* susequent number of spin-tests */
size_t __kmp_stksize = KMP_DEFAULT_STKSIZE;
#if KMP_USE_MONITOR
size_t __kmp_monitor_stksize = 0; // auto adjust
#endif
size_t __kmp_stkoffset = KMP_DEFAULT_STKOFFSET;
int __kmp_stkpadding = KMP_MIN_STKPADDING;
size_t __kmp_malloc_pool_incr = KMP_DEFAULT_MALLOC_POOL_INCR;
void ctor() {
assert( N == 2 );
*intents[0] = ATOMIC_VAR_INIT(DontWantIn);
*intents[1] = ATOMIC_VAR_INIT(DontWantIn);
*last = ATOMIC_VAR_INIT(0);
} // ctor
*
* Copyright (c) 2014-2019 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
#include "pthread.h" // POSIX style threads management
#include <stdatomic.h> // C11 atomic data types
#include <time.h> // Required for: clock()
// Using C11 atomics for synchronization
// NOTE: A plain bool (or any plain data type for that matter) can't be used for inter-thread synchronization
static atomic_bool dataLoaded = ATOMIC_VAR_INIT(false); // Data Loaded completion indicator
static void *LoadDataThread(void *arg); // Loading data thread function declaration
static int dataProgress = 0; // Data progress accumulator
int main(void)
{
// Initialization
//--------------------------------------------------------------------------------------
const int screenWidth = 800;
const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [core] example - loading thread");
pthread_t threadId; // Loading data thread id
