/**
* Main function
*/
int main() {
// We create a condition
CondId cond = CondCreate("TableCondition");
// We create a thread to fill it and one to read it
ThreadId thread_fill = newThread("FillThread", (int)fillThread, (int)cond);
ThreadId thread_read = newThread("ReadThread", (int)readThread, (int)cond);
// Wait the two threads before returning
if (Join(thread_fill) < 0)
n_printf("Error joining first thread");
n_printf("Thread fill just finished");
if (Join(thread_read) < 0)
n_printf("Error joining second thread");
n_printf("Thread read just finished");
// Delete the condition
if (CondDestroy(cond) < 0)
n_printf("Error destroy lock");
// Exit the program
return 0;
}
void BuildQueueDestroy(BuildQueue* queue)
{
Log(kDebug, "destroying build queue");
const BuildQueueConfig* config = &queue->m_Config;
MutexLock(&queue->m_Lock);
queue->m_QuitSignalled = true;
MutexUnlock(&queue->m_Lock);
CondBroadcast(&queue->m_WorkAvailable);
for (int i = 0, thread_count = config->m_ThreadCount; i < thread_count; ++i)
{
if (i > 0)
{
Log(kDebug, "joining with build thread %d", i);
ThreadJoin(queue->m_Threads[i]);
}
ThreadStateDestroy(&queue->m_ThreadState[i]);
}
// Deallocate storage.
MemAllocHeap* heap = queue->m_Config.m_Heap;
HeapFree(heap, queue->m_ExpensiveWaitList);
HeapFree(heap, queue->m_Queue);
CondDestroy(&queue->m_WorkAvailable);
MutexDestroy(&queue->m_Lock);
// Unblock all signals on the main thread.
SignalHandlerSetCondition(nullptr);
SignalBlockThread(false);
}
TInt CTestCondwait::TestCond411()
{
int errsum=0, err = 0;
int retval = 0;
ThreadData lThreadData;
sem_t lSignalSemaphore;
sem_t lSuspendSemaphore;
sem_t lTestSemaphore;
pthread_mutex_t lTestMutex;
pthread_cond_t lTestCondVar;
pthread_condattr_t lCondAttr;
pthread_mutexattr_t lTestMutexAttr;
pthread_mutexattr_t defaultattr;
pthread_mutexattr_t errorcheckattr;
pthread_mutexattr_t recursiveattr;
pthread_mutexattr_init(&defaultattr);
pthread_mutexattr_init(&errorcheckattr);
pthread_mutexattr_init(&recursiveattr);
pthread_mutexattr_settype(&errorcheckattr,PTHREAD_MUTEX_ERRORCHECK);
pthread_mutexattr_settype(&recursiveattr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_t l_staticmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t l_errorcheckmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
pthread_mutex_t l_recursivemutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_cond_t l_staticcondvar = PTHREAD_COND_INITIALIZER;
CommonData lCommonData;
lCommonData.iStaticMutex = &l_staticmutex;
lCommonData.iErrorCheckMutex = &l_errorcheckmutex;
lCommonData.iRecursiveMutex = &l_recursivemutex;
lCommonData.iStaticCondVar = &l_staticcondvar;
retval = sem_init(&lSignalSemaphore,0,0);
if(retval != 0)
{
return retval;
}
retval = sem_init(&lSuspendSemaphore,0,0);
if(retval != 0)
{
return retval;
}
lThreadData.iSignalSemaphore = &lSignalSemaphore;
lThreadData.iSuspendSemaphore = &lSuspendSemaphore;
lThreadData.iTestSemaphore = &lTestSemaphore;
lThreadData.iTestMutex = &lTestMutex;
lThreadData.iTestMutexAttr = &lTestMutexAttr;
lThreadData.iTestCondVar = &lTestCondVar;
lThreadData.iDefaultAttr = &defaultattr;
lThreadData.iErrorcheckAttr = &errorcheckattr;
lThreadData.iRecursiveAttr = &recursiveattr;
lThreadData.iCondAttr = &lCondAttr;
for (int loop = 0; loop < EThreadMain; loop++)
{
g_spinFlag[loop] = true;
}
lThreadData.iSuspending = false;
lThreadData.iSpinCounter = 0;
lThreadData.iCurrentCommand = -1;
lThreadData.iSelf = EThreadMain;
lThreadData.iValue = 0;
lThreadData.iRetValue = 0;
lThreadData.ierrno = 0;
lThreadData.iExpectederrno = 0;
lThreadData.iTimes = 0;
lThreadData.iStopped = false;
lThreadData.iCommonData = &lCommonData;
retval = CondInit(&lThreadData);
retval = MutexInitNULL(&lThreadData);
fp=func;
retval = ThreadCreate(&lThreadData, (void*) EThread1);
WaitTillSuspended(&lThreadData, (void*) EThread1);
fp=func1;
retval = ThreadCreate(&lThreadData, (void*) EThread2);
retval = ThreadDestroy(&lThreadData, (void*) EThread1);
retval = ThreadDestroy(&lThreadData, (void*) EThread2);
retval = MutexDestroy(&lThreadData);
retval = CondDestroy(&lThreadData);
StopThread(&lThreadData);
err = pthread_cond_destroy(&l_staticcondvar);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_recursivemutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_errorcheckmutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_staticmutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&recursiveattr);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&errorcheckattr);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&defaultattr);
if(err != EINVAL)
{
errsum += err;
}
err = sem_destroy(&lSignalSemaphore);
if(err != EINVAL)
{
errsum += err;
}
err = sem_destroy(&lSuspendSemaphore);
if(err != EINVAL)
{
errsum += err;
}
return retval+errsum;
}
