Line data Source code
1 : //-*- Mode: C++ -*-
2 : // $Id$
3 :
4 : #ifndef ALIHLTCONFIGURATION_H
5 : #define ALIHLTCONFIGURATION_H
6 : //* This file is property of and copyright by the *
7 : //* ALICE Experiment at CERN, All rights reserved. *
8 : //* See cxx source for full Copyright notice *
9 :
10 : /// @file AliHLTConfiguration.h
11 : /// @author Matthias Richter
12 : /// @date
13 : /// @brief HLT configuration description for a single component.
14 : /// @note The class is used in Offline (AliRoot) context
15 :
16 : #include <vector>
17 : #include <TObject.h>
18 : #include <TList.h>
19 : #include "AliHLTDataTypes.h"
20 : #include "AliHLTLogging.h"
21 : #include "AliHLTDataBuffer.h"
22 :
23 : class AliHLTConfigurationHandler;
24 :
25 : /**
26 : * @class AliHLTConfiguration
27 : * @brief Description of HLT processing chains.
28 : *
29 : * This class describes a configuration for an HLT component by means of
30 : * the following parameters:
31 : * - configuration id: a unique id string/name
32 : * - component id: id returned by AliHLTComponent::GetComponentID()
33 : * - parent configuartions: ids of configurations it requires input from
34 : * - component arguments: passed to the component when it is initialized
35 : *
36 : * The definition of a configuration requires simply the creation of an object
37 : * of type @ref AliHLTConfiguration.
38 : * <pre>
39 : * AliHLTConfiguration myprocessor("MyProcessor", "Dummy", "publisher", "-output_percentage 80")
40 : * </pre>
41 : *
42 : * The Configuration is automatically registered in the list of available
43 : * configurations maintained by the @ref AliHLTConfigurationHandler.
44 : * The list is used to resolve the dependencies on other configurations.
45 : * Hierarchies can be built up by specifying the configuration id of parent
46 : * configurations as input in the .
47 : * A configuration entry is persistent and must be explicitly removed from
48 : * the AliHLTConfigurationHandler if desired.
49 : *
50 : * The registration mechanism requires the HLT system to be available. The
51 : * global instance of AliHLTSystem is created and retrieved by
52 : * <pre>
53 : * // setup the HLT system
54 : * AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
55 : * </pre>
56 : *
57 : * A configuration is transformed into a list of AliHLTTask objects by the
58 : * function AliHLTSystem::BuildTaskList().
59 : *
60 : * This class is only used in the HLT offline environment, see @ref alihlt_system
61 : * for more details.
62 : *
63 : * @ingroup alihlt_system
64 : */
65 : class AliHLTConfiguration : public TObject, public AliHLTLogging {
66 : public:
67 : /**
68 : * standard constructor. The configuration is automatically registered in the
69 : * global configuration manager
70 : */
71 : AliHLTConfiguration();
72 : /**
73 : * constructor. The configuration is automatically registered in the
74 : * global configuration manager
75 : * @param id unique id of the configuration
76 : * @param component component id
77 : * @param sources blank separated list of source configuration ids
78 : * @param arguments argument string passed to the component at initialization
79 : * @param bufsize size of the output buffer in byte, the string can contain a
80 : * number prepended by a unit, e.g. 1M, allowed units 'k' and 'M'
81 : */
82 : AliHLTConfiguration(const char* id, const char* component,
83 : const char* sources, const char* arguments,
84 : const char* bufsize=NULL);
85 : /** copy constructor */
86 : AliHLTConfiguration(const AliHLTConfiguration& src);
87 : /** assignment op */
88 : AliHLTConfiguration& operator=(const AliHLTConfiguration& src);
89 : /** destructor */
90 : virtual ~AliHLTConfiguration();
91 :
92 : /*****************************************************************************
93 : * properties of the configuration
94 : */
95 :
96 : /**
97 : * Get configuration id, a unique name
98 : * This is an overridden TObject function in order to return the configuration
99 : * name instead of the class name. Enables use of TList standard functions.
100 : * @return configuration id
101 : */
102 : const char *GetName() const;
103 :
104 : /**
105 : * Get id of the component.
106 : * The id is a unique string.
107 : * @return id of the component
108 : */
109 0 : const char* GetComponentID() const {return fComponent;}
110 :
111 : /**
112 : * Return the source string.
113 : */
114 0 : const char* GetSourceSettings() const {return fStringSources;}
115 :
116 : /**
117 : * Return the argument string.
118 : */
119 0 : const char* GetArgumentSettings() const {return fArguments;}
120 :
121 : /**
122 : * Print status info.
123 : * Short summary on id, component, sources and unresolved sources.
124 : */
125 : void PrintStatus() const;
126 :
127 : /**
128 : * overloaded from TObject
129 : * options:
130 : * status - print status including the resolved sources
131 : */
132 : virtual void Print(const char* option="") const;
133 :
134 : /**
135 : * Get a certain source.
136 : * @param id of the source configuration
137 : * @result pointer to the corresponding configuration descriptor
138 : */
139 : AliHLTConfiguration* GetSource(const char* id);
140 :
141 : /**
142 : * Try to find a dependency recursively in the list of sources.
143 : * @param id the source to search for
144 : * @param pTgtList (optional) target list to receive the dependency tree
145 : * @return
146 : * 0 if not found
147 : * n found in the n-th level
148 : * dependency list in the target list
149 : */
150 : int FollowDependency(const char* id, TList* pTgtList=NULL);
151 :
152 : /**
153 : * Get the number of resolved sources.
154 : * @return number of resolved sources
155 : */
156 0 : int GetNofSources() {return fListSources.size();}
157 :
158 : /**
159 : * Check resolving status.
160 : * @return 1 if all sources resolved, 0 if not yet extracted or not resolved
161 : */
162 : int SourcesResolved() const;
163 :
164 : /**
165 : * extract the source configurations from the sources string
166 : * builds up the internal list of source configurations
167 : * @result 1 if sources resolved, 0 if not
168 : */
169 : int ExtractSources(AliHLTConfigurationHandler* pHandler);
170 :
171 : /**
172 : * Start iteration and get the first source.
173 : * @result pointer to the first configuration descriptor
174 : */
175 : AliHLTConfiguration* GetFirstSource() const;
176 :
177 : /**
178 : * Continue iteration and get the next source.
179 : * @result pointer to the next configuration descriptor in the list
180 : */
181 : AliHLTConfiguration* GetNextSource() const;
182 :
183 : /**
184 : * Invalidate a dependency and mark the configuration to be re-evaluted.
185 : * @param pConf pointer to configuration descriptor
186 : */
187 : int InvalidateSource(AliHLTConfiguration* pConf);
188 :
189 : /**
190 : * Mark the configuration to be re-evaluted.
191 : */
192 0 : int InvalidateSources() {fNofSources=-1; return 0;}
193 :
194 : /**
195 : * Get the arguments array.
196 : * @param pArgv pointer to receive argument array pointer
197 : * @return argc if succeeded, neg. error code if failed
198 : */
199 : int GetArguments(const char*** pArgv) const;
200 :
201 : /**
202 : * Get output buffer size.
203 : * @return size in byte or -1 if not specified
204 : */
205 0 : int GetOutputBufferSize() const {return fBufferSize;}
206 :
207 : /**
208 : * Two configurations are considered equal if all properties match
209 : */
210 : bool operator==(const AliHLTConfiguration& c) const {
211 0 : return (fID==c.fID) && (fComponent==c.fComponent) && (fStringSources==c.fStringSources) && (fArguments==c.fArguments);
212 : }
213 : bool operator!=(const AliHLTConfiguration& c) const {
214 0 : return !(*this==c);
215 : }
216 :
217 : /**
218 : * Helper function to build a vector from an argument string.
219 : * The function allocates memory for each token. The caller is responsible
220 : * for cleaning the strings recursively.
221 : * @param arg pointer to argument string
222 : * @param argList target to receive the argument list
223 : */
224 : static int InterpreteString(const char* arg, vector<char*>& argList);
225 :
226 : protected:
227 :
228 :
229 : private:
230 : /* extract arguments from the argument string
231 : */
232 : int ExtractArguments();
233 :
234 : /**
235 : * Convert buffer size string to number
236 : */
237 : int ConvertSizeString(const char* strSize) const;
238 :
239 : /** id of this configuration */
240 : TString fID; // see above
241 : /** component id of this configuration */
242 : TString fComponent; // see above
243 :
244 : /** the <i>sources</i> string as passed to the constructor */
245 : TString fStringSources; // see above
246 : /** number of resolved sources, -1 indicates re-evaluation */
247 : int fNofSources; //! transient
248 : /** list of sources */
249 : vector<AliHLTConfiguration*> fListSources; //! transient
250 : /** index of the current element in the list of sources */
251 : int fListSrcElementIdx; //! transient
252 :
253 : /**
254 : * The argument string as passed to the constructor.
255 : * Specifies the arguments for the Analysys component. The string will
256 : * be parsed and the separated arguments stored in the @ref fArgv array
257 : * and @ref fArgc member.
258 : */
259 : TString fArguments; // see above
260 : /** number of arguments */
261 : int fArgc; //! transient
262 : /** argument array */
263 : char** fArgv; //! transient
264 :
265 : /** size of the output buffer */
266 : int fBufferSize; // see above
267 :
268 126 : ClassDef(AliHLTConfiguration, 0);
269 : };
270 :
271 : #endif
|
