static void* testMethodProduce(void* val) { cout << "\nProduce method started" << endl; Lock* lock = (Lock*)val; cout << "Produce: Sleeping for 3 segs" << endl; int x = 0; while (x < MAX_NUMBER) { lock->lock(); if (pcList.size() >= 10) { printf("Queue is full. Last produced: %d\n", x); lock->wait(1); } else { printf("Last produced: %d\n", x); x++; pcList.push_back(x); lock->notify(); } lock->unlock(); } cout << "Produce: notification sent. Waiting for confirmation" << endl; lock->lock(); lock->notify(); lock->unlock(); return NULL; }
int main(int argc, char *argv[]){ for (uint32_t y = 0; y < 10; y++) { assert(!locks.getValue(y)); } locks.lock(3); assert(locks.getValue(2)); assert(locks.getValue(3)); assert(locks.getValue(4)); locks.unlock(3); assert(!locks.getValue(2)); assert(!locks.getValue(3)); assert(!locks.getValue(4)); locks.lock(9); assert(locks.getValue(8)); assert(locks.getValue(9)); assert(locks.getValue(0)); locks.unlock(9); assert(!locks.getValue(8)); assert(!locks.getValue(9)); assert(!locks.getValue(0)); locks.lock(0); assert(locks.getValue(9)); assert(locks.getValue(0)); assert(locks.getValue(1)); locks.unlock(0); assert(!locks.getValue(9)); assert(!locks.getValue(0)); assert(!locks.getValue(1)); // A thread is waiting void *status; pthread_t threads[NUM_THREAD]; for (long i = 0; i < NUM_THREAD; i++) { // printf("Creation thread n° %li \n", i); pthread_create(&(threads[i]), NULL, thread1, (void*) i); } // Wait for the end of every thread for (long i = 0; i < NUM_THREAD; i++) { pthread_join(threads[i], &status); if (status != (void*)0) { // printf("Error in the execution"); return 1; } } //printf("All thread have finished \n"); return 0; }
virtual void threadProc() { omsg("ImageLoaderThread: start"); while(!sShutdownLoaderThread) { sImageQueueLock.lock(); if(sImageQueue.size() > 0) { Ref<ImageUtils::LoadImageAsyncTask> task = sImageQueue.front(); sImageQueue.pop(); sImageQueueLock.unlock(); Ref<PixelData> res = ImageUtils::loadImage(task->getData().path, task->getData().isFullPath); if(!sShutdownLoaderThread) { task->getData().image = res; task->notifyComplete(); } //sImageQueueLock.unlock(); } else { sImageQueueLock.unlock(); } osleep(100); } omsg("ImageLoaderThread: shutdown"); }
void wait(Lock& lock) { BOOST_ASSERT(lock.locked()); lock.unlock(); { mutex::scoped_lock waitLock(mWaitCountMutex); ++mWaitCount; } ::WaitForSingleObject(event_, INFINITE); { mutex::scoped_lock waitLock(mWaitCountMutex); --mWaitCount; if (mWaitCount == 0) { // Set signalled state back to false. ::ResetEvent(event_); } } lock.lock(); }
void getErrorDescription(int errorCode, WCHAR *buffer, int len) { static Lock lock; lock.lock(); LPVOID lpMsgBuf; FormatMessageW( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorCode, 0, // Default language (LPWSTR) &lpMsgBuf, 0, NULL ); _snwprintf(buffer, len, L"Error %d : %s", errorCode, (LPCTSTR)lpMsgBuf); int len1 = wcslen(buffer); if (len1 >= 2) { buffer[len1 - 2] = '\0'; } LocalFree( lpMsgBuf ); lock.unlock(); }
JNIEXPORT jint JNICALL Java_com_kurento_kas_media_tx_MediaTx_putAudioSamples(JNIEnv* env, jclass clazz, jshortArray samples, jint n_samples, jlong time) { int ret; int16_t *samples_buf; mutexAudioTx.lock(); if (!aTxObj) { media_log(MEDIA_LOG_ERROR, LOG_TAG, "No audio-tx initiated"); mutexAudioTx.unlock(); return -1; } samples_buf = (int16_t*)(env->GetShortArrayElements(samples, JNI_FALSE)); try { ret = aTxObj->putAudioSamplesTx(samples_buf, n_samples, time); } catch(MediaException &e) { media_log(MEDIA_LOG_ERROR, LOG_TAG, "%s", e.what()); ret = -1; } env->ReleaseShortArrayElements(samples, samples_buf, 0); mutexAudioTx.unlock(); return ret; }
bool context_node::open(bool access_rw, bool* fsetxattr_failed) { lock_.lock(); if (pa_) { lock_.unlock(); return true; } char filename[PROP_FILENAME_MAX]; int len = snprintf(filename, sizeof(filename), "%s/%s", property_filename, context_); if (len < 0 || len > PROP_FILENAME_MAX) { lock_.unlock(); return false; } if (access_rw) { pa_ = map_prop_area_rw(filename, context_, fsetxattr_failed); } else { pa_ = map_prop_area(filename #if MB_ENABLE_COMPAT_PROPERTIES , false #endif ); } lock_.unlock(); return pa_; }
void wait(Lock& lock) { BOOST_ASSERT(lock.locked()); lock.unlock(); ::WaitForSingleObject(event_, INFINITE); lock.lock(); }
bool timed_wait(Lock& lock, boost::uint32_t waitMs) { BOOST_ASSERT(lock.locked()); lock.unlock(); { mutex::scoped_lock waitLock(mWaitCountMutex); ++mWaitCount; } DWORD ret = ::WaitForSingleObject(event_, waitMs); assert(ret != WAIT_ABANDONED && ret != WAIT_FAILED); { mutex::scoped_lock waitLock(mWaitCountMutex); --mWaitCount; if (ret != WAIT_TIMEOUT && mWaitCount == 0) { // Set signalled state back to false. ::ResetEvent(event_); } } lock.lock(); if (ret == WAIT_TIMEOUT) { return false; } return true; }
void addExternalListener(const char *name, int retSize, NetworkAddress *addr) { Event ev; bool isNewEvent = false; lock.lock(); ExternalEvent *extEvent = findEvent(name); if(!extEvent) { extEvent = newEvent(name, retSize); isNewEvent = true; } extEvent->addExternalListener(addr); if(isNewEvent) extEvent->listenerAddr = ev.addListener(name, eventCallback, 0, false, retSize); else { int prevSize = extEvent->retSize; //If ret size larger than previous (singleEvent) retSize, make enough room if(prevSize < retSize) { extEvent->totRetSize = (extEvent->totRetSize/extEvent->retSize)*retSize; extEvent->totRetSize = retSize; } else extEvent->totRetSize += extEvent->retSize; ev.resizeListener(extEvent->listenerAddr, extEvent->totRetSize); } lock.unlock(); }
//##ModelId=424BB64700A6 void ACDX::setAliasAvailable(CString _epid, CString _callid) { std::list<Agent>::iterator agentElment; Agent _agent; Agent agent = agentByCallId(_epid, _callid); // find first alias while ((agent.isOK) && (_callid.GetLength() > 0)) { // in alias list update element for(agentElment = aliasList.begin(); agentElment != aliasList.end();agentElment++) { _agent = *agentElment; if (agent.getAlias()==_agent.getAlias()) { if (g_lock.lock()) { agentElment->setState(Alias::AVAILABLE); agentElment->setLastCall(); agentElment->setLastTime(); agentElment->setCallId(""); backlog->checkPending((&(Agent)*agentElment),aliasList); //------> need test it agent in checkpending g_lock.unlock(); }// if lock }//if alias == }// for // check if we have pending calls for this now available agent //backlog->checkPending(&agent); //------> need test it agent in checkpending agent = agentByCallId(_epid, _callid); // find next alias } }
virtual void threadProc() { omsg("MeshLoaderThread: start"); while(!sShutdownLoaderThread) { if(sMeshQueue.size() > 0) { sMeshQueueLock.lock(); if(sMeshQueue.size() > 0) { Ref<WarpMeshUtils::LoadWarpMeshGridAsyncTask> task = sMeshQueue.front(); sMeshQueue.pop(); sMeshQueueLock.unlock(); Ref<WarpMeshGrid> mesh = WarpMeshUtils::loadWarpMeshGrid(task->getData().path, task->getData().isFullPath); if(!sShutdownLoaderThread) { task->getData().mesh = mesh; task->notifyComplete(); } } else { sMeshQueueLock.unlock(); } } osleep(100); } omsg("MeshLoaderThread: shutdown"); }
void addInternalPending(const char *name, char *buf, int bufSize) { lock.lock(); ExternalEvent *extEvent = findEvent(name); if(extEvent) extEvent->addInternalPending(buf, bufSize); lock.unlock(); }
void push(Node<T>* inNode) { //Node<T>* newNode = new Node<T>(); //newNode->data = val; lock->lock(); inNode->next = NULL; tail->next = inNode; tail = inNode; lock->unlock(); }
bool RenderTarget::isProcessing() const { bool ret = true; if(index > 0) { renderLock.lock(); ret = index == pendingTarget.index || index == activeTarget.index; renderLock.unlock(); } return ret; }
void UiRenderPass::render(Renderer* client, const DrawContext& context) { sLock.lock(); myDrawTimeStat->startTiming(); if(context.task == DrawContext::SceneDrawTask) { client->getRenderer()->beginDraw3D(context); glPushAttrib(GL_ALL_ATTRIB_BITS); // This is a bit of a hack. DIsable depth testing for ui stuff. We will take care of ordering. // This may lead to depth inconsistencies wrt the background scene when drawing 3d menus, but we want te // menus to always be visible and unoccluded by geometry. glDisable(GL_DEPTH_TEST); ui::Container* ui = myUiRoot; Renderable* uiRenderable = ui->getRenderable(client); if(uiRenderable != NULL) { uiRenderable->draw(context); } glPopAttrib(); client->getRenderer()->endDraw(); } else if(context.task == DrawContext::OverlayDrawTask) { Vector2i displaySize; // check if the tile is part of a canvas (a multi-tile grid). If it is, // get the canvas resolution. Otherwise simply use the tile resolution. if(context.tile->isInGrid) { DisplaySystem* ds = SystemManager::instance()->getDisplaySystem(); displaySize = ds->getCanvasSize(); } else { displaySize = context.tile->pixelSize; } client->getRenderer()->beginDraw2D(context); glPushAttrib(GL_ALL_ATTRIB_BITS); Renderable* uiRenderable = myUiRoot->getRenderable(client); if(uiRenderable != NULL) { uiRenderable->draw(context); } glPopAttrib(); client->getRenderer()->endDraw(); } myDrawTimeStat->stopTiming(); sLock.unlock(); }
SuperClusterer * SuperClusterer::getInstance() { static Lock l; l.lock(); if (!instance) instance = new SuperClusterer(); l.unlock(); return (instance); }
ArchiverConnectionTask * ArchiverConnectionTask::getInstance() { static Lock l; l.lock(); if (!instance) instance = new ArchiverConnectionTask("ArchiverConnection"); l.unlock(); return (instance); }
State * State::getInstance() { static Lock l; l.lock(); if (!instance) instance = new State(); l.unlock(); return (instance); }
DetectionTask * DetectionTask::getInstance() { static Lock l; l.lock(); if (!instance) instance = new DetectionTask("DetectionTask"); l.unlock(); return (instance); }
MsgList * MsgList::getInstance(string name_, int messages_) { static Lock l; l.lock(); if (!instance) instance = new MsgList(name_, messages_); l.unlock(); return (instance); }
CmdTask * CmdTask::getInstance(string tname_) { static Lock l; l.lock(); if (!instance) instance = new CmdTask(tname_); l.unlock(); return (instance); }
ErrMsg * ErrMsg::getInstance() { static Lock l; l.lock(); if (!instance) instance = new ErrMsg(); l.unlock(); return (instance); }
//Called upon connection termination void removeExternalListeners(NetworkAddress *addr) { lock.lock(); ExternalEvent *extEvent = extEventHead; while(extEvent) { extEvent->removeExternalListeners(addr); extEvent = extEvent->nxt; } lock.unlock(); }
void unblockExternalPending(NetworkAddress *addr) { lock.lock(); ExternalEvent *extEvent = extEventHead; while(extEvent) { extEvent->unblockExternalPending(addr); extEvent = extEvent->nxt; } lock.unlock(); }
JNIEXPORT jint JNICALL Java_com_kurento_kas_media_tx_MediaTx_finishAudio(JNIEnv* env, jclass clazz) { mutexAudioTx.lock(); if (aTxObj) { delete aTxObj; aTxObj = NULL; } mutexAudioTx.unlock(); return 0; }
TEST(WTF_Condition, TimeoutTimesOut) { Lock lock; Condition condition; lock.lock(); bool result = condition.waitFor( lock, Seconds::fromMilliseconds(10), [] () -> bool { return false; }); lock.unlock(); EXPECT_FALSE(result); }
void sendAsynchEvent(const char *name, char *buf, int bufSize, NetworkManager *msgManager, bool isUdp) { lock.lock(); ExternalEvent *extEvent = findEvent(name); if(!extEvent) { printf("INTERNAL ERROR: received event message with no event structure!!"); } else extEvent->sendAsynchEvent(buf, bufSize, msgManager, isUdp); lock.unlock(); }
TEST(WTF_Condition, TimeoutTimesOut) { Lock lock; Condition condition; lock.lock(); bool result = condition.waitFor( lock, std::chrono::microseconds(10000), [] () -> bool { return false; }); lock.unlock(); EXPECT_EQ(false, result); }
void RenderTarget::stop() { if (isActive()) { CCPlus::stop(); return; } if (isPending()) { renderLock.lock(); pendingTarget = 0; renderLock.unlock(); return; } }