threadpool create_threadpool(int num_threads_in_pool)
{
_threadpool *pool;
// sanity check the argument
if ((num_threads_in_pool <= 0) || (num_threads_in_pool > MAXT_IN_POOL))
return NULL;
pool = (_threadpool *) malloc(sizeof(_threadpool));
if (pool == NULL) {
fprintf(stderr, "Out of memory creating a new threadpool!\n");
return NULL;
}
// add your code here to initialize the newly created threadpool
sp_thread_mutex_init( &pool->tp_mutex, NULL );
sp_thread_cond_init( &pool->tp_idle, NULL );
sp_thread_cond_init( &pool->tp_full, NULL );
sp_thread_cond_init( &pool->tp_empty, NULL );
pool->tp_max_index = num_threads_in_pool;
pool->tp_index = 0;
pool->tp_stop = 0;
pool->tp_total = 0;
pool->tp_list = ( _thread ** )malloc( sizeof( void * ) * MAXT_IN_POOL );
memset( pool->tp_list, 0, sizeof( void * ) * MAXT_IN_POOL );
return (threadpool) pool;
}
SP_IocpLFServer :: SP_IocpLFServer( const char * bindIP, int port, SP_HandlerFactory * handlerFactory )
{
snprintf( mBindIP, sizeof( mBindIP ), "%s", bindIP );
mPort = port;
mIsShutdown = 0;
mIsRunning = 0;
mEventArg = new SP_IocpEventArg( 600 );
mMaxThreads = 4;
mAcceptArg = (SP_IocpAcceptArg_t*)malloc( sizeof( SP_IocpAcceptArg_t ) );
memset( mAcceptArg, 0, sizeof( SP_IocpAcceptArg_t ) );
mAcceptArg->mMaxConnections = 256;
mAcceptArg->mReqQueueSize = 128;
mAcceptArg->mRefusedMsg = strdup( "System busy, try again later." );
mAcceptArg->mHandlerFactory = handlerFactory;
mAcceptArg->mEventArg = mEventArg;
mThreadPool = NULL;
mCompletionHandler = NULL;
sp_thread_mutex_init( &mMutex, NULL );
mCompletionPort = mEventArg->getCompletionPort();
}
int dispatch_threadpool(threadpool from_me, dispatch_fn dispatch_to_here, void *arg)
{
int ret = 0;
_threadpool *pool = (_threadpool *) from_me;
sp_thread_attr_t attr;
_thread * thread = NULL;
// add your code here to dispatch a thread
sp_thread_mutex_lock( &pool->tp_mutex );
// printf("==========dispatch_threadpool\n");
while( pool->tp_index <= 0 && pool->tp_total >= pool->tp_max_index ) {
//printf("all thread is busy!~~\n");
sp_thread_cond_wait( &pool->tp_idle, &pool->tp_mutex );
}
if( pool->tp_index <= 0 ) {
_thread * thread = ( _thread * )malloc( sizeof( _thread ) );
memset( &( thread->id ), 0, sizeof( thread->id ) );
sp_thread_mutex_init( &thread->mutex, NULL );
sp_thread_cond_init( &thread->cond, NULL );
thread->fn = dispatch_to_here;
thread->arg = arg;
thread->parent = pool;
sp_thread_attr_init( &attr );
sp_thread_attr_setdetachstate( &attr, SP_THREAD_CREATE_DETACHED );
if( 0 == sp_thread_create( &thread->id, &attr, wrapper_fn, thread ) ) {
pool->tp_total++;
// printf( "create thread#%ld\n", thread->id );
} else {
ret = -1;
//printf( "cannot create thread\n" );
sp_thread_mutex_destroy( &thread->mutex );
sp_thread_cond_destroy( &thread->cond );
free( thread );
}
} else {
pool->tp_index--;
thread = pool->tp_list[ pool->tp_index ];
pool->tp_list[ pool->tp_index ] = NULL;
thread->fn = dispatch_to_here;
thread->arg = arg;
thread->parent = pool;
sp_thread_mutex_lock( &thread->mutex );
sp_thread_cond_signal( &thread->cond ) ;
sp_thread_mutex_unlock ( &thread->mutex );
}
sp_thread_mutex_unlock( &pool->tp_mutex );
return ret;
}
void SP_CacheItem :: init()
{
mKey = NULL;
mDataBlock = NULL;
mDataBytes = mBlockCapacity = 0;
mRefCount = 1;
mCasUnique = 0;
sp_thread_mutex_init( &mMutex, NULL );
}
SP_OnlineManager :: SP_OnlineManager()
{
sp_thread_mutex_init( &mMutex, NULL );
}
SP_BlockingQueue :: SP_BlockingQueue()
{
mQueue = new SP_CircleQueue();
sp_thread_mutex_init( &mMutex, NULL );
sp_thread_cond_init( &mCond, NULL );
}
SP_OnlineSidList :: SP_OnlineSidList()
{
sp_thread_mutex_init( &mMutex, NULL );
}
