HLT/BASE/AliHLTConfiguration.h

   1 // @(#) $Id$
   2
   3 #ifndef ALIHLTCONFIGURATION_H
   4 #define ALIHLTCONFIGURATION_H
   5 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   6  * See cxx source for full Copyright notice                               */
   7
   8 /* AliHLTConfiguration
   9    base class for HLT configurations
  10  */
  11
  12 #include <errno.h>
  13 #include <TObject.h>
  14 #include <TList.h>
  15 #include "AliHLTDataTypes.h"
  16 #include "AliHLTLogging.h"
  17
  18 class AliHLTConfigurationHandler;
  19 /*****************************************************************************************************
  20  *
  21  * AliHLTConfiguration
  22  *
  23  * this class describes a certain configuration af an HLT processing step by the following parameters:
  24  *  - a unique id string/name
  25  *  - the id of the component
  26  *  - the ids of the configurations it requires input from
  27  *  - the arguments, which are passed to the component when it is initialized
  28  *
  29  * The setup of a configuration requires simply the creation of a global object of class AliHLTConfiguration.
  30  * The Configuration is automatically registered in the list of available configurations. The list is used
  31  * by the handler to resolve the dependencies upon other configurations. Hierarchies can be built up in
  32  * an easy way.
  33  *
  34  * A configuration is interpreted by the Configuration Handler and transformed into a Task List.
  35  */
  36 class AliHLTConfiguration : public TObject, public AliHLTLogging {
  37  public:
  38   AliHLTConfiguration();
  39   AliHLTConfiguration(const char* id, const char* component, const char* sources, const char* arguments);
  40   virtual ~AliHLTConfiguration();
  41
  42   /****************************************************************************************************
  43    * global initialization
  44    */
  45   static int GlobalInit(AliHLTConfigurationHandler* pHandler);
  46
  47   static int GlobalDeinit();
  48
  49   /****************************************************************************************************
  50    * properties
  51    */
  52
  53   // configuration id, a unique name
  54   // overridden TObject function in order to return the configuration name instead of the class name
  55   // enables use of TList standard functions
  56   const char *GetName() const;
  57
  58   // id of the component
  59   const char* GetComponentID();
  60
  61   // print status info
  62   void PrintStatus();
  63
  64   // get a certain source
  65   AliHLTConfiguration* GetSource(const char* id);
  66
  67   // try to find a dependency recursively in the list of sources
  68   // parameter:
  69   //   id - the source to search for
  70   //   pTgtList - (optional) target list to receive the dependency tree
  71   // result:
  72   //   0 if not found
  73   //   n found in the n-th level
  74   //   dependency list in the target list
  75   int FollowDependency(const char* id, TList* pTgtList=NULL);
  76
  77   // get the number of resolved sources
  78   int GetNofSources() {return fListSources.size();}
  79
  80   // 1 if all sources are resolved
  81   // try to resolve if bAuto==1
  82   int SourcesResolved(int bAuto=0);
  83
  84   // start iteration and get the first source
  85   AliHLTConfiguration* GetFirstSource();
  86
  87   // continue iteration and get the next source
  88   AliHLTConfiguration* GetNextSource();
  89
  90   // invalidate a dependency and mark the configuration to be re-evaluted
  91   int InvalidateSource(AliHLTConfiguration* pConf);
  92
  93   // mark the configuration to be re-evaluted
  94   int InvalidateSources() {fNofSources=-1; return 0;}
  95
  96   // return the arguments array
  97   int GetArguments(int* pArgc, const char*** pArgv);
  98
  99  protected:
 100
 101
 102  private:
 103   /* extract the source configurations from the sources string
 104    */
 105   int ExtractSources();
 106
 107   /* extract arguments from the argument string
 108    */
 109   int ExtractArguments();
 110
 111   /* helper function to build a vector from an argument string
 112    */
 113   int InterpreteString(const char* arg, vector<char*>& argList);
 114
 115   const char* fID;                  // id of this configuration
 116   const char* fComponent;           // component id of this configuration
 117
 118   const char* fStringSources;                             // the 'sources' string as passed to the constructor
 119   int fNofSources;
 120   vector<AliHLTConfiguration*> fListSources;              // list of sources
 121   vector<AliHLTConfiguration*>::iterator fListSrcElement; // iterator for the above list
 122
 123   const char* fArguments;           // the arguments string as passed to the constructor
 124   int fArgc;                        // number of arguments
 125   char** fArgv;                     // argument array
 126
 127   static AliHLTConfigurationHandler* fConfigurationHandler;
 128
 129   ClassDef(AliHLTConfiguration, 0);
 130 };
 131
 132 struct AliHLTComponent_BlockData;
 133 class AliHLTComponent;
 134 class AliHLTComponentHandler;
 135
 136 /*****************************************************************************************************
 137  *
 138  * AliHLTTask
 139  *
 140  *
 141  */
 142 class AliHLTTask : public TObject, public AliHLTLogging {
 143  public:
 144   AliHLTTask();
 145   AliHLTTask(AliHLTConfiguration* fConf, AliHLTComponentHandler* pCH);
 146   virtual ~AliHLTTask();
 147
 148   /* initialize the task
 149    */
 150   int Init(AliHLTConfiguration* fConf, AliHLTComponentHandler* pCH);
 151
 152   // overridden TObject function in order to return the configuration name instead of the class name
 153   // enables use of TList standard functions
 154   const char *GetName() const;
 155
 156   /* return pointer to configuration
 157    */
 158   AliHLTConfiguration* GetConf();
 159
 160   /* return pointer to configuration
 161    */
 162   AliHLTComponent* GetComponent();
 163
 164   /* find a dependency with name/id
 165    */
 166   AliHLTTask* FindDependency(const char* id);
 167
 168   /* insert block data to the list
 169    * the data has to come from a task the current one depend on
 170    * result:
 171    *    -EEXIST : the block data from this task has already been inserted
 172    *    -ENOENT : no dependencies to the task the data is coming from
 173    */
 174   int InsertBlockData(AliHLTComponent_BlockData* pBlock, AliHLTTask* pSource);
 175
 176   /* add a dependency for the task
 177    */
 178   int SetDependency(AliHLTTask* pDep);
 179
 180   /* return number of unresolved dependencies
 181    */
 182   int CheckDependencies();
 183
 184   /* 1 if the current task depends upon pTask
 185    * 0 if no dependency
 186    */
 187   int Depends(AliHLTTask* pTask);
 188
 189   /* find a target
 190    */
 191   AliHLTTask* FindTarget(const char* id);
 192
 193   /* insert task into target list
 194    */
 195   int SetTarget(AliHLTTask* pDep);
 196
 197   // build a monolithic array of block data
 198   // result: array size, pointer to array in the target pTgt
 199   //
 200   int BuildBlockDataArray(AliHLTComponent_BlockData*& pTgt);
 201
 202   /* process the task if all dependencies are resolved
 203    * reset the source block data list
 204    */
 205   //int ProcessTask(...);
 206
 207   // clear the list of source data blocks
 208   // the list of source data blocks has to be cleared at the beginning of
 209   // a new event
 210   int ClearSourceBlocks();
 211
 212   // print the status of the task with component, dependencies and targets
 213   void PrintStatus();
 214
 215   // search task dependency list recursively to find a dependency
 216   // parameter:
 217   //   id - the task to search for
 218   //   pTgtList - (optional) target list to receive the dependency tree
 219   // result:
 220   //   0 if not found
 221   //   n found in the n-th level
 222   //   dependency list in the target list
 223   int FollowDependency(const char* id, TList* pTgtList=NULL);
 224
 225   // print the tree for a certain dependency either from the task or configuration list
 226   // each task posseses two "link lists": The configurations are the the origin of the
 227   // task list. In case of an error during the built of the task list, the dependencies
 228   // for the task list might be incomplete. In this case the configurations can give
 229   // infomation on the error reason
 230   // parameter:
 231   //   id - the dependency to search for
 232   //   bFromConfiguration (default=0) - if 0 the task dependency list is used, if one the configuration list is used
 233   void PrintDependencyTree(const char* id, int bFromConfiguration=0);
 234
 235  private:
 236   AliHLTConfiguration* fpConfiguration;
 237   AliHLTComponent* fpComponent;
 238   vector<AliHLTComponent_BlockData*> fSources;
 239   TList fListTargets;
 240   TList fListDependencies;
 241
 242   AliHLTComponent_BlockData* fpBlockDataArray;
 243
 244   ClassDef(AliHLTTask, 0);
 245 };
 246
 247 class AliHLTConfigurationHandler : public AliHLTLogging {
 248  public:
 249   AliHLTConfigurationHandler();
 250   AliHLTConfigurationHandler(AliHLTConfiguration* pConf);
 251   virtual ~AliHLTConfigurationHandler();
 252
 253   /****************************************************************************************************
 254    * registration
 255    */
 256
 257   // register a configuration to the global list of configurations
 258   int RegisterConfiguration(AliHLTConfiguration* pConf);
 259
 260   // create a configuration and register it
 261   int CreateConfiguration(const char* id, const char* component, const char* sources, const char* arguments);
 262
 263   // remove a configuration from the global list
 264   int RemoveConfiguration(AliHLTConfiguration* pConf);
 265   int RemoveConfiguration(const char* id);
 266
 267   // find a configuration from the global list
 268   AliHLTConfiguration* FindConfiguration(const char* id);
 269
 270   // print the registered configurations to the logging function
 271   void PrintConfigurations();
 272
 273
 274  private:
 275   static TList fListConfigurations; // the list of registered configurations
 276   static TList fListDynamicConfigurations; // the list of dynamic configurations (for proper cleanup)
 277
 278   ClassDef(AliHLTConfigurationHandler, 0);
 279 };
 280
 281 #endif