pa_mutex* pa_mutex_new(pa_bool_t recursive, pa_bool_t inherit_priority) {
pa_mutex *m;
pthread_mutexattr_t attr;
int r;
pa_assert_se(pthread_mutexattr_init(&attr) == 0);
if (recursive)
pa_assert_se(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) == 0);
#ifdef HAVE_PTHREAD_PRIO_INHERIT
if (inherit_priority)
pa_assert_se(pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT) == 0);
#endif
m = pa_xnew(pa_mutex, 1);
#ifndef HAVE_PTHREAD_PRIO_INHERIT
pa_assert_se(pthread_mutex_init(&m->mutex, &attr) == 0);
#else
if ((r = pthread_mutex_init(&m->mutex, &attr))) {
/* If this failed, then this was probably due to non-available
* priority inheritance. In which case we fall back to normal
* mutexes. */
pa_assert(r == ENOTSUP && inherit_priority);
pa_assert_se(pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_NONE) == 0);
pa_assert_se(pthread_mutex_init(&m->mutex, &attr) == 0);
}
#endif
return m;
}
bool rtsafe_memory_pool_create(RtMemPool_Handle* handlePtr,
const char* poolName,
size_t dataSize,
size_t maxPreallocated)
{
assert(poolName == NULL || strlen(poolName) < RTSAFE_MEMORY_POOL_NAME_MAX);
k_list_head* nodePtr;
RtMemPool* poolPtr;
poolPtr = malloc(sizeof(RtMemPool));
if (poolPtr == NULL)
{
return false;
}
if (poolName != NULL)
{
strcpy(poolPtr->name, poolName);
}
else
{
sprintf(poolPtr->name, "%p", poolPtr);
}
poolPtr->dataSize = dataSize;
poolPtr->maxPreallocated = maxPreallocated;
INIT_LIST_HEAD(&poolPtr->used);
poolPtr->usedCount = 0;
INIT_LIST_HEAD(&poolPtr->unused);
poolPtr->unusedCount = 0;
pthread_mutexattr_t atts;
pthread_mutexattr_init(&atts);
#ifdef __ARM_ARCH_7A__
pthread_mutexattr_setprotocol(&atts, PTHREAD_PRIO_INHERIT);
#endif
pthread_mutex_init(&poolPtr->mutex, &atts);
pthread_mutexattr_destroy(&atts);
while (poolPtr->unusedCount < poolPtr->maxPreallocated)
{
nodePtr = malloc(sizeof(k_list_head) + poolPtr->dataSize);
if (nodePtr == NULL)
{
break;
}
list_add_tail(nodePtr, &poolPtr->unused);
poolPtr->unusedCount++;
}
*handlePtr = (RtMemPool_Handle)poolPtr;
return true;
}
void *
thr (void *arg)
{
int ret = 0;
pthread_mutexattr_t mutexAttr;
ret = pthread_mutexattr_init (&mutexAttr);
CHECK_RETURN_VAL_OR_FAIL (ret, "pthread_mutexattr_init");
ret = pthread_mutexattr_setprotocol (&mutexAttr, PTHREAD_PRIO_INHERIT);
CHECK_RETURN_VAL_OR_FAIL (ret, "pthread_mutexattr_setprotocol");
ret = pthread_mutex_init (&mutex, &mutexAttr);
CHECK_RETURN_VAL_OR_FAIL (ret, "pthread_mutex_init");
ret = pthread_cond_init (&cond, 0);
CHECK_RETURN_VAL_OR_FAIL (ret, "pthread_cond_init");
puts ("th: Init done, entering wait...");
pthread_cleanup_push (clean, (void *) &mutex);
ret = pthread_mutex_lock (&mutex);
CHECK_RETURN_VAL_OR_FAIL (ret, "pthread_mutex_lock");
while (1)
{
ret = pthread_cond_wait (&cond, &mutex);
CHECK_RETURN_VAL_OR_FAIL (ret, "pthread_cond_wait");
}
pthread_cleanup_pop (1);
out:
return (void *) (uintptr_t) ret;
}
int do_test(int argc, char **argv)
{
pthread_mutexattr_t mutexattr;
int retc, protocol;
#if HAS_PTHREAD_MUTEXATTR_PROTOCOL_FUNCTIONS
if (pthread_mutexattr_init(&mutexattr) != 0)
printf("Failed to init mutexattr\n");
if (pthread_mutexattr_setprotocol(&mutexattr,
PTHREAD_PRIO_INHERIT) != 0)
printf("Can't set protocol prio inherit\n");
if (pthread_mutexattr_getprotocol(&mutexattr, &protocol) != 0)
printf("Can't get mutexattr protocol\n");
else
printf("protocol in mutexattr is %d\n", protocol);
retc = pthread_mutex_init(&child_mutex, &mutexattr);
if (retc != 0)
printf("Failed to init mutex: %d\n", retc);
create_other_thread(child_thread, NULL);
join_threads();
return 0;
#else
return 1;
#endif
}
int clockobj_init(struct clockobj *clkobj,
const char *name, unsigned int resolution_ns)
{
pthread_mutexattr_t mattr;
struct timespec now;
int ret;
if (resolution_ns == 0)
return __bt(-EINVAL);
memset(clkobj, 0, sizeof(*clkobj));
ret = __clockobj_set_resolution(clkobj, resolution_ns);
if (ret)
return __bt(ret);
/*
* FIXME: this lock is only used to protect the wallclock
* offset readings from updates. We should replace this by a
* confirmed reading loop.
*/
__RT(pthread_mutexattr_init(&mattr));
__RT(pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT));
__RT(pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE));
__RT(pthread_mutex_init(&clkobj->lock, &mattr));
__RT(pthread_mutexattr_destroy(&mattr));
__RT(clock_gettime(CLOCK_COPPERPLATE, &now));
timespec_sub(&clkobj->offset, &clkobj->epoch, &now);
clkobj->name = name;
return 0;
}
/* Init a Mutex: */
int PsychInitMutex(psych_mutex* mutex)
{
int rc;
// Use mutex attributes:
pthread_mutexattr_t attr;
// Set them to default settings, except for...
pthread_mutexattr_init(&attr);
// ... priority inheritance: We absolutely want it for extra
// good realtime behaviour - Avoidance of priority inversion
// at lock contention points:
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
// Create mutex with attributes in attr:
rc = pthread_mutex_init(mutex, &attr);
if (rc != 0) {
printf("\n\nPTB-CRITICAL: PsychInitMutex(): Mutex initialization failed [%s]! Expect huge trouble and serious malfunctions!!!\n", strerror(rc));
printf("PTB-CRITICAL: PsychInitMutex(): Set a breakpoint on your debugger on pthread_mutexattr_destroy() to debug this.\n\n");
}
// Done with it:
pthread_mutexattr_destroy(&attr);
return(rc);
}
void
ags_recycling_context_init(AgsRecyclingContext *recycling_context)
{
recycling_context->flags = 0;
recycling_context->sound_scope = 0;
/* object mutex */
recycling_context->obj_mutexattr = (pthread_mutexattr_t *) malloc(sizeof(pthread_mutexattr_t));
pthread_mutexattr_init(recycling_context->obj_mutexattr);
pthread_mutexattr_settype(recycling_context->obj_mutexattr,
PTHREAD_MUTEX_RECURSIVE);
#ifdef __linux__
pthread_mutexattr_setprotocol(recycling_context->obj_mutexattr,
PTHREAD_PRIO_INHERIT);
#endif
recycling_context->obj_mutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(recycling_context->obj_mutex,
recycling_context->obj_mutexattr);
/* recall id */
recycling_context->recall_id = NULL;
/* parent and child */
recycling_context->parent = NULL;
recycling_context->children = NULL;
/* context */
recycling_context->recycling = NULL;
recycling_context->length = 0;
}
PERIODIC_THREAD_END
void mon_init(void)
{
ASSERT_ONCE();
/* open monitoring socket: */
mon_socket = scl_get_socket("ap_mon");
ASSERT_NOT_NULL(mon_socket);
int64_t hwm = 1;
zmq_setsockopt(mon_socket, ZMQ_SNDHWM, &hwm, sizeof(hwm));
/* create monitoring connection: */
const struct timespec period = {0, 20 * NSEC_PER_MSEC};
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setprotocol(&mutexattr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&mutex, &mutexattr);
/* init msgpack buffer: */
ASSERT_NULL(msgpack_buf);
msgpack_buf = msgpack_sbuffer_new();
ASSERT_NOT_NULL(msgpack_buf);
ASSERT_NULL(pk);
pk = msgpack_packer_new(msgpack_buf, msgpack_sbuffer_write);
periodic_thread_start(&emitter_thread, mon_emitter, "mon_thread", THREAD_PRIORITY, period, NULL);
}
int mutex_init(mutex_t *mutex, int type, int pi)
{
pthread_mutexattr_t mattr;
int err;
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, type);
#ifdef HAVE_PTHREAD_MUTEXATTR_SETPROTOCOL
if (pi != 0)
pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
err = pthread_mutex_init(mutex, &mattr);
#else
if (pi != 0) {
err = ENOSYS;
goto out;
}
err = pthread_mutex_init(mutex, &mattr);
out:
#endif
pthread_mutexattr_destroy(&mattr);
return -err;
}
static int
initCondAndMutex(void)
{
int status;
pthread_mutexattr_t mutexAttr;
status = pthread_mutexattr_init(&mutexAttr);
if (status) {
LOG_ERRNUM0(status, "Couldn't initialize mutex attributes");
}
else {
(void)pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
/*
* Recursive in case `termSigHandler()` and `waitUntilDone()` execute
* on the same thread
*/
(void)pthread_mutexattr_settype(&mutexAttr, PTHREAD_MUTEX_RECURSIVE);
if ((status = pthread_mutex_init(&mutex, &mutexAttr))) {
LOG_ERRNUM0(status, "Couldn't initialize mutex");
}
else {
if ((status = pthread_cond_init(&cond, NULL))) {
LOG_ERRNUM0(status, "Couldn't initialize condition variable");
(void)pthread_mutex_destroy(&mutex);
}
}
(void)pthread_mutexattr_destroy(&mutexAttr);
} // `mutexAttr` initialized
return status;
}
int main()
{
pthread_mutexattr_t mta;
int protocol = INVALID_PROTOCOL;
int ret;
/* Initialize a mutex attributes object */
if (pthread_mutexattr_init(&mta) != 0)
{
perror("Error at pthread_mutexattr_init()\n");
return PTS_UNRESOLVED;
}
while (protocol == PTHREAD_PRIO_NONE || protocol == PTHREAD_PRIO_INHERIT
|| protocol == PTHREAD_PRIO_PROTECT) {
protocol--;
}
/* Set the protocol to an invalid value. */
ret = pthread_mutexattr_setprotocol(&mta,protocol);
if ((ret == ENOTSUP) || (ret == EINVAL))
{
printf("Test PASSED\n");
return PTS_PASS;
} else{
printf("Test FAILED: Expected error code ENOTSUP, got %d.\n", ret);
return PTS_FAIL;
}
}
epicsMutexOSD * epicsMutexOsdCreate(void) {
epicsMutexOSD *pmutex;
int status;
pmutex = callocMustSucceed(1, sizeof(*pmutex), "epicsMutexOsdCreate");
status = pthread_mutexattr_init(&pmutex->mutexAttr);
checkStatusQuit(status, "pthread_mutexattr_init", "epicsMutexOsdCreate");
#if defined _POSIX_THREAD_PRIO_INHERIT
status = pthread_mutexattr_setprotocol(
&pmutex->mutexAttr,PTHREAD_PRIO_INHERIT);
if (errVerbose) checkStatus(status, "pthread_mutexattr_setprotocal");
#endif /*_POSIX_THREAD_PRIO_INHERIT*/
status = pthread_mutex_init(&pmutex->lock, &pmutex->mutexAttr);
checkStatusQuit(status, "pthread_mutex_init", "epicsMutexOsdCreate");
#if defined _POSIX_THREAD_PROCESS_SHARED
status = pthread_condattr_init(&pmutex->condAttr);
checkStatus(status, "pthread_condattr_init");
status = pthread_condattr_setpshared(&pmutex->condAttr,
PTHREAD_PROCESS_PRIVATE);
checkStatus(status, "pthread_condattr_setpshared");
status = pthread_cond_init(&pmutex->waitToBeOwner, &pmutex->condAttr);
#else
status = pthread_cond_init(&pmutex->waitToBeOwner, 0);
#endif /*_POSIX_THREAD_PROCESS_SHARED*/
checkStatusQuit(status, "pthread_cond_init", "epicsMutexOsdCreate");
return pmutex;
}
int do_test(int argc, char ** argv)
{
pthread_mutexattr_t mutexattr;
int retc, protocol;
if (pthread_mutexattr_init(&mutexattr) != 0) {
printf("Failed to init mutexattr\n");
};
if (pthread_mutexattr_setprotocol(&mutexattr, PTHREAD_PRIO_INHERIT) != 0) {
printf("Can't set protocol prio inherit\n");
}
if (pthread_mutexattr_getprotocol(&mutexattr, &protocol) != 0) {
printf("Can't get mutexattr protocol\n");
} else {
printf("protocol in mutexattr is %d\n", protocol);
}
if ((retc = pthread_mutex_init(&child_mutex, &mutexattr)) != 0) {
printf("Failed to init mutex: %d\n", retc);
}
create_other_thread(child_thread, NULL);
join_threads();
return 0;
}
// initialize data arrays to zero
// create mutex
int initLocalioData(void)
{
int i;
pthread_mutexattr_init(&data1MutexAttr);
pthread_mutexattr_setprotocol(&data1MutexAttr,PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&data1Mutex,&data1MutexAttr);
pthread_mutex_lock(&data1Mutex);
for (i=0;i<NUM_MECH;i++) {
data1.xd[i].x = 0;
data1.xd[i].y = 0;
data1.xd[i].z = 0;
data1.rd[i].yaw = 0;
data1.rd[i].pitch = 0;
data1.rd[i].roll = 0;
data1.rd[i].grasp = 0;
Q_ori[i] = Q_ori[i].getIdentity();
}
data1.surgeon_mode=0;
{
_localio_counter = 0;
for (i=0;i<NUM_MECH;i++) {
master_raw_position[i] = btVector3(0,0,0);
master_position[i] = btVector3(0,0,0);
}
}
pthread_mutex_unlock(&data1Mutex);
return 0;
}
static void
mutex_init_test (void)
{
pthread_mutexattr_t mattr;
pthread_mutex_t mutex;
mutex_kind_t mkind;
int mproto, ret;
/*
* Initialize a mutex attribute.
*
* pthread_mutexattr_init not tested for: ENOMEM
*/
assert (pthread_mutexattr_init (&mattr) == 0);
/*
* Initialize a mutex.
*
* pthread_mutex_init not tested for: EAGAIN ENOMEM EPERM EBUSY
*/
log ("Testing pthread_mutex_init\n");
log ("--------------------------\n");
for (mproto = 0; mproto < NELEMENTS(protocols); mproto++) {
for (mkind = M_POSIX; mkind <= M_SS2_RECURSIVE; mkind++) {
/* Initialize the mutex attribute. */
assert (pthread_mutexattr_init (&mattr) == 0);
assert (pthread_mutexattr_setprotocol (&mattr,
protocols[mproto]) == 0);
/*
* Ensure that the first mutex type is a POSIX
* compliant mutex.
*/
if (mkind != M_POSIX) {
assert (pthread_mutexattr_settype (&mattr,
mutex_types[mkind]) == 0);
}
log (" Protocol %s, Type %s - ",
protocol_strs[mproto], mutextype_strs[mkind]);
ret = pthread_mutex_init (&mutex, &mattr);
check_result (/* expected */ 0, ret);
assert (pthread_mutex_destroy (&mutex) == 0);
/*
* Destroy a mutex attribute.
*
* XXX - There should probably be a magic number
* associated with a mutex attribute so that
* destroy can be reasonably sure the attribute
* is valid.
*
* pthread_mutexattr_destroy not tested for: EINVAL
*/
assert (pthread_mutexattr_destroy (&mattr) == 0);
}
}
}
int swTable_create(swTable *table)
{
uint32_t row_num = table->size * (1 + SW_TABLE_CONFLICT_PROPORTION);
//header + data
uint32_t row_memory_size = sizeof(swTableRow) + table->item_size;
/**
* row data & header
*/
size_t memory_size = row_num * row_memory_size;
/**
* memory pool for conflict rows
*/
memory_size += sizeof(swMemoryPool) + sizeof(swFixedPool) + ((row_num - table->size) * sizeof(swFixedPool_slice));
/**
* for iterator, Iterate through all the elements
*/
memory_size += table->size * sizeof(swTableRow *);
void *memory = sw_shm_malloc(memory_size);
if (memory == NULL)
{
return SW_ERR;
}
memset(memory, 0, memory_size);
table->memory = memory;
table->compress_threshold = table->size * SW_TABLE_COMPRESS_PROPORTION;
table->rows = memory;
memory += table->size * sizeof(swTableRow *);
memory_size -= table->size * sizeof(swTableRow *);
#if SW_TABLE_USE_SPINLOCK == 0
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
pthread_mutexattr_setrobust_np(&attr, PTHREAD_MUTEX_ROBUST_NP);
#endif
int i;
for (i = 0; i < table->size; i++)
{
table->rows[i] = memory + (row_memory_size * i);
#if SW_TABLE_USE_SPINLOCK == 0
pthread_mutex_init(&table->rows[i]->lock, &attr);
#endif
}
memory += row_memory_size * table->size;
memory_size -= row_memory_size * table->size;
table->pool = swFixedPool_new2(row_memory_size, memory, memory_size);
return SW_OK;
}
int fifo_init(struct fifo *fifo, size_t size, bool_t prio_inherit) {
#if defined(HAVE_LIBPTHREAD) && !defined(SDL_FIFOS)
#ifndef _POSIX_THREAD_PROCESS_SHARED
#error "no _POSIX_THREAD_PROCESS_SHARED"
#endif /* _POSIX_THREAD_PROCESS_SHARED */
/* linux multi-process locking */
pthread_mutexattr_t mutex_attr;
pthread_condattr_t cond_attr;
struct utsname utsname;
int err;
if ((err = pthread_mutexattr_init(&mutex_attr)) < 0) {
return err;
}
if (prio_inherit) {
if ((err = pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED)) < 0) {
return err;
}
#ifdef _POSIX_THREAD_PRIO_INHERIT
/* only on PREEMPT kernels */
if ((err = uname(&utsname)) < 0) {
return err;
}
if (!RUNNING_ON_VALGRIND && strstr(utsname.version, "PREEMPT") != NULL) {
if ((err = pthread_mutexattr_setprotocol(&mutex_attr, PTHREAD_PRIO_INHERIT)) < 0) {
return err;
}
}
#endif /* _POSIX_THREAD_PRIO_INHERIT */
}
if ((err = pthread_mutex_init(&fifo->mutex, &mutex_attr)) < 0) {
return err;
}
if ((err = pthread_condattr_init(&cond_attr)) < 0) {
return err;
}
if (prio_inherit) {
if ((err = pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED)) < 0) {
return err;
}
}
if ((err = pthread_cond_init(&fifo->cond, &cond_attr)) < 0) {
return err;
}
#else
/* cross platform locks */
fifo->mutex = SDL_CreateMutex();
fifo->cond = SDL_CreateCond();
#endif
fifo->rptr = 0;
fifo->wptr = 0;
fifo->size = size;
return 0;
}
SeInternalCreateEmptySegmentList( ENGINE_HANDLE hEngine,
SeStatus *ErrorStatus )
{
//--------------------------------
Engine_t *Engine;
SegmentList_t *SegmentList;
pthread_mutexattr_t attr;
int rc;
//--------------------------------
if (ErrorStatus == NULL){
return NULL;
}
//
// Recover our engine object
//
Engine = (Engine_t *)hEngine;
if (Engine->Signature != ENGINE_SIGNATURE){
*ErrorStatus = SeInvalidParameters;
return NULL;
}
//
// Start creating a SegmentList
//
SegmentList = (SegmentList_t *)malloc(sizeof(SegmentList_t));
if (!SegmentList){
*ErrorStatus = SeOutOfMemory;
return NULL;
}
SegmentList->Signature = SEGMENT_LIST_SIGNATURE;
SegmentList->Engine = Engine;
rc = pthread_mutexattr_init(&attr);
ASSERT(rc == 0);
rc = pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
ASSERT(rc == 0);
rc = pthread_mutex_init(&SegmentList->InUse, &attr);
ASSERT(rc == 0);
rc = pthread_mutexattr_destroy(&attr);
ASSERT(rc == 0);
SegmentList->Segments = new vector<Segment_t *>();
SegmentList->Segments->reserve(20);
//
// There isn't one.
//
SegmentList->CurIndex = -1;
return (SE_SEGMENT_LIST_HANDLE)SegmentList;
}
int main(void)
{
#if defined(_SC_PRIORITY_SCHEDULING)
if (sysconf(_SC_PRIORITY_SCHEDULING) == -1) {
printf("PRIORITY_SCHEDULING not supported\n");
return PTS_UNSUPPORTED;
}
pthread_mutexattr_t mutex_attr;
pthread_mutex_t mutex;
int error, prioceiling;
error = pthread_mutexattr_init(&mutex_attr);
if (error) {
printf("pthread_mutexattr_init failed: %s\n", strerror(error));
return PTS_UNRESOLVED;
}
/*
* Has to be something other than PTHREAD_PRIO_NONE, the default as per
* pthread_mutexattr_getprotocol.
*/
error = pthread_mutexattr_setprotocol(&mutex_attr,
PTHREAD_PRIO_PROTECT);
if (error) {
printf("pthread_mutexattr_setprotocol failed: %s\n",
strerror(error));
return PTS_UNRESOLVED;
}
/* Initialize a mutex object */
error = pthread_mutex_init(&mutex, &mutex_attr);
if (error) {
printf("pthread_mutex_init failed: %s\n", strerror(error));
return PTS_UNRESOLVED;
}
/* Get the prioceiling of the mutex. */
error = pthread_mutex_getprioceiling(&mutex, &prioceiling);
if (error) {
printf("pthread_mutex_getprioceiling failed: %s\n",
strerror(error));
return PTS_FAIL;
}
(void)pthread_mutexattr_destroy(&mutex_attr);
(void)pthread_mutex_destroy(&mutex);
printf("Prioceiling returned: %d\n", prioceiling);
return PTS_PASS;
#else
printf("pthread_mutex_getprioceiling not supported");
return PTS_UNSUPPORTED;
#endif
}
void Pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol)
{
int err;
err = pthread_mutexattr_setprotocol(attr, protocol);
if (err) {
err_msg("%s: pthread_mutexattr_setprotocol(): ", __func__);
err_exit(err, NULL);
}
}
void
ags_ipatch_dls2_reader_init(AgsIpatchDLS2Reader *ipatch_dls2_reader)
{
guint i;
pthread_mutex_t *mutex;
pthread_mutexattr_t *attr;
ipatch_dls2_reader->flags = 0;
/* add audio file mutex */
ipatch_dls2_reader->obj_mutexattr =
attr = (pthread_mutexattr_t *) malloc(sizeof(pthread_mutexattr_t));
pthread_mutexattr_init(attr);
pthread_mutexattr_settype(attr,
PTHREAD_MUTEX_RECURSIVE);
#ifdef __linux__
pthread_mutexattr_setprotocol(attr,
PTHREAD_PRIO_INHERIT);
#endif
ipatch_dls2_reader->obj_mutex =
mutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(mutex,
attr);
/* uuid */
ipatch_dls2_reader->uuid = ags_uuid_alloc();
ags_uuid_generate(ipatch_dls2_reader->uuid);
ipatch_dls2_reader->level = 0;
ipatch_dls2_reader->ipatch = NULL;
/* selected */
ipatch_dls2_reader->index_selected = (guint *) malloc(3 * sizeof(guint));
memset(ipatch_dls2_reader->index_selected, 0, 3 * sizeof(guint));
ipatch_dls2_reader->name_selected = (gchar **) malloc(4 * sizeof(gchar *));
for(i = 0; i < 4; i++){
ipatch_dls2_reader->name_selected[i] = NULL;
}
/* reader */
ipatch_dls2_reader->reader = NULL;
ipatch_dls2_reader->dls2 = NULL;
ipatch_dls2_reader->base = NULL;
ipatch_dls2_reader->instrument = NULL;
ipatch_dls2_reader->sample = NULL;
ipatch_dls2_reader->error = NULL;
}
/*
* Test pthread creation at different thread priorities.
*/
int main(int argc, char* argv[]) {
pthread_mutexattr_t mutexattr;
int i, retc, protocol, nopi = 0;
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(0, &mask);
setup();
rt_init("h",parse_args,argc,argv);
if ((retc = pthread_barrier_init(&barrier, NULL, 5))) {
printf("pthread_barrier_init failed: %s\n", strerror(retc));
exit(retc);
}
retc = sched_setaffinity(0, sizeof(mask), &mask);
if (retc < 0) {
printf("Main Thread: Can't set affinity: %d %s\n", retc, strerror(retc));
exit(-1);
}
for (i=0;i<argc;i++) {
if (strcmp(argv[i],"nopi") == 0) nopi = 1;
}
printf("Start %s\n",argv[0]);
if (!nopi) {
if (pthread_mutexattr_init(&mutexattr) != 0) {
printf("Failed to init mutexattr\n");
}
if (pthread_mutexattr_setprotocol(&mutexattr, PTHREAD_PRIO_INHERIT) != 0) {
printf("Can't set protocol prio inherit\n");
}
if (pthread_mutexattr_getprotocol(&mutexattr, &protocol) != 0) {
printf("Can't get mutexattr protocol\n");
} else {
printf("protocol in mutexattr is %d\n", protocol);
}
if ((retc = pthread_mutex_init(&glob_mutex, &mutexattr)) != 0) {
printf("Failed to init mutex: %d\n", retc);
}
}
create_other_thread(func_nonrt,NULL);
create_rr_thread(func_rt, NULL, 20);
create_rr_thread(func_rt, NULL, 30);
create_rr_thread(func_rt, NULL, 40);
create_rr_thread(func_noise, NULL, 40);
printf("Joining threads\n");
join_threads();
printf("Done\n");
printf("Criteria:Low Priority Thread should Preempt Higher Priority Noise Thread\n");
return 0;
}
/*
* Constructor.
*/
CarlaMutex(const bool inheritPriority = true) noexcept
: fMutex(),
fTryLockWasCalled(false)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setprotocol(&attr, inheritPriority ? PTHREAD_PRIO_INHERIT : PTHREAD_PRIO_NONE);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
pthread_mutex_init(&fMutex, &attr);
pthread_mutexattr_destroy(&attr);
}
int main(int argc, char **argv) {
struct sched_param2 dl_params;
int i, retval;
pthread_t thread[MAX_THREADS];
char *debugfs = "/debug";
char path[256];
long tid = gettid();
if (argc > 1) {
printf("[main] MBWI enabled\n");
bwi_enabled = atoi(argv[1]);
}
printf("main opening trace fds\n");
strcpy(path, debugfs);
strcat(path, "/tracing/tracing_on");
trace_fd = open(path, O_WRONLY);
if (trace_fd < 0) {
printf("can't open trace_fd!\n");
exit(-1);
}
strcpy(path, debugfs);
strcat(path, "/tracing/trace_marker");
marker_fd = open(path, O_WRONLY);
if (marker_fd < 0) {
printf("can't open marker_fd!\n");
exit(-1);
}
/* Initialize mutex variable objects */
pthread_mutexattr_init(&my_mutex_attr);
if (bwi_enabled)
pthread_mutexattr_setprotocol(&my_mutex_attr,
PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&my_mutex, &my_mutex_attr);
printf("[main] creates %d threads\n", MAX_THREADS);
write(trace_fd, "1", 1);
ftrace_write(marker_fd, "[main] creates %d threads\n", MAX_THREADS);
pthread_create(&thread[0], NULL, t_1, NULL);
pthread_create(&thread[1], NULL, t_2, NULL);
for (i = 0; i < MAX_THREADS; i++)
pthread_join(thread[i], NULL);
write(trace_fd, "0", 1);
close(trace_fd);
close(marker_fd);
printf("[main] exits\n");
ftrace_write(marker_fd, "[main] exits\n");
}
/** \brief Initialize the mutex taking the mutex attributes
* into account
*
* \b os_mutexInit calls \b pthread_mutex_init to intialize the
* posix \b mutex
*
* In case the scope attribute is \b OS_SCOPE_SHARED, the posix
* mutex "pshared" attribute is set to \b PTHREAD_PROCESS_SHARED
* otherwise it is set to \b PTHREAD_PROCESS_PRIVATE.
*/
os_result
os_mutexInit (
os_mutex *mutex,
const os_mutexAttr *mutexAttr)
{
pthread_mutexattr_t mattr;
int result = 0;
os_result rv;
assert (mutex != NULL);
assert (mutexAttr != NULL);
#ifdef OSPL_STRICT_MEM
assert (mutex->signature != OS_MUTEX_MAGIC_SIG);
#endif
pthread_mutexattr_init (&mattr);
if (mutexAttr->scopeAttr == OS_SCOPE_SHARED) {
result = pthread_mutexattr_setpshared (&mattr, PTHREAD_PROCESS_SHARED);
} else {
result = pthread_mutexattr_setpshared (&mattr, PTHREAD_PROCESS_PRIVATE);
}
#ifdef OSPL_PRIO_INHERIT_SUPPORTED
/* only if priority inheritance is supported in the pthread lib */
if ((result == 0) && ospl_mtx_prio_inherit) {
result = pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
}
#endif
if (result == 0) {
#ifdef OSPL_STRICT_MEM
result = pthread_mutex_init (&mutex->mutex, &mattr);
#else
result = pthread_mutex_init (mutex, &mattr);
if (result == EBUSY) {
os_mutexDestroy (mutex);
result = pthread_mutex_init (mutex, &mattr);
}
#endif
}
pthread_mutexattr_destroy (&mattr);
if (result == 0) {
rv = os_resultSuccess;
#ifdef OSPL_STRICT_MEM
mutex->signature = OS_MUTEX_MAGIC_SIG;
#endif
} else {
OS_REPORT_2(OS_ERROR,"os_mutexInit",0,
"Operation failed: mutex 0x%x, result = %s",
mutex, strerror(result));
assert(OS_FALSE);
rv = os_resultFail;
}
return rv;
}
MutexImpl::MutexImpl()
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
#if !NV_ANDROID
// mimic default windows behavior where applicable
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
#endif
pthread_mutex_init(&getMutex(this)->lock, &attr);
pthread_mutexattr_destroy(&attr);
}
void
ags_file_init(AgsFile *file)
{
file->flags = 0;
/* add file mutex */
file->obj_mutexattr = (pthread_mutexattr_t *) malloc(sizeof(pthread_mutexattr_t));
pthread_mutexattr_init(file->obj_mutexattr);
pthread_mutexattr_settype(file->obj_mutexattr,
PTHREAD_MUTEX_RECURSIVE);
#ifdef __linux__
pthread_mutexattr_setprotocol(file->obj_mutexattr,
PTHREAD_PRIO_INHERIT);
#endif
file->obj_mutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(file->obj_mutex, file->obj_mutexattr);
file->out = NULL;
file->buffer = NULL;
file->filename = NULL;
file->encoding = AGS_FILE_DEFAULT_ENCODING;
file->dtd = AGS_FILE_DEFAULT_DTD;
file->audio_format = AGS_FILE_DEFAULT_AUDIO_FORMAT;
file->audio_encoding = AGS_FILE_DEFAULT_AUDIO_ENCODING;
file->doc = NULL;
file->id_refs = NULL;
file->lookup = NULL;
file->launch = NULL;
file->application_context = NULL;
file->clipboard = NULL;
file->property = NULL;
file->script = NULL;
file->cluster = NULL;
file->client = NULL;
file->server = NULL;
file->history = NULL;
file->embedded_audio = NULL;
file->file_link = NULL;
}
SIMPLE_THREAD_END
int scl_power_init(void)
{
THROW_BEGIN();
scl_socket = scl_get_socket("power");
THROW_IF(scl_socket == NULL, -ENODEV);
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setprotocol(&mutexattr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&mutex, &mutexattr);
simple_thread_start(&thread, thread_func, "power_reader", THREAD_PRIORITY, NULL);
THROW_END();
}
void *POSIX_Init(
void *argument
)
{
#if defined(DEFINE_MUTEX_ATTRIBUTES)
pthread_mutexattr_t mutex_attr;
#endif
pthread_t thread_id;
int status;
puts( "\n\n*** LED BLINKER -- pthread_mutex ***" );
#if defined(DEFINE_MUTEX_ATTRIBUTES)
status = pthread_mutexattr_init( &mutex_attr );
status = pthread_mutexattr_setprotocol( &mutex_attr, PTHREAD_PRIO_INHERIT );
status = pthread_mutexattr_setprioceiling( &mutex_attr, 128 );
status = pthread_mutex_init( &Mutex, &mutex_attr );
#else
status = pthread_mutex_init( &Mutex, NULL );
#endif
if (status)
fprintf( stderr, "mutex init (%d) \n", status );
/* fprintf( stderr, "Mutex id --> 0x%08x\n", Mutex ); */
status = pthread_create( &thread_id, NULL, Server, NULL );
if (status)
fprintf( stderr, "pthread_create --> %d\n", status );
status = pthread_mutex_lock( &Mutex );
if (status)
fprintf( stderr, "Main -- first lock did not work (%d)\n", status );
for ( ; ; ) {
LED_OFF();
status = sleep( 1 );
status = pthread_mutex_unlock( &Mutex );
if (status)
fprintf( stderr, "Main - unlock did not work (%d)\n", status );
status = pthread_mutex_lock( &Mutex );
if (status)
fprintf( stderr, "Main - lock did not work (%d)\n", status );
}
exit( 0 );
}
/*
* Initialize mutex attributes for the various flavors of mutexes
*/
static void
ipc_mutexattr_init(int mtx_type)
{
pthread_mutexattr_t *mtx_attrp;
mtx_attrp = &(filebench_shm->shm_mutexattr[mtx_type]);
(void) pthread_mutexattr_init(mtx_attrp);
#ifdef USE_PROCESS_MODEL
#ifdef HAVE_PROCSCOPE_PTHREADS
if (pthread_mutexattr_setpshared(mtx_attrp,
PTHREAD_PROCESS_SHARED) != 0) {
filebench_log(LOG_ERROR, "cannot set mutex attr "
"PROCESS_SHARED on this platform");
filebench_shutdown(1);
}
#ifdef HAVE_PTHREAD_MUTEXATTR_SETPROTOCOL
if (mtx_type & IPC_MUTEX_PRIORITY) {
if (pthread_mutexattr_setprotocol(mtx_attrp,
PTHREAD_PRIO_INHERIT) != 0) {
filebench_log(LOG_ERROR,
"cannot set mutex attr "
"PTHREAD_PRIO_INHERIT on this platform");
filebench_shutdown(1);
}
}
#endif /* HAVE_PTHREAD_MUTEXATTR_SETPROTOCOL */
#endif /* HAVE_PROCSCOPE_PTHREADS */
#ifdef HAVE_ROBUST_MUTEX
if (mtx_type & IPC_MUTEX_ROBUST) {
if (pthread_mutexattr_setrobust_np(mtx_attrp,
PTHREAD_MUTEX_ROBUST_NP) != 0) {
filebench_log(LOG_ERROR,
"cannot set mutex attr "
"PTHREAD_MUTEX_ROBUST_NP on this platform");
filebench_shutdown(1);
}
if (pthread_mutexattr_settype(mtx_attrp,
PTHREAD_MUTEX_ERRORCHECK) != 0) {
filebench_log(LOG_ERROR,
"cannot set mutex attr "
"PTHREAD_MUTEX_ERRORCHECK "
"on this platform");
filebench_shutdown(1);
}
}
#endif /* HAVE_ROBUST_MUTEX */
#endif /* USE_PROCESS_MODEL */
}
