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;
}
}
