void ags_lv2_option_manager_finalize(GObject *gobject) { AgsLv2OptionManager *lv2_option_manager; lv2_option_manager = AGS_LV2_OPTION_MANAGER(gobject); g_hash_table_destroy(lv2_option_manager->ressource); if(lv2_option_manager == ags_lv2_option_manager){ ags_lv2_option_manager = NULL; } pthread_mutex_destroy(lv2_option_manager->obj_mutex); free(lv2_option_manager->obj_mutex); pthread_mutexattr_destroy(lv2_option_manager->obj_mutexattr); free(lv2_option_manager->obj_mutexattr); /* call parent */ G_OBJECT_CLASS(ags_lv2_option_manager_parent_class)->finalize(gobject); }
/* * Initialize slog library. Function parses config file and reads log * level and save to file flag from config. First argument is file name * where log will be saved and second argument conf is config file path * to be parsedand third argument lvl is log level for this message. */ void slog_init(const char* fname, const char* conf, int lvl, int flvl, int t_safe) { int status = 0; /* Set up default values */ slg.level = lvl; slg.file_level = flvl; slg.to_file = 0; slg.pretty = 0; slg.filestamp = 1; slg.td_safe = t_safe; /* Init mutex sync */ if (t_safe) { /* Init mutex attribute */ pthread_mutexattr_t m_attr; if (pthread_mutexattr_init(&m_attr) || pthread_mutexattr_settype(&m_attr, PTHREAD_MUTEX_RECURSIVE) || pthread_mutex_init(&slog_mutex, &m_attr) || pthread_mutexattr_destroy(&m_attr)) { printf("<%s:%d> %s: [ERROR] Can not initialize mutex: %d\n", __FILE__, __LINE__, __FUNCTION__, errno); slg.td_safe = 0; } } /* Parse config file */ if (conf != NULL) { slg.fname = fname; status = parse_config(conf); } /* Handle config parser status */ if (!status) slog(0, SLOG_INFO, "Initializing logger values without config"); else slog(0, SLOG_INFO, "Loading logger config from: %s", conf); }
//critical_section_t critical_section_t::critical_section_t(bool recursive_flag) throw() { #ifdef LINUX pthread_mutexattr_t mtx_attr; pthread_mutexattr_init(&mtx_attr); if(recursive_flag) pthread_mutexattr_settype(&mtx_attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&_mtx, &mtx_attr); pthread_mutexattr_destroy(&mtx_attr); #elif defined(WIN32) if(recursive_flag) { InitializeCriticalSection(&_cs); _sem = NULL; } else //non-recursive { _sem = ::CreateSemaphore(NULL,1,1,NULL); } #endif //LINUX }
/*! \brief Create and initialize a critical section * * UNIX/Linux * * \return Pointer to critical section created and initialized (casted to \c void *). */ void * PMS_CreateCriticalSection(void) { pthread_mutex_t * ptCS; /* Mutex for critical section */ pthread_mutexattr_t mutexattr; /* Mutex attribute variable */ ptCS = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); if(!ptCS) { PMS_SHOW_ERROR("Failed to allocation critical section structure\n"); return NULL; } #ifndef PMS_OIL_MERGE_DISABLE_MEM memVal+=sizeof(pthread_mutex_t); #endif /* Initialize the attributes set */ pthread_mutexattr_init(&mutexattr); #ifdef MACOSX /* Set the mutex as a normal mutex */ pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_NORMAL); #else #ifdef __NetBSD__ /* Set the mutex as a normal mutex */ pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_NORMAL); #else /* Set the mutex as a fast mutex */ pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ADAPTIVE_NP); #endif #endif /* create the mutex with the attributes set */ pthread_mutex_init(ptCS, &mutexattr); /* After initializing the mutex, the attribute can be destroyed */ pthread_mutexattr_destroy(&mutexattr); return (void*)ptCS; }
int main(void) { int ret; pthread_t tid[2]; pthread_attr_t attr; pthread_mutexattr_t mutexattr; pthread_attr_init(&attr); pthread_mutexattr_init(&mutexattr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP); pthread_mutex_init(&lock, &mutexattr); pthread_mutexattr_destroy(&mutexattr); ret = pthread_create(&tid[0], &attr, test0, NULL); if (ret) { fprintf(stderr, "create:%s\n", strerror(ret)); exit(1); } ret = pthread_create(&tid[0], &attr, test1, NULL); if (ret) { fprintf(stderr, "create:%s\n", strerror(ret)); exit(1); } pthread_attr_destroy(&attr); pthread_exit(NULL); }
int initCrashSimulationThread(rtSimulationThread_t *p_thread, inputThread_t *p_inputThread) { int ret; pthread_mutexattr_t attr; ret = initRTMutexAttr(&attr); if(ret != 0) { PRINT_ERR("Failed to init rt mutex attributes (%d).\n", ret); return ret; } ret = pthread_mutex_init(&p_thread->simulationMutex, &attr); if(ret != 0) { PRINT_ERR("Failed to init mutex (%d).\n", ret); return ret; } ret = pthread_barrier_init(&p_thread->startBarrier, NULL, 2); if(ret != 0) { PRINT_ERR("Failed to init barrier (%d).\n", ret); return ret; } ret = initSimulation(&p_thread->simulation, DEF_DISTANCE); if(ret != 0) { PRINT_ERR("Failed to init simulation (%d).\n", ret); return ret; } p_thread->simulate = 0; p_thread->keepRunning = 0; p_thread->running = 0; p_thread->exitCode = 0; p_thread->inputThread = p_inputThread; pthread_mutexattr_destroy(&attr); return 0; }
static int do_test (void) { pthread_mutex_t m; int e = pthread_mutex_init (&m, ATTR); if (ATTR != NULL && e == ENOTSUP) { puts ("cannot support selected type of mutexes"); e = pthread_mutex_init (&m, NULL); } if (e != 0) { puts ("mutex_init failed"); return 1; } if (ATTR != NULL && pthread_mutexattr_destroy (ATTR) != 0) { puts ("mutexattr_destroy failed"); return 1; } if (pthread_mutex_lock (&m) != 0) { puts ("1st mutex_lock failed"); return 1; } /* Set an alarm for 1 second. The wrapper will expect this. */ alarm (1); /* This call should never return. */ pthread_mutex_lock (&m); puts ("2nd mutex_lock returned"); return 1; }
int main() { pthread_mutexattr_t mta; int rc; /* Initialize a mutex attributes object */ if ((rc=pthread_mutexattr_init(&mta)) != 0) { fprintf(stderr,"Cannot initialize mutex attributes object\n"); return PTS_UNRESOLVED; } /* Destroy the mutex attributes object */ if (pthread_mutexattr_destroy(&mta) != 0) { fprintf(stderr,"Error at pthread_mutexattr_destroy(), rc=%d\n", rc); printf("Test FAILED\n"); return PTS_FAIL; } printf("Test PASSED\n"); return PTS_PASS; }
int usbi_mutex_init_recursive(pthread_mutex_t *mutex, pthread_mutexattr_t *attr) { int err; pthread_mutexattr_t stack_attr; if (!attr) { attr = &stack_attr; err = pthread_mutexattr_init(&stack_attr); if (err != 0) return err; } err = pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE); if (err != 0) goto finish; err = pthread_mutex_init(mutex, attr); finish: if (attr == &stack_attr) pthread_mutexattr_destroy(&stack_attr); return err; }
IMutexLock::IMutexLock() { #ifdef WIN32 if (InitializeCriticalSectionAndSpinCount(&_M_mutex, 2000) != TRUE) { DeleteCriticalSection(&_M_mutex); std::cerr << "init critical section failed !" << std::endl; } #elif defined(HAVE_PTHREAD) int _ret_code = 0; if ((_ret_code = pthread_mutexattr_init(&_M_mutexattr)) != 0) std::cerr << "mutex attribute init failed !" << std::endl; if (_ret_code == 0) _ret_code = pthread_mutexattr_settype(&_M_mutexattr, PTHREAD_MUTEX_ERRORCHECK); if (_ret_code == 0) if ((_ret_code = pthread_mutex_init(&_M_mutex, &_M_mutexattr)) != 0) err_msg("pthread_mutex_init failed"); if (_ret_code != 0) { (void)pthread_mutex_destroy(&_M_mutex); (void)pthread_mutexattr_destroy(&_M_mutexattr); } #endif // end of WIN32 }
zMutex::zMutex(void) { _lockedCount = 0; _isDestroying = false; #if defined(_WIN32) _cs = new CRITICAL_SECTION; InitializeMutexAndSpinCount((LPCRITICAL_SECTION)_cs, 500); #else pthread_mutexattr_t mutexAttr; int res = pthread_mutexattr_init(&mutexAttr); CHECK_FATAL(res, "pthread_mutexattr_init"); res = pthread_mutexattr_settype(&mutexAttr, PTHREAD_MUTEX_RECURSIVE); CHECK_FATAL(res, "pthread_mutexattr_settype PTHREAD_MUTEX_RECURSIVE"); res = pthread_mutex_init(&_mutex, &mutexAttr); CHECK_FATAL(res, "pthread_mutex_init"); res = pthread_mutexattr_destroy(&mutexAttr); CHECK_FATAL(res, "pthread_mutexattr_destroy"); #endif }
/** * Contruct our Mutex */ dashee::Threads::LockMutex::LockMutex() { this->mutex = new pthread_mutex_t(); this->attr = new pthread_mutexattr_t(); if (pthread_mutexattr_init(this->attr) != 0) throw ExceptionLock("Thread attribute init failed"); if (pthread_mutexattr_settype(this->attr, PTHREAD_MUTEX_ERRORCHECK) != 0) throw ExceptionLock("Thread attribute set failed"); // Make sure that initilization comes out as good, otherwise we should // absolutly die die die int ec = pthread_mutex_init(this->mutex, this->attr); if (ec != 0) throw ExceptionLock( "Error Initilizing LockMutex, ec='" + dashee::itostr(ec) + "'. This should not happen!" ); pthread_mutexattr_destroy(this->attr); this->attr = NULL; }
static void *scene_create(obs_data_t settings, struct obs_source *source) { pthread_mutexattr_t attr; struct obs_scene *scene = bmalloc(sizeof(struct obs_scene)); scene->source = source; scene->first_item = NULL; if (pthread_mutexattr_init(&attr) != 0) goto fail; if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0) goto fail; if (pthread_mutex_init(&scene->mutex, &attr) != 0) { blog(LOG_ERROR, "scene_create: Couldn't initialize mutex"); goto fail; } return scene; fail: pthread_mutexattr_destroy(&attr); bfree(scene); return NULL; }
poster(Blink * _blink, bool & ok) : state(WAIT), blink(_blink) { pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK); pthread_mutex_init(&mutex, &attr); pthread_mutexattr_destroy(&attr); switch(pthread_create(&thread_id, 0, run, this)){ case EAGAIN: if(0 != blink->m_os) (*blink->m_os) << "insufficient resources for thread.\n"; ok = false; break; case EINVAL: if(0 != blink->m_os) (*blink->m_os) << "BUG [invalid attr for pthread_create()]\n"; ok = false; break; default: ok = true; } }
/*---------------------------------------------------------------------------------*/ void engine::finalize(){ if ( runMultiThread ) { pthread_mutex_destroy(&thread_lock); pthread_mutexattr_destroy(&mutex_attr); task_submission_finished=true; LOG_INFO(LOG_MULTI_THREAD,"before join\n"); if ( thread_model >=1){ pthread_join(mbsend_tid,NULL); LOG_INFO(LOG_MULTI_THREAD," MBSend thread joined\n"); } if ( thread_model >=2){ pthread_join(mbrecv_tid,NULL); LOG_INFO(LOG_MULTI_THREAD,"MBRecv thread joined\n"); } pthread_join(thread_id,NULL); LOG_INFO(LOG_MULTI_THREAD,"Admin thread joined\n"); } else doProcessLoop((void *)this); globalSync(); if(cfg->getDLB()) dlb.dumpDLB(); }
DeckLinkConsumer() { pthread_mutexattr_t mta; m_displayMode = NULL; m_deckLinkKeyer = NULL; m_deckLinkOutput = NULL; m_deckLink = NULL; m_aqueue = mlt_deque_init(); m_frames = mlt_deque_init(); // operation locks m_op_id = OP_NONE; m_op_arg = 0; pthread_mutexattr_init( &mta ); pthread_mutexattr_settype( &mta, PTHREAD_MUTEX_RECURSIVE ); pthread_mutex_init( &m_op_lock, &mta ); pthread_mutex_init( &m_op_arg_mutex, &mta ); pthread_mutexattr_destroy( &mta ); pthread_cond_init( &m_op_arg_cond, NULL ); pthread_create( &m_op_thread, NULL, op_main, this ); }
int myfunc() { int ret = 0; int type = 0; pthread_mutexattr_t attr; if ((ret = pthread_mutexattr_init(&attr)) != 0) { printf("pthread_mutexattr_init error: %s\n", strerror(ret)); return ret; } if ((ret = pthread_mutexattr_gettype(&attr, &type)) != 0) { printf("gettype error\n"); return ret; } whichtype(type); if ((ret = pthread_mutexattr_destroy(&attr)) != 0) { printf("destroy error\n"); return ret; } return 0; }
//建立临界区 void MThreadBase::rv_CreateSection() { if(s_blSectionFlag) return; #ifndef LINUXCODE ::InitializeCriticalSection(&s_stSection); #else /* * GUOGUO 2009-08-11 设置临界区锁的属性为可递归锁,支持同一线程连续调用lock */ // ADD pthread_mutexattr_t attr; pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP); // ADD END pthread_mutex_init(&s_stSection,&attr); // ADD pthread_mutexattr_destroy(&attr); // ADD END #endif s_blSectionFlag = true; }
/** * Close metadata file of a fake device. */ static void zbc_fake_close_metadata(zbc_fake_device_t *fdev) { if ( fdev->zbd_meta_fd > 0 ) { if ( fdev->zbd_meta ) { msync(fdev->zbd_meta, fdev->zbd_meta_size, MS_SYNC); munmap(fdev->zbd_meta, fdev->zbd_meta_size); fdev->zbd_meta = NULL; fdev->zbd_meta_size = 0; } close(fdev->zbd_meta_fd); fdev->zbd_meta_fd = -1; pthread_mutexattr_destroy(&fdev->zbd_mutex_attr); } return; }
MessageQueue::MessageQueue( int maxMessages_ ) : shutdown( false ), maxMessages( maxMessages_ ), messages( new message_t[ maxMessages_ ] ), head( 0 ), tail( 0 ) { assert( maxMessages > 0 ); for ( int i = 0; i < maxMessages; i++ ) { messages[i].string = NULL; messages[i].synced = false; } pthread_mutexattr_t attr; pthread_mutexattr_init( &attr ); pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_ERRORCHECK ); pthread_mutex_init( &mutex, &attr ); pthread_mutexattr_destroy( &attr ); pthread_cond_init( &posted, NULL ); pthread_cond_init( &received, NULL ); }
/***************************************************************************** * vlc_mutex_init: initialize a recursive mutex (Do not use) *****************************************************************************/ int vlc_mutex_init_recursive( vlc_mutex_t *p_mutex ) { #if defined( LIBVLC_USE_PTHREAD ) pthread_mutexattr_t attr; int i_result; pthread_mutexattr_init( &attr ); # if defined (__GLIBC__) && (__GLIBC_MINOR__ < 6) pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_RECURSIVE_NP ); # else pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE ); # endif i_result = pthread_mutex_init( p_mutex, &attr ); pthread_mutexattr_destroy( &attr ); return( i_result ); #elif defined( WIN32 ) /* Create mutex returns a recursive mutex */ *p_mutex = CreateMutex( 0, FALSE, 0 ); return (*p_mutex != NULL) ? 0 : ENOMEM; #else # error Unimplemented! #endif }
void print_pthread_info() { #if defined(HAVE_LIBPTHREAD) pthread_attr_t attr; pthread_mutexattr_t m_attr; pthread_condattr_t c_attr; #if defined(PTHREAD_KEYS_MAX) fprintf(stderr, "PTHREAD_KEYS_MAX = %d\n", PTHREAD_KEYS_MAX); #endif #if defined(PTHREAD_DESTRUCTOR_ITERATIONS) fprintf(stderr, "PTHREAD_DESTRUCTOR_ITERATIONS = %d\n", PTHREAD_DESTRUCTOR_ITERATIONS); #endif #if defined(PTHREAD_THREADS_MAX) fprintf(stderr, "PTHREAD_THREADS_MAX = %d\n", PTHREAD_THREADS_MAX); #endif #if defined(PTHREAD_STACK_MIN) fprintf(stderr, "PTHREAD_STACK_MIN = %d\n", PTHREAD_STACK_MIN); #endif fprintf(stderr, "\n"); pthread_attr_init(&attr); print_pthread_attr("Default pthread attr", &attr); pthread_attr_destroy(&attr); pthread_mutexattr_init(&m_attr); print_pthread_mutexattr("Default pthread mutexattr", &m_attr); pthread_mutexattr_destroy(&m_attr); pthread_condattr_init(&c_attr); print_pthread_condattr("Default pthread condattr ", &c_attr); pthread_condattr_destroy(&c_attr); fprintf(stderr, "\n"); #endif }
ESL_DECLARE(esl_status_t) esl_mutex_create(esl_mutex_t **mutex) { esl_status_t status = ESL_FAIL; #ifndef WIN32 pthread_mutexattr_t attr; #endif esl_mutex_t *check = NULL; check = (esl_mutex_t *)malloc(sizeof(**mutex)); if (!check) goto done; #ifdef WIN32 InitializeCriticalSection(&check->mutex); #else if (pthread_mutexattr_init(&attr)) goto done; if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) goto fail; if (pthread_mutex_init(&check->mutex, &attr)) goto fail; goto success; fail: pthread_mutexattr_destroy(&attr); goto done; success: #endif *mutex = check; status = ESL_SUCCESS; done: return status; }
Sender::Sender(OlySocket* socket) { mDataFile = NULL; mDataSocket = NULL; // Set up the socket connection if (socket) { char streamline[64] = {0}; mDataSocket = socket; // Receive magic sequence - can wait forever // Streamline will send data prior to the magic sequence for legacy support, which should be ignored for v4+ while (strcmp("STREAMLINE", streamline) != 0) { if (mDataSocket->receiveString(streamline, sizeof(streamline)) == -1) { logg->logError("Socket disconnected"); handleException(); } } // Send magic sequence - must be done first, after which error messages can be sent char magic[32]; snprintf(magic, 32, "GATOR %i\n", PROTOCOL_VERSION); mDataSocket->send(magic, strlen(magic)); gSessionData->mWaitingOnCommand = true; logg->logMessage("Completed magic sequence"); } pthread_mutexattr_t attr; if (pthread_mutexattr_init(&attr) != 0 || pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK) != 0 || pthread_mutex_init(&mSendMutex, &attr) != 0 || pthread_mutexattr_destroy(&attr) != 0 || false) { logg->logError("Unable to setup mutex"); handleException(); } }
static void opal_mutex_construct(opal_mutex_t *m) { #if OPAL_HAVE_POSIX_THREADS #if OPAL_ENABLE_DEBUG pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); /* set type to ERRORCHECK so that we catch recursive locks */ #if OMPI_HAVE_PTHREAD_MUTEX_ERRORCHECK_NP pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK_NP); #elif OMPI_HAVE_PTHREAD_MUTEX_ERRORCHECK pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK); #endif /* OMPI_HAVE_PTHREAD_MUTEX_ERRORCHECK_NP */ pthread_mutex_init(&m->m_lock_pthread, &attr); pthread_mutexattr_destroy(&attr); #else /* Without debugging, choose the fastest available mutexes */ pthread_mutex_init(&m->m_lock_pthread, NULL); #endif /* OPAL_ENABLE_DEBUG */ #endif #if OPAL_ENABLE_DEBUG && !OPAL_ENABLE_MULTI_THREADS m->m_lock_debug = 0; m->m_lock_file = NULL; m->m_lock_line = 0; #endif #if OPAL_HAVE_ATOMIC_SPINLOCKS opal_atomic_init( &m->m_lock_atomic, OPAL_ATOMIC_UNLOCKED ); #endif }
static ph_dns_channel_t *create_chan(void) { ph_dns_channel_t *chan; struct ares_options opts; int res; pthread_mutexattr_t attr; chan = ph_mem_alloc(mt.chan); if (!chan) { return NULL; } pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&chan->chanlock, &attr); pthread_mutexattr_destroy(&attr); if (ph_ht_init(&chan->sock_map, 4, &sock_key, &ph_ht_ptr_val_def) != PH_OK) { ph_panic("failed to init sock map"); } memset(&opts, 0, sizeof(opts)); opts.sock_state_cb_data = chan; opts.sock_state_cb = sock_state_cb; opts.flags = ARES_FLAG_STAYOPEN; res = ares_init_options(&chan->chan, &opts, ARES_OPT_SOCK_STATE_CB|ARES_OPT_FLAGS); if (res != ARES_SUCCESS) { ph_panic("failed to ares_init_options: %s", ares_strerror(res)); } ares_set_socket_callback(chan->chan, sock_create_cb, chan); return chan; }
int main(void) { int err; int condition; int arg; struct timespec when; if ((err = pthread_mutexattr_init(&attr)) != 0) { printf("pthread_mutexattr_init failed\n"); return(1); } err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); if (err != 0) { printf("pthread_mutexattr_settype failed\n"); } else if ((err = pthread_mutex_init(&mutex, &attr)) != 0) { printf("pthread_mutex_init failed\n"); } pthread_mutexattr_destroy(&attr); if (err != 0) { return(1); } /* ... */ pthread_mutex_lock(&mutex); condition = 1; if (condition) { /* calculate target time "when" */ maketimespec(&when, 5); timeout(&when, retry, (void *)arg); } /* ... */ pthread_mutex_unlock(&mutex); /* ... */ sleep(10); /* wait */ exit(0); /* fflush */ }
int usbi_mutex_init_recursive(pthread_mutex_t *mutex, pthread_mutexattr_t *attr) { int err; pthread_mutexattr_t stack_attr; if (!attr) { attr = &stack_attr; err = pthread_mutexattr_init(&stack_attr); if (err != 0) return err; } /* mutexattr_settype requires _GNU_SOURCE or _XOPEN_SOURCE >= 500 on Linux */ err = pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE); if (err != 0) goto finish; err = pthread_mutex_init(mutex, attr); finish: if (attr == &stack_attr) pthread_mutexattr_destroy(&stack_attr); return err; }
void OSAcquireMutex(void) { if(!mutexInitialized) { int ret; pthread_mutexattr_t attr; ret = pthread_mutexattr_init(&attr); //initially not locked RI_ASSERT(!ret); //check that there aren't any errors ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); //count the number of recursive locks RI_ASSERT(!ret); //check that there aren't any errors ret = pthread_mutex_init(&mutex, &attr); pthread_mutexattr_destroy(&attr); RI_ASSERT(!ret); //check that there aren't more errors RI_UNREF(ret); mutexInitialized = true; } int ret = pthread_mutex_lock(&mutex); RI_ASSERT(ret != EINVAL); //assert that the mutex has been initialized RI_ASSERT(ret != EAGAIN); //assert that the maximum number of recursive locks hasn't been exceeded RI_ASSERT(ret != EDEADLK); //recursive mutexes shouldn't return this RI_ASSERT(!ret); //check that there aren't other errors RI_UNREF(ret); mutexRefCount++; }
/* Fonction appelée au lancement du programme */ void initialisationProgramme() { // Implémenter ici l'initialisation de vos variables, la création // de vos objets système, etc. /* initialisation du scheduler en mode FIFO et a la priorité max*/ int priority = 0; int pid = getpid(); priority = sched_get_priority_max(SCHED_FIFO); struct sched_param param; param.sched_priority = priority; if (sched_setscheduler(pid, SCHED_FIFO, & param) != 0) { perror("sched_setscheduler"); exit(EXIT_FAILURE); } /* creation et initialisation des mutex pour la console et la ressource*/ pthread_mutexattr_t attributsMutex; pthread_mutexattr_init(&attributsMutex); pthread_mutexattr_settype(&attributsMutex, PTHREAD_MUTEX_DEFAULT); pthread_mutex_init(&mutConsole, &attributsMutex); pthread_mutex_init(&mutRessourceGlobale, &attributsMutex); pthread_mutexattr_destroy(&attributsMutex); }