]>
Commit | Line | Data |
---|---|---|
3495cce2 | 1 | // $Id$ |
2 | ||
3 | /************************************************************************** | |
4 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
5 | * * | |
6 | * Authors: Matthias Richter <Matthias.Richter@ift.uib.no> * | |
7 | * for The ALICE Off-line Project. * | |
8 | * * | |
9 | * Permission to use, copy, modify and distribute this software and its * | |
10 | * documentation strictly for non-commercial purposes is hereby granted * | |
11 | * without fee, provided that the above copyright notice appears in all * | |
12 | * copies and that both the copyright notice and this permission notice * | |
13 | * appear in the supporting documentation. The authors make no claims * | |
14 | * about the suitability of this software for any purpose. It is * | |
15 | * provided "as is" without express or implied warranty. * | |
16 | **************************************************************************/ | |
17 | ||
b22e91eb | 18 | /** @file AliHLTConfiguration.cxx |
19 | @author Matthias Richter | |
20 | @date | |
21 | @brief Implementation of HLT configuration handler. | |
22 | */ | |
3495cce2 | 23 | |
0c0c9d99 | 24 | #if __GNUC__>= 3 |
3495cce2 | 25 | using namespace std; |
26 | #endif | |
27 | ||
a5854ddd | 28 | #include <cerrno> |
3495cce2 | 29 | #include "AliHLTConfiguration.h" |
c38ba6f9 | 30 | #include "AliHLTConfigurationHandler.h" |
31 | #include "AliHLTTask.h" | |
3495cce2 | 32 | #include "AliHLTComponent.h" |
33 | #include "AliHLTComponentHandler.h" | |
34 | #include <iostream> | |
a5854ddd | 35 | #include <string> |
3495cce2 | 36 | |
b22e91eb | 37 | /** ROOT macro for the implementation of ROOT specific class methods */ |
3495cce2 | 38 | ClassImp(AliHLTConfiguration) |
39 | ||
40 | AliHLTConfiguration::AliHLTConfiguration() | |
85869391 | 41 | : |
42 | fID(NULL), | |
43 | fComponent(NULL), | |
44 | fStringSources(NULL), | |
45 | fNofSources(-1), | |
53feaef5 | 46 | fListSources(), |
47 | fListSrcElement(), | |
85869391 | 48 | fArguments(NULL), |
49 | fArgc(-1), | |
53feaef5 | 50 | fArgv(NULL) |
3495cce2 | 51 | { |
3495cce2 | 52 | fListSrcElement=fListSources.begin(); |
53 | } | |
54 | ||
55 | AliHLTConfiguration::AliHLTConfiguration(const char* id, const char* component, const char* sources, const char* arguments) | |
85869391 | 56 | : |
57 | fID(id), | |
58 | fComponent(component), | |
59 | fStringSources(sources), | |
60 | fNofSources(-1), | |
53feaef5 | 61 | fListSources(), |
62 | fListSrcElement(), | |
85869391 | 63 | fArguments(arguments), |
64 | fArgc(-1), | |
53feaef5 | 65 | fArgv(NULL) |
3495cce2 | 66 | { |
85869391 | 67 | fListSrcElement=fListSources.begin(); |
3495cce2 | 68 | if (id && component) { |
85465857 | 69 | if (fConfigurationHandler) { |
70 | fConfigurationHandler->RegisterConfiguration(this); | |
71 | } else { | |
72 | HLTError("no configuration handler set, abort registration"); | |
73 | } | |
3495cce2 | 74 | } |
75 | } | |
76 | ||
85869391 | 77 | AliHLTConfiguration::AliHLTConfiguration(const AliHLTConfiguration&) |
78 | : | |
53feaef5 | 79 | TObject(), |
80 | AliHLTLogging(), | |
85869391 | 81 | fID(NULL), |
82 | fComponent(NULL), | |
83 | fStringSources(NULL), | |
84 | fNofSources(-1), | |
53feaef5 | 85 | fListSources(), |
86 | fListSrcElement(), | |
85869391 | 87 | fArguments(NULL), |
88 | fArgc(-1), | |
53feaef5 | 89 | fArgv(NULL) |
85869391 | 90 | { |
91 | fListSrcElement=fListSources.begin(); | |
92 | HLTFatal("copy constructor untested"); | |
93 | } | |
94 | ||
95 | AliHLTConfiguration& AliHLTConfiguration::operator=(const AliHLTConfiguration&) | |
96 | { | |
97 | HLTFatal("assignment operator untested"); | |
98 | return *this; | |
99 | } | |
100 | ||
3495cce2 | 101 | AliHLTConfiguration::~AliHLTConfiguration() |
102 | { | |
85465857 | 103 | if (fConfigurationHandler) { |
104 | if (fConfigurationHandler->FindConfiguration(fID)!=NULL) { | |
105 | fConfigurationHandler->RemoveConfiguration(this); | |
106 | } | |
3495cce2 | 107 | } |
108 | if (fArgv != NULL) { | |
109 | if (fArgc>0) { | |
110 | for (int i=0; i<fArgc; i++) { | |
111 | delete[] fArgv[i]; | |
112 | } | |
113 | } | |
114 | delete[] fArgv; | |
115 | fArgv=NULL; | |
116 | } | |
117 | } | |
118 | ||
b22e91eb | 119 | /* the global configuration handler which is used to automatically register the configuration |
120 | */ | |
121 | AliHLTConfigurationHandler* AliHLTConfiguration::fConfigurationHandler=NULL; | |
122 | ||
85465857 | 123 | int AliHLTConfiguration::GlobalInit(AliHLTConfigurationHandler* pHandler) |
124 | { | |
125 | int iResult=0; | |
126 | if (fConfigurationHandler!=NULL) { | |
127 | fConfigurationHandler->Logging(kHLTLogWarning, "AliHLTConfiguration::GlobalInit", HLT_DEFAULT_LOG_KEYWORD, "configuration handler already initialized, overriding object %p", fConfigurationHandler); | |
128 | } | |
129 | fConfigurationHandler=pHandler; | |
130 | return iResult; | |
131 | } | |
132 | ||
133 | int AliHLTConfiguration::GlobalDeinit() | |
134 | { | |
135 | int iResult=0; | |
136 | fConfigurationHandler=NULL; | |
137 | return iResult; | |
138 | } | |
139 | ||
3495cce2 | 140 | const char* AliHLTConfiguration::GetName() const { |
141 | if (fID) | |
142 | return fID; | |
143 | return TObject::GetName(); | |
144 | } | |
145 | ||
146 | AliHLTConfiguration* AliHLTConfiguration::GetSource(const char* id) | |
147 | { | |
148 | AliHLTConfiguration* pSrc=NULL; | |
149 | if (id) { | |
150 | // first check the current element | |
151 | if (fListSrcElement!=fListSources.end() && strcmp(id, (*fListSrcElement)->GetName())==0) { | |
152 | pSrc=*fListSrcElement; | |
153 | } else { | |
154 | // check the list | |
155 | ||
156 | pSrc=GetFirstSource(); | |
157 | while (pSrc) { | |
158 | if (strcmp(id, pSrc->GetName())==0) | |
159 | break; | |
160 | pSrc=GetNextSource(); | |
161 | } | |
162 | } | |
163 | } | |
164 | return pSrc; | |
165 | } | |
166 | ||
167 | AliHLTConfiguration* AliHLTConfiguration::GetFirstSource() | |
168 | { | |
169 | AliHLTConfiguration* pSrc=NULL; | |
170 | if (fNofSources>=0 || ExtractSources()) { | |
171 | fListSrcElement=fListSources.begin(); | |
172 | if (fListSrcElement!=fListSources.end()) pSrc=*fListSrcElement; | |
173 | } | |
174 | return pSrc; | |
175 | } | |
176 | ||
177 | AliHLTConfiguration* AliHLTConfiguration::GetNextSource() | |
178 | { | |
179 | AliHLTConfiguration* pSrc=NULL; | |
180 | if (fNofSources>0) { | |
181 | if (fListSrcElement!=fListSources.end() && (++fListSrcElement)!=fListSources.end()) | |
182 | pSrc=*fListSrcElement; | |
183 | } | |
184 | return pSrc; | |
185 | } | |
186 | ||
187 | int AliHLTConfiguration::SourcesResolved(int bAuto) | |
188 | { | |
189 | int iResult=0; | |
190 | if (fNofSources>=0 || bAuto && (iResult=ExtractSources())>=0) { | |
85465857 | 191 | //HLTDebug("fNofSources=%d", fNofSources); |
192 | //HLTDebug("list size = %d", fListSources.size()); | |
3495cce2 | 193 | iResult=fNofSources==(int)fListSources.size(); |
194 | } | |
195 | return iResult; | |
196 | } | |
197 | ||
198 | int AliHLTConfiguration::InvalidateSource(AliHLTConfiguration* pConf) | |
199 | { | |
200 | int iResult=0; | |
201 | if (pConf) { | |
202 | vector<AliHLTConfiguration*>::iterator element=fListSources.begin(); | |
203 | while (element!=fListSources.end()) { | |
204 | if (*element==pConf) { | |
205 | fListSources.erase(element); | |
206 | fListSrcElement=fListSources.end(); | |
207 | // there is no need to re-evaluate until there was a new configuration registered | |
208 | // -> postpone the invalidation, its done in AliHLTConfigurationHandler::RegisterConfiguration | |
209 | //InvalidateSources(); | |
210 | break; | |
211 | } | |
212 | element++; | |
213 | } | |
214 | } else { | |
215 | iResult=-EINVAL; | |
216 | } | |
217 | return iResult; | |
218 | } | |
219 | ||
220 | void AliHLTConfiguration::PrintStatus() | |
221 | { | |
85465857 | 222 | HLTLogKeyword("configuration status"); |
223 | HLTMessage("status of configuration \"%s\" (%p)", GetName(), this); | |
224 | if (fComponent) HLTMessage(" - component: \"%s\"", fComponent); | |
225 | else HLTMessage(" - component string invalid"); | |
226 | if (fStringSources) HLTMessage(" - sources: \"%s\"", fStringSources); | |
227 | else HLTMessage(" - no sources"); | |
3495cce2 | 228 | if (SourcesResolved(1)<=0) |
85465857 | 229 | HLTMessage(" there are unresolved sources"); |
3495cce2 | 230 | AliHLTConfiguration* pSrc=GetFirstSource(); |
231 | while (pSrc) { | |
85465857 | 232 | HLTMessage(" source \"%s\" (%p) resolved", pSrc->GetName(), pSrc); |
3495cce2 | 233 | pSrc=GetNextSource(); |
234 | } | |
235 | } | |
236 | ||
0c0c9d99 | 237 | int AliHLTConfiguration::GetArguments(const char*** pArgv) |
3495cce2 | 238 | { |
239 | int iResult=0; | |
0c0c9d99 | 240 | if (pArgv) { |
241 | iResult=fArgc; | |
3495cce2 | 242 | *pArgv=(const char**)fArgv; |
243 | } else { | |
244 | iResult=-EINVAL; | |
245 | } | |
246 | return iResult; | |
247 | } | |
248 | ||
249 | ||
250 | int AliHLTConfiguration::ExtractSources() | |
251 | { | |
252 | int iResult=0; | |
253 | fNofSources=0; | |
254 | if (fStringSources!=NULL) { | |
255 | vector<char*> tgtList; | |
256 | fListSources.clear(); | |
257 | if ((iResult=InterpreteString(fStringSources, tgtList))>=0) { | |
258 | fNofSources=tgtList.size(); | |
259 | vector<char*>::iterator element=tgtList.begin(); | |
85465857 | 260 | while ((element=tgtList.begin())!=tgtList.end()) { |
261 | if (fConfigurationHandler) { | |
262 | AliHLTConfiguration* pConf=fConfigurationHandler->FindConfiguration(*element); | |
263 | if (pConf) { | |
264 | HLTDebug("source \"%s\" inserted", pConf->GetName()); | |
265 | fListSources.push_back(pConf); | |
266 | } else { | |
267 | HLTError("can not find source \"%s\"", (*element)); | |
268 | iResult=-ENOENT; | |
269 | } | |
270 | } else if (iResult>=0) { | |
271 | iResult=-EFAULT; | |
272 | HLTFatal("global configuration handler not initialized, can not resolve sources"); | |
3495cce2 | 273 | } |
274 | delete[] (*element); | |
275 | tgtList.erase(element); | |
276 | } | |
277 | fListSrcElement=fListSources.begin(); | |
278 | } | |
279 | } | |
280 | return iResult; | |
281 | } | |
282 | ||
283 | int AliHLTConfiguration::ExtractArguments() | |
284 | { | |
285 | int iResult=0; | |
286 | if (fArguments!=NULL) { | |
287 | vector<char*> tgtList; | |
288 | if ((iResult=InterpreteString(fArguments, tgtList))>=0) { | |
289 | fArgc=tgtList.size(); | |
85465857 | 290 | //HLTDebug("found %d arguments", fArgc); |
3495cce2 | 291 | if (fArgc>0) { |
292 | fArgv = new char*[fArgc]; | |
293 | if (fArgv) { | |
294 | vector<char*>::iterator element=tgtList.begin(); | |
295 | int i=0; | |
296 | while (element!=tgtList.end()) { | |
85465857 | 297 | //HLTDebug("assign arguments %d (%s)", i, *element); |
3495cce2 | 298 | fArgv[i++]=(*element); |
299 | element++; | |
300 | } | |
301 | } else { | |
302 | iResult=-ENOMEM; | |
303 | } | |
304 | } | |
305 | } | |
306 | } | |
307 | return iResult; | |
308 | } | |
309 | ||
310 | int AliHLTConfiguration::InterpreteString(const char* arg, vector<char*>& argList) | |
311 | { | |
312 | int iResult=0; | |
313 | if (arg) { | |
85465857 | 314 | //HLTDebug("interprete \"%s\"", arg); |
3495cce2 | 315 | int i=0; |
316 | int prec=-1; | |
317 | do { | |
318 | if (arg[i]==0 || arg[i]==' ') { | |
319 | if (prec>=0) { | |
320 | char* pEntry= new char[i-prec+1]; | |
321 | if (pEntry) { | |
322 | strncpy(pEntry, &arg[prec], i-prec); | |
323 | pEntry[i-prec]=0; // terminate string | |
85465857 | 324 | //HLTDebug("create string \"%s\", insert at %d", pEntry, argList.size()); |
3495cce2 | 325 | argList.push_back(pEntry); |
326 | } else | |
327 | iResult=-ENOMEM; | |
328 | prec=-1; | |
329 | } | |
330 | } else if (prec==-1) prec=i; | |
331 | } while (arg[i++]!=0 && iResult>=0); | |
332 | } else { | |
333 | iResult=-EINVAL; | |
334 | } | |
335 | return iResult; | |
336 | } | |
337 | ||
338 | int AliHLTConfiguration::FollowDependency(const char* id, TList* pTgtList) | |
339 | { | |
340 | int iResult=0; | |
341 | if (id) { | |
342 | AliHLTConfiguration* pDep=NULL; | |
343 | if ((pDep=GetSource(id))!=NULL) { | |
344 | if (pTgtList) pTgtList->Add(pDep); | |
345 | iResult++; | |
346 | } else { | |
347 | pDep=GetFirstSource(); | |
348 | while (pDep && iResult==0) { | |
349 | if ((iResult=pDep->FollowDependency(id, pTgtList))>0) { | |
350 | if (pTgtList) pTgtList->AddFirst(pDep); | |
351 | iResult++; | |
352 | } | |
353 | pDep=GetNextSource(); | |
354 | } | |
355 | } | |
356 | } else { | |
357 | iResult=-EINVAL; | |
358 | } | |
359 | return iResult; | |
360 | } | |
361 | ||
362 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
363 | ||
b22e91eb | 364 | /** ROOT macro for the implementation of ROOT specific class methods */ |
3495cce2 | 365 | ClassImp(AliHLTTask) |
366 | ||
367 | AliHLTTask::AliHLTTask() | |
85869391 | 368 | : |
369 | fpConfiguration(NULL), | |
370 | fpComponent(NULL), | |
85869391 | 371 | fpDataBuffer(NULL), |
372 | fListTargets(), | |
53feaef5 | 373 | fListDependencies(), |
374 | fpBlockDataArray(NULL), | |
375 | fBlockDataArraySize(0) | |
3495cce2 | 376 | { |
3495cce2 | 377 | } |
378 | ||
53feaef5 | 379 | AliHLTTask::AliHLTTask(AliHLTConfiguration* pConf) |
85869391 | 380 | : |
53feaef5 | 381 | fpConfiguration(pConf), |
85869391 | 382 | fpComponent(NULL), |
85869391 | 383 | fpDataBuffer(NULL), |
384 | fListTargets(), | |
53feaef5 | 385 | fListDependencies(), |
386 | fpBlockDataArray(NULL), | |
387 | fBlockDataArraySize(0) | |
3495cce2 | 388 | { |
3495cce2 | 389 | } |
390 | ||
85869391 | 391 | AliHLTTask::AliHLTTask(const AliHLTTask&) |
392 | : | |
53feaef5 | 393 | TObject(), |
394 | AliHLTLogging(), | |
85869391 | 395 | fpConfiguration(NULL), |
396 | fpComponent(NULL), | |
85869391 | 397 | fpDataBuffer(NULL), |
398 | fListTargets(), | |
53feaef5 | 399 | fListDependencies(), |
400 | fpBlockDataArray(NULL), | |
401 | fBlockDataArraySize(0) | |
85869391 | 402 | { |
403 | HLTFatal("copy constructor untested"); | |
404 | } | |
405 | ||
406 | AliHLTTask& AliHLTTask::operator=(const AliHLTTask&) | |
407 | { | |
408 | HLTFatal("assignment operator untested"); | |
409 | return *this; | |
410 | } | |
411 | ||
3495cce2 | 412 | AliHLTTask::~AliHLTTask() |
413 | { | |
414 | if (fpComponent) delete fpComponent; | |
415 | fpComponent=NULL; | |
416 | if (fpBlockDataArray) delete[] fpBlockDataArray; | |
417 | fpBlockDataArray=NULL; | |
418 | } | |
419 | ||
53feaef5 | 420 | int AliHLTTask::Init(AliHLTConfiguration* pConf, AliHLTComponentHandler* pCH) |
3495cce2 | 421 | { |
422 | int iResult=0; | |
53feaef5 | 423 | if (fpConfiguration!=NULL && fpConfiguration!=pConf) { |
2d7ff710 | 424 | HLTWarning("overriding existing reference to configuration object %p (%s) by %p", |
53feaef5 | 425 | fpConfiguration, GetName(), pConf); |
426 | } | |
427 | if (pConf!=NULL) fpConfiguration=pConf; | |
428 | if (fpConfiguration) { | |
3495cce2 | 429 | if (pCH) { |
430 | int argc=0; | |
431 | const char** argv=NULL; | |
53feaef5 | 432 | if ((iResult=fpConfiguration->GetArguments(&argv))>=0) { |
0c0c9d99 | 433 | argc=iResult; // just to make it clear |
2d7ff710 | 434 | // TODO: we have to think about the optional environment parameter, |
435 | // currently just set to NULL. | |
53feaef5 | 436 | iResult=pCH->CreateComponent(fpConfiguration->GetComponentID(), NULL, argc, argv, fpComponent); |
3495cce2 | 437 | if (fpComponent) { |
438 | } else { | |
53feaef5 | 439 | HLTError("can not find component \"%s\"", fpConfiguration->GetComponentID()); |
3495cce2 | 440 | } |
441 | } | |
53feaef5 | 442 | } else { |
443 | HLTError("component handler instance needed for task initialization"); | |
444 | iResult=-EINVAL; | |
3495cce2 | 445 | } |
446 | } else { | |
53feaef5 | 447 | HLTError("configuration object instance needed for task initialization"); |
3495cce2 | 448 | iResult=-EINVAL; |
449 | } | |
450 | return iResult; | |
451 | } | |
452 | ||
53feaef5 | 453 | int AliHLTTask::Deinit() |
454 | { | |
2d7ff710 | 455 | int iResult=0; |
456 | AliHLTComponent* pComponent=GetComponent(); | |
457 | fpComponent=NULL; | |
458 | if (pComponent) { | |
459 | pComponent->Deinit(); | |
460 | delete pComponent; | |
461 | } else { | |
462 | HLTWarning("task %s (%p) doesn't seem to be in initialized", GetName(), this); | |
463 | } | |
464 | return iResult; | |
53feaef5 | 465 | } |
466 | ||
3495cce2 | 467 | const char *AliHLTTask::GetName() const |
468 | { | |
469 | if (fpConfiguration) | |
470 | return fpConfiguration->GetName(); | |
471 | return TObject::GetName(); | |
472 | } | |
473 | ||
0c0c9d99 | 474 | AliHLTConfiguration* AliHLTTask::GetConf() const |
3495cce2 | 475 | { |
476 | return fpConfiguration; | |
477 | } | |
478 | ||
0c0c9d99 | 479 | AliHLTComponent* AliHLTTask::GetComponent() const |
3495cce2 | 480 | { |
481 | return fpComponent; | |
482 | } | |
483 | ||
484 | AliHLTTask* AliHLTTask::FindDependency(const char* id) | |
485 | { | |
486 | AliHLTTask* pTask=NULL; | |
487 | if (id) { | |
488 | pTask=(AliHLTTask*)fListDependencies.FindObject(id); | |
489 | } | |
490 | return pTask; | |
491 | } | |
492 | ||
493 | int AliHLTTask::FollowDependency(const char* id, TList* pTgtList) | |
494 | { | |
495 | int iResult=0; | |
496 | if (id) { | |
497 | AliHLTTask* pDep=NULL; | |
498 | if ((pDep=(AliHLTTask*)fListDependencies.FindObject(id))!=NULL) { | |
499 | if (pTgtList) pTgtList->Add(pDep); | |
500 | iResult++; | |
501 | } else { | |
502 | TObjLink* lnk=fListDependencies.FirstLink(); | |
503 | while (lnk && iResult==0) { | |
504 | pDep=(AliHLTTask*)lnk->GetObject(); | |
505 | if (pDep) { | |
506 | if ((iResult=pDep->FollowDependency(id, pTgtList))>0) { | |
507 | if (pTgtList) pTgtList->AddFirst(pDep); | |
508 | iResult++; | |
509 | } | |
510 | } else { | |
511 | iResult=-EFAULT; | |
512 | } | |
513 | lnk=lnk->Next(); | |
514 | } | |
515 | } | |
516 | } else { | |
517 | iResult=-EINVAL; | |
518 | } | |
519 | return iResult; | |
520 | } | |
521 | ||
522 | void AliHLTTask::PrintDependencyTree(const char* id, int bFromConfiguration) | |
523 | { | |
85465857 | 524 | HLTLogKeyword("task dependencies"); |
3495cce2 | 525 | int iResult=0; |
526 | TList tgtList; | |
527 | if (bFromConfiguration) { | |
528 | if (fpConfiguration) | |
529 | iResult=fpConfiguration->FollowDependency(id, &tgtList); | |
530 | else | |
531 | iResult=-EFAULT; | |
532 | } else | |
533 | iResult=FollowDependency(id, &tgtList); | |
534 | if (iResult>0) { | |
85465857 | 535 | HLTMessage(" task \"%s\": dependency level %d ", GetName(), iResult); |
3495cce2 | 536 | TObjLink* lnk=tgtList.FirstLink(); |
537 | int i=iResult; | |
538 | char* pSpace = new char[iResult+1]; | |
539 | if (pSpace) { | |
540 | memset(pSpace, 32, iResult); | |
541 | pSpace[i]=0; | |
542 | while (lnk) { | |
543 | TObject* obj=lnk->GetObject(); | |
85465857 | 544 | HLTMessage(" %s^-- %s ", &pSpace[i--], obj->GetName()); |
3495cce2 | 545 | lnk=lnk->Next(); |
546 | } | |
547 | delete [] pSpace; | |
548 | } else { | |
549 | iResult=-ENOMEM; | |
550 | } | |
551 | } | |
552 | } | |
553 | ||
3495cce2 | 554 | int AliHLTTask::SetDependency(AliHLTTask* pDep) |
555 | { | |
556 | int iResult=0; | |
557 | if (pDep) { | |
558 | if (FindDependency(pDep->GetName())==NULL) { | |
559 | fListDependencies.Add(pDep); | |
560 | } else { | |
561 | iResult=-EEXIST; | |
562 | } | |
563 | } else { | |
564 | iResult=-EINVAL; | |
565 | } | |
566 | return iResult; | |
567 | } | |
568 | ||
569 | int AliHLTTask::CheckDependencies() | |
570 | { | |
571 | int iResult=0; | |
572 | AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource(); | |
573 | while (pSrc) { | |
574 | if (FindDependency(pSrc->GetName())==NULL) { | |
85465857 | 575 | //HLTDebug("dependency \"%s\" unresolved", pSrc->GetName()); |
3495cce2 | 576 | iResult++; |
577 | } | |
578 | pSrc=fpConfiguration->GetNextSource(); | |
579 | } | |
580 | return iResult; | |
581 | } | |
582 | ||
583 | ||
584 | int AliHLTTask::Depends(AliHLTTask* pTask) | |
585 | { | |
586 | int iResult=0; | |
587 | if (pTask) { | |
588 | if (fpConfiguration) { | |
589 | iResult=fpConfiguration->GetSource(pTask->GetName())!=NULL; | |
590 | if (iResult>0) { | |
85465857 | 591 | //HLTDebug("task \"%s\" depends on \"%s\"", GetName(), pTask->GetName()); |
3495cce2 | 592 | } else { |
85465857 | 593 | //HLTDebug("task \"%s\" independend of \"%s\"", GetName(), pTask->GetName()); |
3495cce2 | 594 | } |
595 | } else { | |
596 | iResult=-EFAULT; | |
597 | } | |
598 | } else { | |
599 | iResult=-EINVAL; | |
600 | } | |
601 | return iResult; | |
602 | } | |
603 | ||
604 | AliHLTTask* AliHLTTask::FindTarget(const char* id) | |
605 | { | |
606 | AliHLTTask* pTask=NULL; | |
607 | if (id) { | |
608 | pTask=(AliHLTTask*)fListTargets.FindObject(id); | |
609 | } | |
610 | return pTask; | |
611 | } | |
612 | ||
613 | int AliHLTTask::SetTarget(AliHLTTask* pTgt) | |
614 | { | |
615 | int iResult=0; | |
616 | if (pTgt) { | |
617 | if (FindTarget(pTgt->GetName())==NULL) { | |
618 | fListTargets.Add(pTgt); | |
619 | } else { | |
620 | iResult=-EEXIST; | |
621 | } | |
622 | } else { | |
623 | iResult=-EINVAL; | |
624 | } | |
625 | return iResult; | |
626 | } | |
627 | ||
0c0c9d99 | 628 | int AliHLTTask::StartRun() |
629 | { | |
630 | int iResult=0; | |
631 | int iNofInputDataBlocks=0; | |
632 | AliHLTComponent* pComponent=GetComponent(); | |
633 | if (pComponent) { | |
634 | // determine the number of input data blocks provided from the source tasks | |
635 | TObjLink* lnk=fListDependencies.FirstLink(); | |
636 | while (lnk && iResult>=0) { | |
637 | AliHLTTask* pSrcTask=(AliHLTTask*)lnk->GetObject(); | |
638 | if (pSrcTask) { | |
639 | if ((iResult=pSrcTask->GetNofMatchingDataTypes(this))>0) { | |
640 | iNofInputDataBlocks+=iResult; | |
641 | } else if (iResult==0) { | |
642 | HLTWarning("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this); | |
643 | } else { | |
644 | HLTError("task %s (%p): error getting matching data types for source task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask); | |
645 | iResult=-EFAULT; | |
646 | } | |
647 | } | |
648 | lnk=lnk->Next(); | |
649 | } | |
650 | if (iResult>=0) { | |
651 | if (fpBlockDataArray) { | |
652 | HLTWarning("block data array for task %s (%p) was not cleaned", GetName(), this); | |
653 | delete [] fpBlockDataArray; | |
654 | fpBlockDataArray=NULL; | |
655 | fBlockDataArraySize=0; | |
656 | } | |
657 | ||
658 | // component init | |
2d7ff710 | 659 | // the initialization of the component is done by the ComponentHandler after creation |
660 | // of the component. | |
0c0c9d99 | 661 | //iResult=Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv ); |
662 | ||
2d7ff710 | 663 | // allocate internal task variables for bookkeeping aso. |
8ede8717 | 664 | fpBlockDataArray=new AliHLTComponentBlockData[iNofInputDataBlocks]; |
0c0c9d99 | 665 | if (fpBlockDataArray) { |
666 | fBlockDataArraySize=iNofInputDataBlocks; | |
667 | } else { | |
668 | HLTError("memory allocation failed"); | |
669 | iResult=-ENOMEM; | |
670 | } | |
671 | } | |
672 | } else { | |
673 | HLTError("task %s (%p) does not have a component", GetName(), this); | |
674 | iResult=-EFAULT; | |
675 | } | |
676 | return iResult; | |
677 | } | |
3495cce2 | 678 | |
0c0c9d99 | 679 | int AliHLTTask::EndRun() |
680 | { | |
681 | int iResult=0; | |
2d7ff710 | 682 | if (fpBlockDataArray) { |
683 | fBlockDataArraySize=0; | |
684 | delete [] fpBlockDataArray; | |
685 | fpBlockDataArray=0; | |
686 | } else { | |
687 | HLTWarning("task %s (%p) doesn't seem to be in running mode", GetName(), this); | |
688 | } | |
0c0c9d99 | 689 | return iResult; |
690 | } | |
3495cce2 | 691 | |
0c0c9d99 | 692 | int AliHLTTask::ProcessTask() |
693 | { | |
694 | int iResult=0; | |
2d7ff710 | 695 | AliHLTComponent* pComponent=GetComponent(); |
696 | if (pComponent && fpBlockDataArray) { | |
0c0c9d99 | 697 | int iSourceDataBlock=0; |
698 | int iInputDataVolume=0; | |
699 | ||
700 | int iNofInputDataBlocks=0; | |
701 | /* TODO: the assumption of only one output data type per component is the current constraint | |
702 | * later it should be checked how many output blocks of the source component match the input | |
703 | * data types of the consumer component (GetNofMatchingDataBlocks). If one assumes that a | |
704 | * certain output block is always been produced, the initialization could be done in the | |
705 | * StartRun. Otherwise the fpBlockDataArray has to be adapted each time. | |
706 | */ | |
707 | iNofInputDataBlocks=fListDependencies.GetSize(); // one block per source | |
708 | // is not been used since the allocation was done in StartRun, but check the size | |
709 | if (iNofInputDataBlocks>fBlockDataArraySize) { | |
710 | HLTError("block data array too small"); | |
711 | } | |
712 | ||
713 | AliHLTTask* pSrcTask=NULL; | |
714 | TList subscribedTaskList; | |
715 | TObjLink* lnk=fListDependencies.FirstLink(); | |
716 | ||
717 | // subscribe to all source tasks | |
718 | while (lnk && iResult>=0) { | |
719 | pSrcTask=(AliHLTTask*)lnk->GetObject(); | |
720 | if (pSrcTask) { | |
721 | if (pSrcTask->GetNofMatchingDataBlocks(this)<fBlockDataArraySize-iSourceDataBlock) { | |
722 | if ((iResult=pSrcTask->Subscribe(this, &fpBlockDataArray[iSourceDataBlock],fBlockDataArraySize-iSourceDataBlock))>0) { | |
723 | for (int i=0; i<iResult; i++) { | |
724 | iInputDataVolume+=fpBlockDataArray[i+iSourceDataBlock].fSize; | |
725 | // put the source task as many times into the list as it provides data blocks | |
726 | // makes the bookkeeping for the data release easier | |
727 | subscribedTaskList.Add(pSrcTask); | |
728 | } | |
729 | iSourceDataBlock+=iResult; | |
730 | HLTDebug("Task %s (%p) successfully subscribed to %d data blocks of task %s (%p)", GetName(), this, iResult, pSrcTask->GetName(), pSrcTask); | |
731 | iResult=0; | |
732 | } else { | |
733 | HLTError("Task %s (%p): subscription to task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iResult); | |
734 | iResult=-EFAULT; | |
735 | } | |
736 | } else { | |
737 | HLTFatal("Task %s (%p): too little space in data block array for subscription to task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask); | |
738 | iResult=-EFAULT; | |
739 | } | |
740 | } else { | |
741 | HLTFatal("fatal internal error in ROOT list handling"); | |
742 | iResult=-EFAULT; | |
743 | } | |
744 | lnk=lnk->Next(); | |
745 | } | |
746 | ||
747 | // process the event | |
748 | if (iResult>=0) { | |
749 | long unsigned int iConstBase=0; | |
750 | double fInputMultiplier=0; | |
2d7ff710 | 751 | pComponent->GetOutputDataSize(iConstBase, fInputMultiplier); |
0c0c9d99 | 752 | int iOutputDataSize=int(fInputMultiplier*iInputDataVolume) + iConstBase; |
753 | AliHLTUInt8_t* pTgtBuffer=fpDataBuffer->GetTargetBuffer(iOutputDataSize); | |
8ede8717 | 754 | AliHLTComponentEventData evtData; |
755 | AliHLTComponentTriggerData trigData; | |
0c0c9d99 | 756 | AliHLTUInt32_t size=iOutputDataSize; |
757 | AliHLTUInt32_t outputBlockCnt=0; | |
8ede8717 | 758 | AliHLTComponentBlockData* outputBlocks=NULL; |
759 | AliHLTComponentEventDoneData* edd; | |
0c0c9d99 | 760 | if (pTgtBuffer!=NULL || iOutputDataSize==0) { |
2d7ff710 | 761 | iResult=pComponent->ProcessEvent(evtData, fpBlockDataArray, trigData, pTgtBuffer, size, outputBlockCnt, outputBlocks, edd); |
762 | if (iResult>=0) { | |
763 | iResult=fpDataBuffer->SetSegments(pTgtBuffer, outputBlocks, outputBlockCnt); | |
764 | } | |
0c0c9d99 | 765 | } else { |
766 | } | |
767 | } | |
768 | ||
769 | // now release all buffers which we have subscribed to | |
770 | iSourceDataBlock=0; | |
771 | lnk=subscribedTaskList.FirstLink(); | |
772 | while (lnk) { | |
773 | pSrcTask=(AliHLTTask*)lnk->GetObject(); | |
774 | if (pSrcTask) { | |
775 | int iTempRes=0; | |
776 | if ((iTempRes=pSrcTask->Release(&fpBlockDataArray[iSourceDataBlock], this))>=0) { | |
777 | HLTDebug("Task %s (%p) successfully released task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask); | |
778 | } else { | |
779 | HLTError("Task %s (%p): realease of task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iTempRes); | |
780 | } | |
781 | } else { | |
2d7ff710 | 782 | HLTFatal("internal error in ROOT list handling"); |
783 | if (iResult>=0) iResult=-EFAULT; | |
0c0c9d99 | 784 | } |
785 | subscribedTaskList.Remove(lnk); | |
786 | lnk=subscribedTaskList.FirstLink(); | |
787 | iSourceDataBlock++; | |
788 | } | |
789 | if (subscribedTaskList.GetSize()>0) { | |
790 | HLTError("task %s (%p): could not release all data buffers", GetName(), this); | |
791 | } | |
792 | } else { | |
793 | HLTError("internal failure: task not initialized"); | |
794 | iResult=-EFAULT; | |
795 | } | |
796 | return iResult; | |
797 | } | |
798 | ||
2d7ff710 | 799 | int AliHLTTask::GetNofMatchingDataBlocks(const AliHLTTask* pConsumerTask) const |
0c0c9d99 | 800 | { |
801 | int iResult=0; | |
802 | if (pConsumerTask) { | |
803 | if (fpDataBuffer) { | |
804 | iResult=fpDataBuffer->FindMatchingDataBlocks(pConsumerTask->GetComponent(), NULL); | |
805 | } else { | |
806 | HLTFatal("internal data buffer missing"); | |
807 | iResult=-EFAULT; | |
808 | } | |
809 | } else { | |
810 | iResult=-EINVAL; | |
811 | } | |
812 | return iResult; | |
813 | } | |
814 | ||
2d7ff710 | 815 | int AliHLTTask::GetNofMatchingDataTypes(const AliHLTTask* pConsumerTask) const |
0c0c9d99 | 816 | { |
817 | int iResult=0; | |
818 | if (pConsumerTask) { | |
819 | AliHLTComponent* pComponent=GetComponent(); | |
820 | if (!pComponent) { | |
821 | // init | |
822 | } | |
823 | if (pComponent) { | |
824 | iResult=pComponent->FindMatchingDataTypes(pConsumerTask->GetComponent(), NULL); | |
825 | } else { | |
826 | HLTFatal("task initialization failed"); | |
827 | iResult=-EFAULT; | |
828 | } | |
829 | } else { | |
830 | iResult=-EINVAL; | |
831 | } | |
832 | return iResult; | |
833 | } | |
834 | ||
8ede8717 | 835 | int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponentBlockData* pBlockDesc, int iArraySize) |
0c0c9d99 | 836 | { |
837 | int iResult=0; | |
838 | if (pConsumerTask) { | |
839 | if (fpDataBuffer) { | |
840 | iResult=fpDataBuffer->Subscribe(pConsumerTask->GetComponent(), pBlockDesc, iArraySize); | |
841 | } else { | |
842 | HLTFatal("internal data buffer missing"); | |
843 | iResult=-EFAULT; | |
844 | } | |
845 | } else { | |
846 | iResult=-EINVAL; | |
847 | } | |
848 | return iResult; | |
849 | } | |
850 | ||
8ede8717 | 851 | int AliHLTTask::Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTTask* pConsumerTask) |
0c0c9d99 | 852 | { |
853 | int iResult=0; | |
854 | if (pConsumerTask && pBlockDesc) { | |
855 | if (fpDataBuffer) { | |
856 | iResult=fpDataBuffer->Release(pBlockDesc, pConsumerTask->GetComponent()); | |
857 | } else { | |
858 | HLTFatal("internal data buffer missing"); | |
859 | iResult=-EFAULT; | |
860 | } | |
861 | } else { | |
862 | iResult=-EINVAL; | |
863 | } | |
864 | return iResult; | |
865 | } | |
3495cce2 | 866 | |
0c0c9d99 | 867 | /* this function is most likely depricated |
3495cce2 | 868 | int AliHLTTask::ClearSourceBlocks() |
869 | { | |
870 | int iResult=0; | |
871 | return iResult; | |
872 | } | |
0c0c9d99 | 873 | */ |
3495cce2 | 874 | |
875 | void AliHLTTask::PrintStatus() | |
876 | { | |
85465857 | 877 | HLTLogKeyword("task properties"); |
2d7ff710 | 878 | AliHLTComponent* pComponent=GetComponent(); |
879 | if (pComponent) { | |
880 | HLTMessage(" component: %s (%p)", pComponent->GetComponentID(), pComponent); | |
3495cce2 | 881 | } else { |
85465857 | 882 | HLTMessage(" no component set!"); |
3495cce2 | 883 | } |
884 | if (fpConfiguration) { | |
885 | AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource(); | |
886 | while (pSrc) { | |
887 | const char* pQualifier="unresolved"; | |
888 | if (FindDependency(pSrc->GetName())) | |
889 | pQualifier="resolved"; | |
85465857 | 890 | HLTMessage(" source: %s (%s)", pSrc->GetName(), pQualifier); |
3495cce2 | 891 | pSrc=fpConfiguration->GetNextSource(); |
892 | } | |
893 | TObjLink* lnk = fListTargets.FirstLink(); | |
894 | while (lnk) { | |
895 | TObject *obj = lnk->GetObject(); | |
85465857 | 896 | HLTMessage(" target: %s", obj->GetName()); |
3495cce2 | 897 | lnk = lnk->Next(); |
898 | } | |
899 | } else { | |
85465857 | 900 | HLTMessage(" task \"%s\" not initialized", GetName()); |
3495cce2 | 901 | } |
902 | } | |
903 | ||
904 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
905 | ||
906 | TList AliHLTConfigurationHandler::fListConfigurations; | |
907 | TList AliHLTConfigurationHandler::fListDynamicConfigurations; | |
908 | ||
b22e91eb | 909 | /** ROOT macro for the implementation of ROOT specific class methods */ |
3495cce2 | 910 | ClassImp(AliHLTConfigurationHandler) |
911 | ||
912 | AliHLTConfigurationHandler::AliHLTConfigurationHandler() | |
913 | { | |
914 | } | |
915 | ||
916 | AliHLTConfigurationHandler::~AliHLTConfigurationHandler() | |
917 | { | |
918 | TObjLink* lnk=fListDynamicConfigurations.FirstLink(); | |
919 | while (lnk) { | |
920 | TObject* obj=lnk->GetObject(); | |
921 | if (fListConfigurations.FindObject(obj->GetName())==NULL) { | |
85465857 | 922 | HLTDebug("delete dynamic configuration \"%s\"", obj->GetName()); |
3495cce2 | 923 | delete obj; |
924 | } | |
925 | lnk=lnk->Next(); | |
926 | } | |
927 | } | |
928 | ||
929 | int AliHLTConfigurationHandler::RegisterConfiguration(AliHLTConfiguration* pConf) | |
930 | { | |
931 | int iResult=0; | |
932 | if (pConf) { | |
933 | if (FindConfiguration(pConf->GetName()) == NULL) { | |
934 | fListConfigurations.Add(pConf); | |
85465857 | 935 | //HLTDebug("configuration \"%s\" registered", pConf->GetName()); |
3495cce2 | 936 | |
937 | // mark all configurations with unresolved dependencies for re-evaluation | |
938 | TObjLink* lnk=fListConfigurations.FirstLink(); | |
939 | while (lnk) { | |
940 | AliHLTConfiguration* pSrc=(AliHLTConfiguration*)lnk->GetObject(); | |
941 | if (pSrc && pSrc!=pConf && pSrc->SourcesResolved()!=1) { | |
942 | pSrc->InvalidateSources(); | |
943 | } | |
944 | lnk=lnk->Next(); | |
945 | } | |
946 | } else { | |
947 | iResult=-EEXIST; | |
85465857 | 948 | HLTWarning("configuration \"%s\" already registered", pConf->GetName()); |
3495cce2 | 949 | } |
950 | } else { | |
951 | iResult=-EINVAL; | |
952 | } | |
953 | return iResult; | |
954 | } | |
955 | ||
956 | int AliHLTConfigurationHandler::CreateConfiguration(const char* id, const char* component, const char* sources, const char* arguments) | |
957 | { | |
958 | int iResult=0; | |
959 | AliHLTConfiguration* pConf= new AliHLTConfiguration(id, component, sources, arguments); | |
960 | if (pConf) { | |
961 | // the configuration will be registered automatically, if this failes the configuration | |
962 | // is missing -> delete it | |
963 | if (FindConfiguration(id)==NULL) { | |
964 | delete pConf; | |
965 | pConf=NULL; | |
966 | iResult=-EEXIST; | |
967 | } else { | |
968 | fListDynamicConfigurations.Add(pConf); | |
969 | } | |
970 | } else { | |
85465857 | 971 | HLTError("system error: object allocation failed"); |
3495cce2 | 972 | iResult=-ENOMEM; |
973 | } | |
974 | return iResult; | |
975 | } | |
976 | ||
977 | void AliHLTConfigurationHandler::PrintConfigurations() | |
978 | { | |
85465857 | 979 | HLTLogKeyword("configuration listing"); |
980 | HLTMessage("registered configurations:"); | |
3495cce2 | 981 | TObjLink *lnk = fListConfigurations.FirstLink(); |
982 | while (lnk) { | |
983 | TObject *obj = lnk->GetObject(); | |
85465857 | 984 | HLTMessage(" %s", obj->GetName()); |
3495cce2 | 985 | lnk = lnk->Next(); |
986 | } | |
987 | } | |
988 | ||
989 | int AliHLTConfigurationHandler::RemoveConfiguration(const char* id) | |
990 | { | |
991 | int iResult=0; | |
992 | if (id) { | |
993 | AliHLTConfiguration* pConf=NULL; | |
994 | if ((pConf=FindConfiguration(id))!=NULL) { | |
995 | iResult=RemoveConfiguration(pConf); | |
996 | } else { | |
85465857 | 997 | HLTWarning("can not find configuration \"%s\"", id); |
3495cce2 | 998 | iResult=-ENOENT; |
999 | } | |
1000 | } else { | |
1001 | iResult=-EINVAL; | |
1002 | } | |
1003 | return iResult; | |
1004 | } | |
1005 | ||
1006 | int AliHLTConfigurationHandler::RemoveConfiguration(AliHLTConfiguration* pConf) | |
1007 | { | |
1008 | int iResult=0; | |
1009 | if (pConf) { | |
1010 | // remove the configuration from the list | |
1011 | fListConfigurations.Remove(pConf); | |
1012 | // remove cross links in the remaining configurations | |
1013 | TObjLink* lnk=fListConfigurations.FirstLink(); | |
1014 | while (lnk && iResult>=0) { | |
1015 | AliHLTConfiguration* pRem=(AliHLTConfiguration*)lnk->GetObject(); | |
1016 | if (pRem) { | |
1017 | pRem->InvalidateSource(pConf); | |
1018 | } else { | |
1019 | iResult=-EFAULT; | |
1020 | } | |
1021 | lnk=lnk->Next(); | |
1022 | } | |
1023 | } | |
1024 | return iResult; | |
1025 | } | |
1026 | ||
1027 | AliHLTConfiguration* AliHLTConfigurationHandler::FindConfiguration(const char* id) | |
1028 | { | |
1029 | AliHLTConfiguration* pConf=NULL; | |
1030 | if (id) { | |
1031 | pConf=(AliHLTConfiguration*)fListConfigurations.FindObject(id); | |
1032 | } | |
1033 | return pConf; | |
1034 | } | |
1035 |