CernVM-FS  2.9.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
ConcurrentWorker< DerivedWorkerT > Class Template Reference

#include <util_concurrency.h>

Inheritance diagram for ConcurrentWorker< DerivedWorkerT >:
Collaboration diagram for ConcurrentWorker< DerivedWorkerT >:

Public Member Functions

virtual ~ConcurrentWorker ()
virtual bool Initialize ()
virtual void TearDown ()

Protected Member Functions

 ConcurrentWorker ()
< DerivedWorkerT > * 
master () const

Private Member Functions

void RegisterMaster (ConcurrentWorkers< DerivedWorkerT > *master)
- Private Member Functions inherited from SingleCopy
 SingleCopy ()

Private Attributes

< DerivedWorkerT > * 


class ConcurrentWorkers< DerivedWorkerT >

Detailed Description

template<class DerivedWorkerT>
class ConcurrentWorker< DerivedWorkerT >

Base class for worker classes that should be used in a ConcurrentWorkers swarm. These classes need to fulfill a number of requirements in order to satisfy the needs of the ConcurrentWorkers template.

Requirements: -> needs to define the following types:

  • expected_data - input data structure of the worker
  • returned_data - output data structure of the worker
  • worker_context - context structure for initialization information

-> implement a constructor that takes a pointer to its worker_context as its only parameter: AwesomeWorker(const AwesomeWorker::worker_context*) Note: do not rely on the context object to be available after the consturctor has returned!

-> needs to define the calling-operator expecting one parameter of type: const expected_data& and returning void This will be invoked for every new job the worker should process

-> inside the implementation of the described calling-operator it needs to invoke either: master()->JobSuccessful(const returned_data&) or: master()->JobFailed(const returned_data&) as its LAST operation before returning. This will keep track of finished jobs and inform the user of Concurrent- Workers about finished jobs.

-> [optional] overwrite Initialize() and/or TearDown() to do environmental setup work, before or respectively after jobs will be processed

General Reminder: You will be running in a multi-threaded environment here! Buckle up and make suitable preparations to shield yourself from serious head-ache.

Note: This implements a Curiously Recurring Template Pattern (

DerivedWorkerTthe class name of the inheriting class (f.e. class AwesomeWorker : public ConcurrentWorker<AwesomeWorker>)

Definition at line 810 of file util_concurrency.h.

Constructor & Destructor Documentation

template<class DerivedWorkerT>
virtual ConcurrentWorker< DerivedWorkerT >::~ConcurrentWorker ( )

Definition at line 812 of file util_concurrency.h.

template<class DerivedWorkerT>
ConcurrentWorker< DerivedWorkerT >::ConcurrentWorker ( )

The actual job-processing entry point. See the description of the inheriting class requirements to learn about the semantics of this methods. DO NOT FORGET TO CALL master()->JobSuccessful() OR master()->JobFinished() at the end of thismethod!!

Note: There is no way to generally define this operator, it is therefore commented out and placed here just as a reminder.

datathe data to be processed.

Definition at line 843 of file util_concurrency.h.

Member Function Documentation

template<class DerivedWorkerT>
virtual bool ConcurrentWorker< DerivedWorkerT >::Initialize ( )

Does general initialization before any jobs will get scheduled. You do not need to up-call this initialize method, since it is seen as a dummy here.

true one successful initialization

Definition at line 820 of file util_concurrency.h.

template<class DerivedWorkerT>
ConcurrentWorkers<DerivedWorkerT>* ConcurrentWorker< DerivedWorkerT >::master ( ) const

Gets a pointer to the ConcurrentWorkers object that this worker resides in

a pointer to the ConcurrentWorkers object

Definition at line 850 of file util_concurrency.h.

Referenced by swissknife::CommandMigrate::AbstractMigrationWorker< DerivedT >::operator()().

Here is the caller graph for this function:

template<class DerivedWorkerT>
void ConcurrentWorker< DerivedWorkerT >::RegisterMaster ( ConcurrentWorkers< DerivedWorkerT > *  master)

Definition at line 854 of file util_concurrency.h.

template<class DerivedWorkerT>
virtual void ConcurrentWorker< DerivedWorkerT >::TearDown ( )

Does general clean-up after the last job was processed in the worker object and it is about to vanish. You do not need to up-call this method.

Definition at line 826 of file util_concurrency.h.

Friends And Related Function Documentation

template<class DerivedWorkerT>
friend class ConcurrentWorkers< DerivedWorkerT >

Definition at line 853 of file util_concurrency.h.

Member Data Documentation

template<class DerivedWorkerT>
ConcurrentWorkers<DerivedWorkerT>* ConcurrentWorker< DerivedWorkerT >::master_

Definition at line 859 of file util_concurrency.h.

The documentation for this class was generated from the following file: