C++ (Cpp) pool_removeの例

コード例 #1

ファイル: server.c プロジェクト: waten1992/work_learning

void *my_thread(void *message)
{
	printf("tid : %u \n",pthread_self());
	pthread_detach(pthread_self());
	while(1)
	{
		size_t fd = pool_remove(&sp);
		int recv_len = 0;	
		char buff[4096] ;
        memset(buff,0,4096);
    while(1)
	  {
		  if((recv_len = recv(fd, buff, sizeof(buff), 0)) > 0) {
		    printf("recieve data from client : %s\n", buff);
		  }
      else if(recv_len == -1) {
            if (errno == EWOULDBLOCK || errno == EAGAIN)
            	printf("under O_NONBLOCK mode data didn't prepare \n");
      }
      else {
        printf("googbye client ~~~ \n");
				close(fd);
				break;
      }
	 }

	}	
}

コード例 #2

ファイル: dbase.c プロジェクト: eliasbaixas/openser-xmlrpc

/*
 * Shut down database module
 * No function should be called after this
 */
void db_mysql_close(db_con_t* _h)
{
    struct pool_con* con;

    if (!_h) {
        LM_ERR("invalid parameter value\n");
        return;
    }

    con = (struct pool_con*)_h->tail;
    if (pool_remove(con) == 1) {
        db_mysql_free_connection((struct my_con*)con);
    }

    pkg_free(_h);
}

コード例 #3

ファイル: dbase.c プロジェクト: Gaoithe/openimscore_ims

/*
 * Shut down database module
 * No function should be called after this
 */
void db_close(db_con_t* _h)
{
	struct pool_con* con;

	if (!_h) {
		LOG(L_ERR, "db_close: Invalid parameter value\n");
		return;
	}

	con = (struct pool_con*)_h->tail;
	if (pool_remove(con) != 0) {
		free_connection((struct my_con*)con);
	}

	pkg_free(_h);
}

コード例 #4

ファイル: pool.c プロジェクト: noelbk/bklib

void
pool_free(pool_t *pool, void *ptr) {
    pool_node_t *p;

    if( !ptr ) return;
    p = pool_find(pool, ptr);
    if( p ) {
	p->refcount--;
	if(p->refcount <= 0 ) { 
	    if( p->free ) {
		(*p->free)(p->ptr, p->arg);
	    }
	    else {
		free(p->ptr);
	    }
	    pool_remove(pool, ptr);
	}
    }
}

コード例 #5

ファイル: task_dispatcher.c プロジェクト: asqz/runner

static int cancel_task(struct task_dispatcher_t* td, struct task_t* task, tasks_comparator cmp)
{
   int result = -1;
   int should_fire_event = 0;

   pthread_mutex_lock(&td->lock);

   struct task_t* queued_task = pool_get_next(td->tasks, NULL);
   struct task_t* prev = NULL;
   while (queued_task != NULL)
   {
      if (cmp(queued_task, task) == 0)
      {
         LOGI("Removing task %p", queued_task);
         queued_task = pool_remove(td->tasks, queued_task);
         result = 0;

         if (should_fire_event == 0 && prev == NULL)
         {
            should_fire_event = 1;
         }
      }
      else
      {
         prev = queued_task;
         queued_task = pool_get_next(td->tasks, queued_task);
      }
   }

   if (should_fire_event)
   {
      pthread_cond_broadcast(&td->event);
   }

   pthread_mutex_unlock(&td->lock);
   return result;
}

コード例 #6

ファイル: task_dispatcher.c プロジェクト: asqz/runner

static void* working_thread(void* ctx)
{
   struct task_dispatcher_t* td = (struct task_dispatcher_t*)ctx;
   LOGI("Task dispatcher working thread started");

   pthread_mutex_lock(&td->event_lock);
   while (1)
   {
      if (pool_is_empty(td->tasks))
      {
         LOGD("Waiting for event");
         pthread_cond_wait(&td->event, &td->event_lock);
      }
      else
      {
         struct task_t* task = pool_get_next(td->tasks, NULL);

         struct timespec activate_time = {0};
         timestamp_to_timespec(&task->activate_time, &activate_time);

         timestamp_t current = {0};
         timestamp_set(&current);

         LOGD("Waiting for task [%ld:%d -> %ld:%d]", current.value.tv_sec, current.value.tv_usec, task->activate_time.value.tv_sec, task->activate_time.value.tv_usec);
         pthread_cond_timedwait(&td->event, &td->event_lock, &activate_time);
      }

      if (!td->running)
      {
         LOGI("Stopping working thread");
         break;
      }

      if (!pool_is_empty(td->tasks))
      {
         struct task_t* task = pool_get_next(td->tasks, NULL);

         timestamp_t current = {0};
         timestamp_set(&current);

         if (timestamp_diff(&current, &task->activate_time) >= 0)
         {
            pool_remove(td->tasks, task);
            LOGD("Removed task %p [queue empty %d]", task, pool_is_empty(td->tasks));

            if (task->interval > 0)
            {
               task_dispatcher_enqueue_task(td, task->callback, task->ctx, task->interval, task->interval);
            }

            pthread_mutex_unlock(&td->event_lock);

            LOGD("Running task");
            task->callback(td, task, &task->enqueue_time, &current, task->ctx);

            pthread_mutex_lock(&td->event_lock);
         }
      }
   }
   pthread_mutex_unlock(&td->event_lock);

   LOGI("Task dispatcher working thread stopped");
   return NULL;
}

コード例 #7

ファイル: pool.c プロジェクト: noelbk/bklib

void*
pool_realloc(pool_t *pool, void *ptr, size_t len) {
    pool_remove(pool, ptr);
    ptr = realloc(ptr, len);
    return pool_add(pool, ptr, 0, 0);
}