XRootD
XrdFfsQueue.hh File Reference
#include <pthread.h>
+ Include dependency graph for XrdFfsQueue.hh:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  XrdFfsQueueTasks
 

Functions

unsigned int XrdFfsQueue_count_tasks ()
 
int XrdFfsQueue_count_workers ()
 
struct XrdFfsQueueTasksXrdFfsQueue_create_task (void *(*func)(void *), void **args, short initstat)
 
int XrdFfsQueue_create_workers (int n)
 
void XrdFfsQueue_free_task (struct XrdFfsQueueTasks *task)
 
int XrdFfsQueue_remove_workers (int n)
 
void XrdFfsQueue_wait_task (struct XrdFfsQueueTasks *task)
 

Function Documentation

◆ XrdFfsQueue_count_tasks()

unsigned int XrdFfsQueue_count_tasks ( )

Definition at line 131 of file XrdFfsQueue.cc.

132 {
133  unsigned int que_len = 0;
134  pthread_mutex_lock(&XrdFfsQueueTaskque_mutex);
135  if (XrdFfsQueueTaskque_head != NULL && XrdFfsQueueTaskque_tail != NULL) {
138  else
139 // this is wrong:
140 // que_len = (unsigned int)2147483647 - (XrdFfsQueueTaskque_head->id - XrdFfsQueueTaskque_tail->id) + 1;
141 
142 //not accepted by c89
143 // que_len = (unsigned int)4294967295 - (XrdFfsQueueTaskque_head->id - XrdFfsQueueTaskque_tail->id) + 1;
144 
145 //this is not quite correct, but I imagine that the queue will never by so long >= 2147483647
146  que_len = (unsigned int)2147483647 - (XrdFfsQueueTaskque_head->id - XrdFfsQueueTaskque_tail->id) + 1+(unsigned int)2147483647+1;
147  }
148  pthread_mutex_unlock(&XrdFfsQueueTaskque_mutex);
149  return que_len;
150 }
struct XrdFfsQueueTasks * XrdFfsQueueTaskque_head
Definition: XrdFfsQueue.cc:39
pthread_mutex_t XrdFfsQueueTaskque_mutex
Definition: XrdFfsQueue.cc:42
struct XrdFfsQueueTasks * XrdFfsQueueTaskque_tail
Definition: XrdFfsQueue.cc:40
unsigned int id
Definition: XrdFfsQueue.hh:43

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.

255 {
256  int i;
257  pthread_mutex_lock(&XrdFfsQueueWorker_mutex);
259  pthread_mutex_unlock(&XrdFfsQueueWorker_mutex);
260  return i;
261 }
pthread_mutex_t XrdFfsQueueWorker_mutex
Definition: XrdFfsQueue.cc:188
unsigned short XrdFfsQueueNworkers
Definition: XrdFfsQueue.cc:189

References XrdFfsQueueNworkers, and XrdFfsQueueWorker_mutex.

Referenced by XrdFfsMisc_xrd_init().

+ 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.

98 {
99  struct XrdFfsQueueTasks *task = (struct XrdFfsQueueTasks*) malloc(sizeof(struct XrdFfsQueueTasks));
100  task->func = func;
101  task->args = args;
102  task->done = ( (initstat == -1)? -1 : 0); /* -1 means this task is meant to kill a worker thread */
103 
104  pthread_mutex_init(&task->mutex, NULL);
105  pthread_cond_init(&task->cond, NULL);
106 
107  XrdFfsQueue_enqueue(task);
108  return task;
109 }
void XrdFfsQueue_enqueue(struct XrdFfsQueueTasks *task)
Definition: XrdFfsQueue.cc:45
pthread_cond_t cond
Definition: XrdFfsQueue.hh:38
pthread_mutex_t mutex
Definition: XrdFfsQueue.hh:37
void *(* func)(void *)
Definition: XrdFfsQueue.hh:40

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.

193 {
194  int i, rc, *id;
195  pthread_t *thread;
196  pthread_attr_t attr;
197  size_t stacksize = 2*1024*1024;
198 
199  pthread_attr_init(&attr);
200  pthread_attr_setstacksize(&attr, stacksize);
201  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
202 
203  pthread_mutex_lock(&XrdFfsQueueWorker_mutex);
204  for (i = 0; i < n; i++)
205  {
206  id = (int*) malloc(sizeof(int));
207  *id = XrdFfsQueueWorker_id++;
208  thread = (pthread_t*) malloc(sizeof(pthread_t));
209  if (thread == NULL)
210  {
212  break;
213  }
214  rc = pthread_create(thread, &attr, XrdFfsQueue_worker, id);
215  if (rc != 0)
216  {
218  break;
219  }
220  pthread_detach(*thread);
221  free(thread);
222  }
223  pthread_attr_destroy(&attr);
224  XrdFfsQueueNworkers += i;
225  pthread_mutex_unlock(&XrdFfsQueueWorker_mutex);
226  return i;
227 }
unsigned int XrdFfsQueueWorker_id
Definition: XrdFfsQueue.cc:190
void * XrdFfsQueue_worker(void *x)
Definition: XrdFfsQueue.cc:154

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

Referenced by XrdFfsMisc_xrd_init().

+ Here is the call graph for this function:
+ 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.

112 {
113  pthread_mutex_destroy(&task->mutex);
114  pthread_cond_destroy(&task->cond);
115  task->func = NULL;
116  task->args = NULL;
117  task->next = NULL;
118  task->prev = NULL;
119  free(task);
120  task = NULL;
121 }
struct XrdFfsQueueTasks * prev
Definition: XrdFfsQueue.hh:45
struct XrdFfsQueueTasks * next
Definition: XrdFfsQueue.hh:44

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.

230 {
231  int i;
232  struct XrdFfsQueueTasks *task;
233 
234  pthread_mutex_lock(&XrdFfsQueueWorker_mutex);
235  if (XrdFfsQueueNworkers == 0)
236  n = 0;
237  else if (n > XrdFfsQueueNworkers)
238  {
241  }
242  else
243  XrdFfsQueueNworkers -= n;
244  for (i = 0; i < n; i++)
245  {
246  task = XrdFfsQueue_create_task(NULL, NULL, -1);
247  XrdFfsQueue_wait_task(task);
248  XrdFfsQueue_free_task(task);
249  }
250  pthread_mutex_unlock(&XrdFfsQueueWorker_mutex);
251  return n;
252 }
void XrdFfsQueue_free_task(struct XrdFfsQueueTasks *task)
Definition: XrdFfsQueue.cc:111
struct XrdFfsQueueTasks * XrdFfsQueue_create_task(void *(*func)(void *), void **args, short initstat)
Definition: XrdFfsQueue.cc:97
void XrdFfsQueue_wait_task(struct XrdFfsQueueTasks *task)
Definition: XrdFfsQueue.cc:123

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

+ Here is the call graph for this function:

◆ XrdFfsQueue_wait_task()

void XrdFfsQueue_wait_task ( struct XrdFfsQueueTasks task)

Definition at line 123 of file XrdFfsQueue.cc.

124 {
125  pthread_mutex_lock(&task->mutex);
126  if (task->done != 1)
127  pthread_cond_wait(&task->cond, &task->mutex);
128  pthread_mutex_unlock(&task->mutex);
129 }

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

Referenced by XrdFfsQueue_remove_workers().

+ Here is the caller graph for this function: