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