#include "XrdFfs/XrdFfsQueue.hh"
#include <cstdlib>

Include dependency graph for XrdFfsQueue.cc:

Functions
unsigned int	XrdFfsQueue_count_tasks ()

int	XrdFfsQueue_count_workers ()

struct XrdFfsQueueTasks *	XrdFfsQueue_create_task (void (func)(void ), void *args, short initstat)

int	XrdFfsQueue_create_workers (int n)

struct XrdFfsQueueTasks *	XrdFfsQueue_dequeue ()

void	XrdFfsQueue_enqueue (struct XrdFfsQueueTasks *task)

void	XrdFfsQueue_free_task (struct XrdFfsQueueTasks *task)

int	XrdFfsQueue_remove_workers (int n)

void	XrdFfsQueue_wait_task (struct XrdFfsQueueTasks *task)

void *	XrdFfsQueue_worker (void *x)

Variables
unsigned int	XrdFfsQueueNext_task_id = 0

unsigned short	XrdFfsQueueNworkers = 0

pthread_cond_t	XrdFfsQueueTaskque_cond = PTHREAD_COND_INITIALIZER

struct XrdFfsQueueTasks *	XrdFfsQueueTaskque_head = NULL

pthread_mutex_t	XrdFfsQueueTaskque_mutex = PTHREAD_MUTEX_INITIALIZER

struct XrdFfsQueueTasks *	XrdFfsQueueTaskque_tail = NULL

unsigned int	XrdFfsQueueWorker_id = 0

pthread_mutex_t	XrdFfsQueueWorker_mutex

Function Documentation

◆ XrdFfsQueue_count_tasks()

unsigned int XrdFfsQueue_count_tasks ( )

Definition at line 131 of file XrdFfsQueue.cc.

 {
     unsigned int que_len = 0;
     pthread_mutex_lock(&XrdFfsQueueTaskque_mutex);
     if (XrdFfsQueueTaskque_head != NULL && XrdFfsQueueTaskque_tail != NULL) {
         if (XrdFfsQueueTaskque_tail->id > XrdFfsQueueTaskque_head->id)
             que_len = XrdFfsQueueTaskque_tail->id - XrdFfsQueueTaskque_head->id;
         else
 // this is wrong: 
 //          que_len = (unsigned int)2147483647 - (XrdFfsQueueTaskque_head->id - XrdFfsQueueTaskque_tail->id) + 1;
  
 //not accepted by c89
 //          que_len = (unsigned int)4294967295 - (XrdFfsQueueTaskque_head->id - XrdFfsQueueTaskque_tail->id) + 1;
  
 //this is not quite correct, but I imagine that the queue will never by so long >= 2147483647
           que_len = (unsigned int)2147483647 - (XrdFfsQueueTaskque_head->id - XrdFfsQueueTaskque_tail->id) + 1+(unsigned int)2147483647+1;
     }
     pthread_mutex_unlock(&XrdFfsQueueTaskque_mutex);
     return que_len;
 }

References XrdFfsQueueTasks::id, XrdFfsQueueTaskque_head, XrdFfsQueueTaskque_mutex, and XrdFfsQueueTaskque_tail.

Referenced by XrdFfsPosix_statall().

Here is the caller graph for this function:

◆ XrdFfsQueue_count_workers()

int XrdFfsQueue_count_workers ( )

Definition at line 254 of file XrdFfsQueue.cc.

 {
     int i;
     pthread_mutex_lock(&XrdFfsQueueWorker_mutex);
     i = XrdFfsQueueNworkers;
     pthread_mutex_unlock(&XrdFfsQueueWorker_mutex);
     return i;
 }

References XrdFfsQueueNworkers, and XrdFfsQueueWorker_mutex.

Referenced by XrdFfsMisc_xrd_init(), xrootdfs_getxattr(), xrootdfs_init(), and xrootdfs_setxattr().

Here is the caller graph for this function:

◆ XrdFfsQueue_create_task()

struct XrdFfsQueueTasks* XrdFfsQueue_create_task	(	void ()(void *)	func,
		void **	args,
		short	initstat
	)

Definition at line 97 of file XrdFfsQueue.cc.

 {
     struct XrdFfsQueueTasks *task = (struct XrdFfsQueueTasks*) malloc(sizeof(struct XrdFfsQueueTasks));
     task->func = func;
     task->args = args;
     task->done = ( (initstat == -1)? -1 : 0); /* -1 means this task is meant to kill a worker thread */
  
     pthread_mutex_init(&task->mutex, NULL);
     pthread_cond_init(&task->cond, NULL);
  
     XrdFfsQueue_enqueue(task);
     return task;
 }

References XrdFfsQueueTasks::args, XrdFfsQueueTasks::cond, XrdFfsQueueTasks::done, XrdFfsQueueTasks::func, XrdFfsQueueTasks::mutex, and XrdFfsQueue_enqueue().

Referenced by XrdFfsPosix_deleteall(), XrdFfsPosix_readdirall(), XrdFfsPosix_statall(), XrdFfsPosix_statvfsall(), and XrdFfsQueue_remove_workers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ XrdFfsQueue_create_workers()

int XrdFfsQueue_create_workers ( int n )

Definition at line 192 of file XrdFfsQueue.cc.

 {
     int i, rc, *id;
     pthread_t *thread;
     pthread_attr_t attr;
     size_t stacksize = 2*1024*1024;
  
     pthread_attr_init(&attr);
     pthread_attr_setstacksize(&attr, stacksize);
     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
     
     pthread_mutex_lock(&XrdFfsQueueWorker_mutex);
     for (i = 0; i < n; i++)
     {
         id = (int*) malloc(sizeof(int));
         *id = XrdFfsQueueWorker_id++;
         thread = (pthread_t*) malloc(sizeof(pthread_t));
         if (thread == NULL) 
         {
             XrdFfsQueueWorker_id--;
             break;
         }
         rc = pthread_create(thread, &attr, XrdFfsQueue_worker, id);
         if (rc != 0) 
         {
             XrdFfsQueueWorker_id--;
             break;
         }
         pthread_detach(*thread);
         free(thread);
     }
     pthread_attr_destroy(&attr);
     XrdFfsQueueNworkers += i;
     pthread_mutex_unlock(&XrdFfsQueueWorker_mutex);
     return i;
 }

References XrdFfsQueueTasks::id, XrdFfsQueue_worker(), XrdFfsQueueNworkers, XrdFfsQueueWorker_id, and XrdFfsQueueWorker_mutex.

Referenced by XrdFfsMisc_xrd_init(), xrootdfs_init(), and xrootdfs_setxattr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ XrdFfsQueue_dequeue()

struct XrdFfsQueueTasks* XrdFfsQueue_dequeue ( )

Definition at line 70 of file XrdFfsQueue.cc.

 {
     struct XrdFfsQueueTasks *head;
     while (pthread_mutex_lock(&XrdFfsQueueTaskque_mutex) == 0)
         if (XrdFfsQueueTaskque_head == NULL)
         {
             pthread_cond_wait(&XrdFfsQueueTaskque_cond, &XrdFfsQueueTaskque_mutex);
             pthread_mutex_unlock(&XrdFfsQueueTaskque_mutex);
         }
         else
             break;
  
     head = XrdFfsQueueTaskque_head;
     XrdFfsQueueTaskque_head = XrdFfsQueueTaskque_head->next;
  
     head->next = NULL;
     head->prev = NULL;        
  
     if (XrdFfsQueueTaskque_head == NULL)
         XrdFfsQueueTaskque_tail = NULL;
  
     pthread_mutex_unlock(&XrdFfsQueueTaskque_mutex);
     return head;
 }

References XrdFfsQueueTasks::next, XrdFfsQueueTasks::prev, XrdFfsQueueTaskque_cond, XrdFfsQueueTaskque_head, XrdFfsQueueTaskque_mutex, and XrdFfsQueueTaskque_tail.

Referenced by XrdFfsQueue_worker().

Here is the caller graph for this function:

◆ XrdFfsQueue_enqueue()

void XrdFfsQueue_enqueue ( struct XrdFfsQueueTasks * task )

Definition at line 45 of file XrdFfsQueue.cc.

 {
     pthread_mutex_lock(&XrdFfsQueueTaskque_mutex);
  
     task->id = XrdFfsQueueNext_task_id + 1;
     XrdFfsQueueNext_task_id = task->id;
     if (XrdFfsQueueTaskque_tail == NULL) 
     {
         XrdFfsQueueTaskque_head = task;
         XrdFfsQueueTaskque_tail = task;
         task->next = NULL;
         pthread_cond_broadcast(&XrdFfsQueueTaskque_cond);
     }
     else
     {
         task->prev = XrdFfsQueueTaskque_tail;
         task->next = NULL;
         XrdFfsQueueTaskque_tail->next = task;
         XrdFfsQueueTaskque_tail = task;
     }
  
     pthread_mutex_unlock(&XrdFfsQueueTaskque_mutex);
     return;
 }

References XrdFfsQueueTasks::id, XrdFfsQueueTasks::next, XrdFfsQueueTasks::prev, XrdFfsQueueNext_task_id, XrdFfsQueueTaskque_cond, XrdFfsQueueTaskque_head, XrdFfsQueueTaskque_mutex, and XrdFfsQueueTaskque_tail.

Referenced by XrdFfsQueue_create_task().

Here is the caller graph for this function:

◆ XrdFfsQueue_free_task()

void XrdFfsQueue_free_task ( struct XrdFfsQueueTasks * task )

Definition at line 111 of file XrdFfsQueue.cc.

 {
     pthread_mutex_destroy(&task->mutex);
     pthread_cond_destroy(&task->cond);
     task->func = NULL;
     task->args = NULL;
     task->next = NULL;
     task->prev = NULL;
     free(task);
     task = NULL;
 }

References XrdFfsQueueTasks::args, XrdFfsQueueTasks::cond, XrdFfsQueueTasks::func, XrdFfsQueueTasks::mutex, XrdFfsQueueTasks::next, and XrdFfsQueueTasks::prev.

Referenced by XrdFfsQueue_remove_workers().

Here is the caller graph for this function:

◆ XrdFfsQueue_remove_workers()

int XrdFfsQueue_remove_workers ( int n )

Definition at line 229 of file XrdFfsQueue.cc.

 {
     int i;
     struct XrdFfsQueueTasks *task;
  
     pthread_mutex_lock(&XrdFfsQueueWorker_mutex);
     if (XrdFfsQueueNworkers == 0)
         n = 0;
     else if (n > XrdFfsQueueNworkers)
     {
         n = XrdFfsQueueNworkers;
         XrdFfsQueueNworkers = 0;
     }
     else
         XrdFfsQueueNworkers -= n;
     for (i = 0; i < n; i++)
     {
         task = XrdFfsQueue_create_task(NULL, NULL, -1);
         XrdFfsQueue_wait_task(task);
         XrdFfsQueue_free_task(task);
     }
     pthread_mutex_unlock(&XrdFfsQueueWorker_mutex);
     return n;
 }

References XrdFfsQueue_create_task(), XrdFfsQueue_free_task(), XrdFfsQueue_wait_task(), XrdFfsQueueNworkers, and XrdFfsQueueWorker_mutex.

Referenced by xrootdfs_setxattr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ XrdFfsQueue_wait_task()

void XrdFfsQueue_wait_task ( struct XrdFfsQueueTasks * task )

Definition at line 123 of file XrdFfsQueue.cc.

 {
     pthread_mutex_lock(&task->mutex);
     if (task->done != 1)
         pthread_cond_wait(&task->cond, &task->mutex);
     pthread_mutex_unlock(&task->mutex);
 }

References XrdFfsQueueTasks::cond, XrdFfsQueueTasks::done, and XrdFfsQueueTasks::mutex.

Referenced by XrdFfsQueue_remove_workers().

Here is the caller graph for this function:

◆ XrdFfsQueue_worker()

void* XrdFfsQueue_worker ( void * x )

Definition at line 154 of file XrdFfsQueue.cc.

 {
     struct XrdFfsQueueTasks *task;
     short quit = 0;
  
     loop:
     task = XrdFfsQueue_dequeue();
  
     if (task->done == -1) // terminate this worker thread
         quit = 1;
  
     pthread_mutex_lock(&task->mutex);
 #ifdef QUEDEBUG
     printf("worker %d on task %d\n", wid, task->id);
 #endif
     if (!quit)
         (task->func)(task->args);
  
     task->done = 1;
     pthread_cond_signal(&task->cond);
     pthread_mutex_unlock(&task->mutex);
     if (quit)
     {
 #ifdef QUEDEBUG
         printf("worker %d is leaving\n", wid);
 #endif
         free(x);
 //        pthread_exit(NULL);
         return(NULL);
     }
     else
         goto loop;
 }