PAPIConnection* allocConnection( PAPIConnectionListener inConnectionListener, void * inUserData, PAPIListener inInternalListener, void * inInternalListenerData, PAPISocket inSocket, PAPIStatus * outStatus ) { PAPIConnection * theConnection = ( PAPIConnection * )malloc( sizeof( PAPIConnection ) ); if ( theConnection != 0 ) { theConnection->mFD = inSocket; theConnection->mFDPollTimeout = getTransactionTimeout(); theConnection->mListeners = 0; theConnection->mSavedMessage = 0; theConnection->mListenerThreadStatus = NOT_RUNNING; theConnection->mConnectionListener = inConnectionListener; theConnection->mUserData = inUserData; theConnection->mListenersMutex = newMutex(); theConnection->mSavedMessageMutex = newMutex(); theConnection->mListenerThreadStatusMutex= newMutex(); theConnection->mConnectionStateChangeMutex= newMutex(); theConnection->mInternalListener = inInternalListener; theConnection->mInternalListenerData = inInternalListenerData; theConnection->mAuthHandler = 0; theConnection->mAuthHandlerUserData = ( PAPIAuthHandlerData * )malloc( sizeof( PAPIAuthHandlerData ) ); *outStatus = PAPISuccess; } else { *outStatus = PAPIOutOfMemoryFailure; } return theConnection; }
Channel::Channel() : named(false) , sent(0) , received(0) { mutex = newMutex(); cond = newConditional(); }
Channel::Channel(const std::string &name) : named(true) , name(name) , sent(0) , received(0) { mutex = newMutex(); cond = newConditional(); }
ArchCond ArchMultithreadWindows::newCondVar() { ArchCondImpl* cond = new ArchCondImpl; cond->m_events[ArchCondImpl::kSignal] = CreateEvent(NULL, FALSE, FALSE, NULL); cond->m_events[ArchCondImpl::kBroadcast] = CreateEvent(NULL, TRUE, FALSE, NULL); cond->m_waitCountMutex = newMutex(); cond->m_waitCount = 0; return cond; }
Channel *Channel::getChannel(const std::string &name) { if (!namedChannelMutex) namedChannelMutex = newMutex(); Lock l(namedChannelMutex); if (!namedChannels.count(name)) namedChannels[name] = new Channel(name); else namedChannels[name]->retain(); return namedChannels[name]; }
ArchMultithreadPosix::ArchMultithreadPosix() : m_newThreadCalled(false), m_nextID(0) { assert(s_instance == NULL); s_instance = this; // no signal handlers for (size_t i = 0; i < kNUM_SIGNALS; ++i) { m_signalFunc[i] = NULL; m_signalUserData[i] = NULL; } // create mutex for thread list m_threadMutex = newMutex(); // create thread for calling (main) thread and add it to our // list. no need to lock the mutex since we're the only thread. m_mainThread = new ArchThreadImpl; m_mainThread->m_thread = pthread_self(); insert(m_mainThread); // install SIGWAKEUP handler. this causes SIGWAKEUP to interrupt // system calls. we use that when cancelling a thread to force it // to wake up immediately if it's blocked in a system call. we // won't need this until another thread is created but it's fine // to install it now. struct sigaction act; sigemptyset(&act.sa_mask); # if defined(SA_INTERRUPT) act.sa_flags = SA_INTERRUPT; # else act.sa_flags = 0; # endif act.sa_handler = &threadCancel; sigaction(SIGWAKEUP, &act, NULL); // set desired signal dispositions. let SIGWAKEUP through but // ignore SIGPIPE (we'll handle EPIPE). sigset_t sigset; sigemptyset(&sigset); sigaddset(&sigset, SIGWAKEUP); pthread_sigmask(SIG_UNBLOCK, &sigset, NULL); sigemptyset(&sigset); sigaddset(&sigset, SIGPIPE); pthread_sigmask(SIG_BLOCK, &sigset, NULL); }
ArchMultithreadWindows::ArchMultithreadWindows() { assert(s_instance == NULL); s_instance = this; // no signal handlers for (size_t i = 0; i < kNUM_SIGNALS; ++i) { m_signalFunc[i] = NULL; m_signalUserData[i] = NULL; } // create mutex for thread list m_threadMutex = newMutex(); // create thread for calling (main) thread and add it to our // list. no need to lock the mutex since we're the only thread. m_mainThread = new ArchThreadImpl; m_mainThread->m_thread = NULL; m_mainThread->m_id = GetCurrentThreadId(); insert(m_mainThread); }