Fixing bug caused by UUID not being generated properly.
[u/mrichter/AliRoot.git] / HLT / trigger / AliHLTGlobalTriggerComponent.cxx
1 // $Id$
2 /**************************************************************************
3  * This file is property of and copyright by the ALICE HLT Project        *
4  * ALICE Experiment at CERN, All rights reserved.                         *
5  *                                                                        *
6  * Primary Authors: Artur Szostak <artursz@iafrica.com>                   *
7  *                  for The ALICE HLT 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
18 /// @file   AliHLTGlobalTriggerComponent.cxx
19 /// @author Artur Szostak <artursz@iafrica.com>
20 /// @date   26 Nov 2008
21 /// @brief  Implementation of the AliHLTGlobalTriggerComponent component class.
22 ///
23 /// The AliHLTGlobalTriggerComponentComponent class applies the global HLT trigger to all
24 /// trigger information produced by components deriving from AliHLTTrigger.
25
26 #include "AliHLTGlobalTriggerComponent.h"
27 #include "AliHLTGlobalTriggerDecision.h"
28 #include "AliHLTGlobalTrigger.h"
29 #include "AliHLTGlobalTriggerConfig.h"
30 #include "AliHLTTriggerMenu.h"
31 #include "AliHLTCTPData.h"
32 #include "AliCDBManager.h"
33 #include "AliCDBStorage.h"
34 #include "AliCDBEntry.h"
35 #include "TUUID.h"
36 #include "TMD5.h"
37 #include "TRandom3.h"
38 #include "TROOT.h"
39 #include "TSystem.h"
40 #include "TRegexp.h"
41 #include "TClonesArray.h"
42 #include "TObjString.h"
43 #include "TString.h"
44 #include "TInterpreter.h"
45 #include "TDatime.h"
46 #include "TClass.h"
47 #include "TNamed.h"
48 #include <fstream>
49 #include <cerrno>
50 #include <cassert>
51 #include <vector>
52 #include <algorithm>
53
54 ClassImp(AliHLTGlobalTriggerComponent)
55
56 const char* AliHLTGlobalTriggerComponent::fgkTriggerMenuCDBPath = "HLT/ConfigHLT/HLTGlobalTrigger";
57
58
59 namespace
60 {
61   /**
62    * This method is used as a comparison functor with the STL sort routines.
63    */
64   bool AliHLTDescendingNumbers(UInt_t a, UInt_t b)
65   {
66     return a > b;
67   }
68 } // end of namespace
69
70
71 AliHLTGlobalTriggerComponent::AliHLTGlobalTriggerComponent() :
72         AliHLTTrigger(),
73         fTrigger(NULL),
74         fDebugMode(false),
75         fRuntimeCompile(true),
76         fDeleteCodeFile(false),
77         fCodeFileName(),
78         fClassName(),
79         fCTPDecisions(NULL),
80         fBufferSizeConst(2*(sizeof(AliHLTGlobalTriggerDecision) + sizeof(AliHLTReadoutList))),
81         fBufferSizeMultiplier(1.),
82         fIncludePaths(TObjString::Class()),
83         fIncludeFiles(TObjString::Class()),
84         fLibStateAtLoad(),
85         fBits(0),
86         fDataEventsOnly(true)
87 {
88   // Default constructor.
89   
90   ClearInfoForNewEvent(false);
91 }
92
93
94 AliHLTGlobalTriggerComponent::~AliHLTGlobalTriggerComponent()
95 {
96   // Default destructor.
97   
98   if (fTrigger != NULL) delete fTrigger;
99
100   if (fCTPDecisions) {
101     fCTPDecisions->Delete();
102     delete fCTPDecisions;
103   }
104 }
105
106
107 void AliHLTGlobalTriggerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& list) const
108 {
109   // Returns the kAliHLTDataTypeGlobalTrigger type as output.
110   list.push_back(kAliHLTDataTypeGlobalTrigger);
111 }
112
113
114 void AliHLTGlobalTriggerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
115 {
116   // Returns the output data size estimate.
117
118   constBase = fBufferSizeConst;
119   inputMultiplier = fBufferSizeMultiplier;
120 }
121
122
123 Int_t AliHLTGlobalTriggerComponent::DoInit(int argc, const char** argv)
124 {
125   // Initialises the global trigger component.
126   
127   fDebugMode = false;
128   fClassName = "";
129   fCodeFileName = "";
130   fDeleteCodeFile = false;
131   const char* configFileName = NULL;
132   const char* codeFileName = NULL;
133   fIncludePaths.Clear();
134   fIncludeFiles.Clear();
135   SetBit(kIncludeInput);
136   fDataEventsOnly = true;
137   
138   for (int i = 0; i < argc; i++)
139   {
140     if (strcmp(argv[i], "-config") == 0)
141     {
142       if (configFileName != NULL)
143       {
144         HLTWarning("Trigger configuration macro was already specified."
145                    " Will replace previous value given by -config."
146         );
147       }
148       if (argc <= i+1)
149       {
150         HLTError("The trigger configuration macro filename was not specified." );
151         return -EINVAL;
152       }
153       configFileName = argv[i+1];
154       i++;
155       continue;
156     }
157     
158     if (strcmp(argv[i], "-includepath") == 0)
159     {
160       if (argc <= i+1)
161       {
162         HLTError("The include path was not specified." );
163         return -EINVAL;
164       }
165       try
166       {
167         new (fIncludePaths[fIncludePaths.GetEntriesFast()]) TObjString(argv[i+1]);
168       }
169       catch (const std::bad_alloc&)
170       {
171         HLTError("Could not allocate more memory for the fIncludePaths array.");
172         return -ENOMEM;
173       }
174       i++;
175       continue;
176     }
177     
178     if (strcmp(argv[i], "-include") == 0)
179     {
180       if (argc <= i+1)
181       {
182         HLTError("The include file name was not specified." );
183         return -EINVAL;
184       }
185       try
186       {
187         new (fIncludeFiles[fIncludeFiles.GetEntriesFast()]) TObjString(argv[i+1]);
188       }
189       catch (const std::bad_alloc&)
190       {
191         HLTError("Could not allocate more memory for the fIncludeFiles array.");
192         return -ENOMEM;
193       }
194       i++;
195       continue;
196     }
197     
198     if (strcmp(argv[i], "-debug") == 0)
199     {
200       if (fDebugMode == true)
201       {
202         HLTWarning("The debug flag was already specified. Ignoring this instance.");
203       }
204       fDebugMode = true;
205       continue;
206     }
207     
208     if (strcmp(argv[i], "-cint") == 0)
209     {
210       fRuntimeCompile = false;
211       continue;
212     }
213     
214     if (strcmp(argv[i], "-usecode") == 0)
215     {
216       if (codeFileName != NULL)
217       {
218         HLTWarning("Custom trigger code file was already specified."
219                    " Will replace previous value given by -usecode."
220         );
221       }
222       if (argc <= i+1)
223       {
224         HLTError("The custom trigger code filename was not specified." );
225         return -EINVAL;
226       }
227       codeFileName = argv[i+1];
228       if (argc <= i+2)
229       {
230         HLTError("The custom trigger class name was not specified." );
231         return -EINVAL;
232       }
233       fClassName = argv[i+2];
234       i += 2;
235       continue;
236     }
237
238     if (strcmp(argv[i], "-skipctp") == 0)
239     {
240       HLTInfo("Skipping CTP counters in trigger decision");
241       SetBit(kSkipCTP);
242       continue;
243     }
244
245     if (strcmp(argv[i], "-forward-input") == 0)
246     {
247       HLTInfo("Forwarding input objects and trigger decisions");
248       SetBit(kForwardInput);
249       SetBit(kIncludeShort);
250       SetBit(kIncludeInput, false);
251       continue;
252     }
253
254     if (strstr(argv[i], "-include-input") == argv[i])
255     {
256       SetBit(kForwardInput,false);
257       TString param=argv[i];
258       param.ReplaceAll("-include-input", "");
259       if (param.CompareTo("=none")==0) 
260       {
261         HLTInfo("skipping objects and trigger decisions");
262         SetBit(kIncludeShort, false);
263         SetBit(kIncludeInput, false);
264       }
265       else if (param.CompareTo("=short")==0) 
266       {
267         HLTInfo("including short info on objects and trigger decisions");
268         SetBit(kIncludeShort);
269         SetBit(kIncludeInput, false);
270       }
271       else if (param.CompareTo("=both")==0) 
272       {
273         HLTInfo("including input objects, trigger decisions and short info");
274         SetBit(kIncludeShort);
275         SetBit(kIncludeInput);
276       }
277       else if (param.CompareTo("=objects")==0 || param.IsNull())
278       {
279         HLTInfo("including input objects and trigger decisions");
280         SetBit(kIncludeShort, false);
281         SetBit(kIncludeInput);
282       }
283       else
284       {
285         HLTError("unknown parameter '%s' for argument '-include-input'", param.Data());
286       }
287       continue;
288     }
289
290     if (strcmp(argv[i], "-process-all-events") == 0)
291     {
292       fDataEventsOnly = false;
293       continue;
294     }
295     
296     HLTError("Unknown option '%s'.", argv[i]);
297     return -EINVAL;
298   } // for loop
299   
300   const AliHLTTriggerMenu* menu = NULL;
301   if (configFileName != NULL)
302   {
303     TString cmd = ".x ";
304     cmd += configFileName;
305     gROOT->ProcessLine(cmd);
306     menu = AliHLTGlobalTriggerConfig::Menu();
307   }
308   
309   // Try load the trigger menu from the CDB if it is not loaded yet with the
310   // -config option
311   int result = -ENOENT;
312   if (menu == NULL)
313   {
314     result = LoadTriggerMenu(fgkTriggerMenuCDBPath, menu);
315   }
316   if (menu == NULL)
317   {
318     HLTError("No trigger menu configuration found or specified.");
319     return result;
320   }
321   
322   if (codeFileName == NULL)
323   {
324     result = GenerateTrigger(menu, fClassName, fCodeFileName, fIncludePaths, fIncludeFiles);
325     if (result == 0) fDeleteCodeFile = true;
326   }
327   else
328   {
329     result = LoadTriggerClass(codeFileName, fIncludePaths);
330     if (result == 0) fCodeFileName = codeFileName;
331   }
332   if (result != 0) return result;
333   
334   try
335   {
336     fTrigger = AliHLTGlobalTrigger::CreateNew(fClassName.Data());
337   }
338   catch (const std::bad_alloc&)
339   {
340     HLTError("Could not allocate memory for the AliHLTGlobalTrigger instance.");
341     return -ENOMEM;
342   }
343   if (fTrigger == NULL)
344   {
345     HLTError("Could not create a new instance of '%s'.", fClassName.Data());
346     return -EIO;
347   }
348   
349   fTrigger->FillFromMenu(*menu);
350   if (fTrigger->CallFailed()) return -EPROTO;
351
352   // setup the CTP accounting in AliHLTComponent
353   SetupCTPData();
354
355   // Set the default values from the trigger menu.
356   SetDescription(menu->DefaultDescription());
357   SetTriggerDomain(menu->DefaultTriggerDomain());
358   
359   return 0;
360 }
361
362
363 Int_t AliHLTGlobalTriggerComponent::DoDeinit()
364 {
365   // Cleans up the global trigger component.
366   
367   if (fTrigger != NULL)
368   {
369     delete fTrigger;
370     fTrigger = NULL;
371   }
372   
373   if (fCTPDecisions) {
374     fCTPDecisions->Delete();
375     delete fCTPDecisions;
376   }
377   fCTPDecisions=NULL;
378   
379   Int_t result = UnloadTriggerClass(fCodeFileName);
380   if (result != 0) return result;
381   
382   if (fDeleteCodeFile and !fCodeFileName.IsNull() && gSystem->AccessPathName(fCodeFileName)==0 && !fDebugMode) {
383     fCodeFileName.ReplaceAll(".cxx", "*");
384     TString command="rm "; command+=fCodeFileName;
385     gSystem->Exec(command);
386   }
387   fCodeFileName="";
388   fDeleteCodeFile=false;
389
390   return 0;
391 }
392
393
394 AliHLTComponent* AliHLTGlobalTriggerComponent::Spawn()
395 {
396   // Creates a new object instance.
397   AliHLTComponent* comp = NULL;
398   try
399   {
400     comp = new AliHLTGlobalTriggerComponent;
401   }
402   catch (const std::bad_alloc&)
403   {
404     HLTError("Could not allocate memory for a new instance of AliHLTGlobalTriggerComponent.");
405     return NULL;
406   }
407   return comp;
408 }
409
410
411 int AliHLTGlobalTriggerComponent::DoTrigger()
412 {
413   // This method will apply the global trigger decision.
414
415   if (fTrigger == NULL)
416   {
417     HLTFatal("Global trigger implementation object is NULL!");
418     return -EIO;
419   }
420
421   AliHLTUInt32_t eventType=0;
422   if (!IsDataEvent(&eventType)) {
423     if (eventType==gkAliEventTypeEndOfRun) PrintStatistics(fTrigger, kHLTLogImportant, 0);
424     if (fDataEventsOnly)
425     {
426       IgnoreEvent();  // dont generate any trigger decision.
427       return 0;
428     }
429   }
430
431   // Copy the trigger counters in case we need to set them back to their original
432   // value because the PushBack method fails with ENOSPC.
433   TArrayL64 originalCounters = fTrigger->GetCounters();
434   if (fTrigger->CallFailed()) return -EPROTO;
435   
436   fTrigger->NewEvent();
437   if (fTrigger->CallFailed()) return -EPROTO;
438   
439   // Fill in the input data.
440   const TObject* obj = GetFirstInputObject();
441   while (obj != NULL)
442   {
443     fTrigger->Add(obj, GetDataType(), GetSpecification());
444     if (fTrigger->CallFailed()) return -EPROTO;
445     obj = GetNextInputObject();
446   }
447
448   // add trigger decisions for every CTP class
449   const AliHLTCTPData* pCTPData=CTPData();
450   if (pCTPData) {
451     AddCTPDecisions(fTrigger, pCTPData, GetTriggerData());
452   }
453
454   // Calculate the global trigger result and trigger domain, then create and push
455   // back the new global trigger decision object.
456   TString description;
457   AliHLTTriggerDomain triggerDomain;
458   bool triggerResult = fTrigger->CalculateTriggerDecision(triggerDomain, description);
459   if (fTrigger->CallFailed()) return -EPROTO;
460   AliHLTGlobalTriggerDecision decision(
461       triggerResult,
462       // The following will cause the decision to be generated with default values
463       // (set in fTriggerDomain and fDescription) if the trigger result is false.
464       (triggerResult == true) ? triggerDomain : GetTriggerDomain(),
465       (triggerResult == true) ? description.Data() : GetDescription()
466     );
467
468   decision.SetCounters(fTrigger->GetCounters(), GetEventCount()+1);
469   if (fTrigger->CallFailed()) return -EPROTO;
470   
471   TClonesArray shortInfo(TNamed::Class(), GetNumberOfInputBlocks());
472   
473   // Add the input objects used to make the global decision.
474   obj = GetFirstInputObject();
475   while (obj != NULL)
476   {
477     const AliHLTTriggerDecision* intrig = dynamic_cast<const AliHLTTriggerDecision*>(obj);
478     
479     if (TestBit(kForwardInput)) Forward(obj);
480     
481     if (TestBit(kIncludeInput))
482     {
483       if (intrig != NULL)
484       {
485          decision.AddTriggerInput(*intrig);
486       }
487       else
488       {
489         // The const_cast should be safe in this case because the list of inputObjects
490         // will be added to the global decision with AddInputObjectRef, which only
491         // modifies the kCanDelete bit and nothing else.
492         // This is necessary since GetFirstInputObject only returns const objects.
493         decision.AddInputObjectRef( const_cast<TObject*>(obj) );
494       }
495     }
496     
497     if (TestBit(kIncludeShort))
498     {
499       int entries = shortInfo.GetEntriesFast();
500       try
501       {
502         new (shortInfo[entries]) TNamed(obj->GetName(), obj->GetTitle());
503       }
504       catch (const std::bad_alloc&)
505       {
506         HLTError("Could not allocate more memory for the short list of input objects.");
507         return -ENOMEM;
508       }
509       if (intrig != NULL)
510       {
511         shortInfo[entries]->SetBit(BIT(16)); // indicate that this is a trigger decision
512         shortInfo[entries]->SetBit(BIT(15), intrig->Result());
513       }
514     }
515
516     obj = GetNextInputObject();
517   }
518   if (TestBit(kIncludeShort)) decision.AddInputObjectRef(&shortInfo);
519   
520   // The const_cast should be safe in this case because AddInputObjectRef just
521   // modifies the kCanDelete bit and nothing else.
522   if (!TestBit(kSkipCTP) && CTPData()) decision.AddInputObjectRef(const_cast<AliHLTCTPData*>(CTPData()));
523   
524   static UInt_t lastTime=0;
525   TDatime time;
526   if (time.Get()-lastTime>60) {
527     lastTime=time.Get();
528     PrintStatistics(fTrigger, kHLTLogImportant);
529   }
530
531   // add readout filter to event done data
532   CreateEventDoneReadoutFilter(decision.TriggerDomain(), 3);
533   // add monitoring filter to event done data
534   CreateEventDoneReadoutFilter(decision.TriggerDomain(), 4);
535   if (decision.Result()) {
536     // add monitoring event command for triggered events
537     CreateEventDoneReadoutFilter(decision.TriggerDomain(), 5);
538   }
539   if (TriggerEvent(&decision) == -ENOSPC)
540   {
541     // Increase the estimated buffer space required if the PushBack methods in TriggerEvent
542     // returned the "no buffer space" error code. Also remember to set the trigger counters
543     // back to what they were, otherwise triggers will be double counted when we try to reprocess
544     // this event with larger buffers.
545     fBufferSizeConst += 1024*1024;
546     fBufferSizeMultiplier *= 2.;
547     fTrigger->SetCounters(originalCounters);
548     if (fTrigger->CallFailed()) return -EPROTO;
549     return -ENOSPC;
550   }
551   return 0;
552 }
553
554
555 int AliHLTGlobalTriggerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
556 {
557   // Reconfigure the component by loading the trigger menu and recreating the
558   // trigger logic class.
559   
560   const char* path = fgkTriggerMenuCDBPath;
561   const char* id = "(unknown)";
562   if (cdbEntry != NULL) path = cdbEntry;
563   if (chainId != NULL and chainId[0] != '\0') id = chainId;
564   HLTInfo("Reconfiguring from '%s' for chain component '%s'.", path, id);
565   
566   const AliHLTTriggerMenu* menu = NULL;
567   int result = LoadTriggerMenu(path, menu);
568   if (result != 0) return result;
569   
570   TString className;
571   TString codeFileName;
572   result = GenerateTrigger(menu, className, codeFileName, fIncludePaths, fIncludeFiles);
573   if (result != 0) return result;
574   
575   AliHLTGlobalTrigger* trigger = NULL;
576   try
577   {
578     trigger = AliHLTGlobalTrigger::CreateNew(className.Data());
579   }
580   catch (const std::bad_alloc&)
581   {
582     HLTError("Could not allocate memory for the AliHLTGlobalTrigger instance.");
583     return -ENOMEM;
584   }
585   if (trigger == NULL)
586   {
587     HLTError("Could not create a new instance of '%s'.", className.Data());
588     // Make sure to cleanup after the new code file.
589     UnloadTriggerClass(codeFileName);
590     if (not codeFileName.IsNull() and gSystem->AccessPathName(codeFileName)==0 and not fDebugMode)
591     {
592       codeFileName.ReplaceAll(".cxx", "*");
593       TString command="rm "; command+=codeFileName;
594       gSystem->Exec(command);
595     }
596     return -EIO;
597   }
598   
599   if (fTrigger != NULL)
600   {
601     delete fTrigger;
602     fTrigger = NULL;
603   }
604   
605   fTrigger = trigger;
606   fTrigger->FillFromMenu(*menu);
607   if (fTrigger->CallFailed()) return -EPROTO;
608
609   // Set the default values from the trigger menu.
610   SetDescription(menu->DefaultDescription());
611   SetTriggerDomain(menu->DefaultTriggerDomain());
612   
613   // Cleanup the old class code.
614   UnloadTriggerClass(fCodeFileName);
615   if (fDeleteCodeFile and not fCodeFileName.IsNull() and gSystem->AccessPathName(fCodeFileName)==0 and not fDebugMode)
616   {
617     fCodeFileName.ReplaceAll(".cxx", "*");
618     TString command="rm "; command+=fCodeFileName;
619     gSystem->Exec(command);
620   }
621   fCodeFileName = codeFileName;
622   fDeleteCodeFile = true;  // Since we generated a new class.
623   
624   return 0;
625 }
626
627
628 int AliHLTGlobalTriggerComponent::LoadTriggerMenu(const char* cdbPath, const AliHLTTriggerMenu*& menu)
629 {
630   // Loads the trigger menu object from the CDB path.
631   
632   HLTDebug("Trying to load trigger menu from '%s'.", cdbPath);
633   if (AliCDBManager::Instance() == NULL)
634   {
635     HLTError("CDB manager object not found.");
636     return -EIO;
637   }
638   AliCDBStorage* store = AliCDBManager::Instance()->GetDefaultStorage();
639   if (store == NULL)
640   {
641     HLTError("Could not get the the default storage for the CDB.");
642     return -EIO;
643   }
644   Int_t version = store->GetLatestVersion(cdbPath, GetRunNo());
645   Int_t subVersion = store->GetLatestSubVersion(cdbPath, GetRunNo(), version);
646   AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, GetRunNo(), version, subVersion);
647   if (entry == NULL)
648   {
649     HLTError("Could not get the CDB entry for \"%s\".", cdbPath);
650     return -EIO;
651   }
652   TObject* obj = entry->GetObject();
653   if (obj == NULL)
654   {
655     HLTError("Configuration object for \"%s\" is missing.", cdbPath);
656     return -ENOENT;
657   }
658   if (obj->IsA() != AliHLTTriggerMenu::Class())
659   {
660     HLTError("Wrong type for configuration object in \"%s\". Found a %s but we expect a AliHLTTriggerMenu.",
661              cdbPath, obj->ClassName()
662     );
663     return -EPROTO;
664   }
665   menu = static_cast<AliHLTTriggerMenu*>(obj);
666   return 0;
667 }
668
669
670 void AliHLTGlobalTriggerComponent::GenerateFileName(TString& name, TString& filename) const
671 {
672   // Creates a unique file name for the generated code.
673   
674   // Start by creating a new UUID. We cannot use the one automatically generated
675   // by ROOT because the algorithm used will not guarantee unique IDs when generating
676   // these UUIDs at a high rate in parallel.
677   TUUID uuid;
678   // We then use the generated UUID to form part of the random number seeds which
679   // will be used to generate a proper random UUID. For good measure we use a MD5
680   // hash also. Note that we want to use the TUUID class because it will combine the
681   // host address information into the UUID. Using gSystem->GetHostByName() apparently
682   // can cause problems on Windows machines with a firewall, because it always tries
683   // to contact a DNS. The TUUID class handles this case appropriately.
684   union
685   {
686     UChar_t buf[16];
687     UShort_t word[8];
688     UInt_t dword[4];
689   };
690   uuid.GetUUID(buf);
691   TMD5 md5;
692   md5.Update(buf, sizeof(buf));
693   md5.Final(buf);
694   dword[0] += gSystem->GetUid();
695   dword[1] += gSystem->GetGid();
696   dword[2] += gSystem->GetPid();
697   for (int i = 0; i < 4; ++i)
698   {
699     gRandom->SetSeed(dword[i]);
700     dword[i] = gRandom->Integer(0xFFFFFFFF);
701   }
702   md5.Update(buf, sizeof(buf));
703   md5.Final(buf);
704   // To keep to the standard we need to set the version and reserved bits.
705   word[3] = (word[3] & 0x0FFF) | 0x4000;
706   buf[8] = (buf[8] & 0x3F) | 0x80;
707
708   // Create the name of the new class and file.
709   char uuidstr[64];
710   sprintf(uuidstr, "%08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x",
711     dword[0], word[2], word[3], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]
712   );
713   name = "AliHLTGlobalTriggerImpl_";
714   name += uuidstr;
715   filename = name + ".cxx";
716
717   // For good measure, check that the file names are not used. If they are then regenerate.
718   fstream file(filename.Data(), ios_base::in);
719   if (file.good())
720   {
721     file.close();
722     GenerateFileName(name, filename);
723   }
724 }
725
726
727 int AliHLTGlobalTriggerComponent::GenerateTrigger(
728     const AliHLTTriggerMenu* menu, TString& name, TString& filename,
729     const TClonesArray& includePaths, const TClonesArray& includeFiles
730   )
731 {
732   // Generates the global trigger class that will implement the specified trigger menu.
733   // See header for more details.
734   
735   GenerateFileName(name, filename);
736   HLTDebug("Generating custom HLT trigger class named %s, in file %s, using trigger menu %p.",
737     name.Data(), filename.Data(), ((void*)menu)
738   );
739   
740   // Open a text file to write the code and generate the new class.
741   fstream code(filename.Data(), ios_base::out | ios_base::trunc);
742   if (not code.good())
743   {
744     HLTError("Could not open file '%s' for writing.", filename.Data());
745     return -EIO;
746   }
747   
748   TClonesArray symbols(AliHLTTriggerMenuSymbol::Class());
749   int result = BuildSymbolList(menu, symbols);
750   if (result != 0) return result;
751   
752   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
753   code << "#include <cstring>" << endl;
754   code << "#include \"TClass.h\"" << endl;
755   code << "#include \"TString.h\"" << endl;
756   code << "#include \"TClonesArray.h\"" << endl;
757   code << "#include \"AliHLTLogging.h\"" << endl;
758   code << "#include \"AliHLTGlobalTrigger.h\"" << endl;
759   code << "#include \"AliHLTGlobalTriggerDecision.h\"" << endl;
760   code << "#include \"AliHLTDomainEntry.h\"" << endl;
761   code << "#include \"AliHLTTriggerDomain.h\"" << endl;
762   code << "#include \"AliHLTReadoutList.h\"" << endl;
763   code << "#include \"AliHLTTriggerMenu.h\"" << endl;
764   code << "#include \"AliHLTTriggerMenuItem.h\"" << endl;
765   code << "#include \"AliHLTTriggerMenuSymbol.h\"" << endl;
766   
767   // Add any include files that were specified on the command line.
768   for (Int_t i = 0; i < includeFiles.GetEntriesFast(); i++)
769   {
770     TString file = static_cast<TObjString*>(includeFiles.UncheckedAt(i))->String();
771     code << "#include \"" << file.Data() << "\"" << endl;
772   }
773   
774   if (fDebugMode)
775   {
776     code << "#else" << endl;
777     code << "const char* gFunctionName = \"???\";" << endl;
778     code << "#define HLTDebug(msg) if (CheckFilter(kHLTLogDebug) && CheckGroup(Class_Name())) SendMessage(kHLTLogDebug, Class_Name(), ::gFunctionName, __FILE__, __LINE__, msg)" << endl;
779   }
780   code << "#endif" << endl;
781   
782   code << "class " << name << " :" << endl;
783   // Add appropriate #ifdef sections since we need to prevent inheritance from
784   // AliHLTGlobalTrigger. CINT does not seem to support multiple inheritance nor
785   // multiple levels of inheritance. Neither of the following schemes worked:
786   //
787   // 1)  class AliHLTGlobalTrigger : public AliHLTLogging {};
788   //     class AliHLTGlobalTriggerImpl_xyz : public AliHLTGlobalTrigger {};
789   //
790   // 2)  class AliHLTGlobalTrigger {};
791   //     class AliHLTGlobalTriggerImpl_xyz : public AliHLTGlobalTrigger, public AliHLTLogging {};
792   //
793   // Thus, we are forced to just inherit from AliHLTLogging when running in the CINT
794   // interpreter. But we anyway have to call the global trigger implementation class
795   // through the AliHLTGlobalTriggerWrapper so this is not such a problem.
796   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
797   code << "  public AliHLTGlobalTrigger," << endl;
798   code << "#endif" << endl;
799   code << "  public AliHLTLogging" << endl;
800   code << "{" << endl;
801   code << "public:" << endl;
802   
803   // Generate constructor method.
804   code << "  " << name << "() :" << endl;
805   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
806   code << "    AliHLTGlobalTrigger()," << endl;
807   code << "#endif" << endl;
808   code << "    AliHLTLogging()";
809   // Write the symbols in the trigger menu in the initialisation list.
810   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
811   {
812     code << "," << endl;
813     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
814     code << "    " << symbol->Name() << "()," << endl;
815     if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0)
816     {
817       code << "    " << symbol->Name() << "TriggerDomain()," << endl;
818     }
819     code << "    " << symbol->Name() << "DomainEntry(kAliHLTAnyDataType)";
820   }
821   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
822   {
823     code << "," << endl << "    fMenuItemDescription" << i << "()";
824   }
825   code << endl << "  {" << endl;
826   if (fDebugMode)
827   {
828     code << "#ifdef __CINT__" << endl;
829     code << "    gFunctionName = \"" << name.Data() <<"\";" << endl;
830     code << "#endif" << endl;
831     code << "    SetLocalLoggingLevel(kHLTLogAll);" << endl;
832     code << "    HLTDebug(Form(\"Creating new instance at %p.\", this));" << endl;
833   }
834   code << "  }" << endl;
835   
836   code << "  virtual ~" << name << "() {" << endl;
837   if (fDebugMode)
838   {
839     code << "#ifdef __CINT__" << endl;
840     code << "    gFunctionName = \"~" << name.Data() << "\";" << endl;
841     code << "#endif" << endl;
842     code << "    HLTDebug(Form(\"Deleting instance at %p.\", this));" << endl;
843   }
844   code << "  }" << endl;
845   
846   // Generate the FillFromMenu method.
847   code << "  virtual void FillFromMenu(const AliHLTTriggerMenu& menu) {" << endl;
848   if (fDebugMode)
849   {
850     code << "#ifdef __CINT__" << endl;
851     code << "    gFunctionName = \"FillFromMenu\";" << endl;
852     code << "#endif" << endl;
853     code << "    HLTDebug(Form(\"Filling description entries from trigger menu for global trigger %p.\", this));" << endl;
854   }
855   code << "    fCounter.Set(menu.NumberOfItems());" << endl;
856   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
857   {
858     code << "    fMenuItemDescription" << i << " = (menu.Item(" << i
859          << ") != NULL) ? menu.Item(" << i << ")->Description() : \"\";" << endl;
860   }
861   if (fDebugMode)
862   {
863     code << "    HLTDebug(Form(\"Finished filling description entries from trigger menu.\"));" << endl;
864     code << "    HLTDebug(Form(\"Filling domain entries from trigger menu symbols for global trigger %p.\", this));" << endl;
865   }
866   code << "    for (Int_t i = 0; i < menu.SymbolArray().GetEntriesFast(); i++) {" << endl;
867   // 30 Oct 2009 - CINT sometimes evaluates the dynamic_cast incorrectly.
868   // Have to use the TClass system for extra protection.
869   code << "      if (menu.SymbolArray().UncheckedAt(i) == NULL) continue;" << endl;
870   code << "      if (menu.SymbolArray().UncheckedAt(i)->IsA() != AliHLTTriggerMenuSymbol::Class()) continue;" << endl;
871   code << "      const AliHLTTriggerMenuSymbol* symbol = dynamic_cast<const"
872            " AliHLTTriggerMenuSymbol*>(menu.SymbolArray().UncheckedAt(i));" << endl;
873   code << "      if (symbol == NULL) continue;" << endl;
874   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
875   {
876     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
877     code << "      if (strcmp(symbol->RealName(), \"" << symbol->RealName() << "\") == 0) {" << endl;
878     if (fDebugMode)
879     {
880       code << "        HLTDebug(Form(\"Assinging domain entry value corresponding with symbol '%s' to '%s'.\","
881               " symbol->RealName(), symbol->BlockType().AsString().Data()));" << endl;
882     }
883     code << "        " << symbol->Name() << "DomainEntry = symbol->BlockType();" << endl;
884     code << "        continue;" << endl;
885     code << "      }" << endl;
886   }
887   code << "    }" << endl;
888   // The following is an optimisation where symbols without any assignment operators
889   // are treated as constant and only initialised in FillFromMenu rather than reseting
890   // them in the NewEvent method.
891   // Note: we putting this initialisation into the constructor can lead to seg faults
892   // under CINT interpretation. Thus we must put it into the FillFromMenu method instead.
893   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
894   {
895     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
896     if (TString(symbol->AssignExpression()) != "") continue;
897     if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0) continue;
898     // CINT has problems with the implicit equals operator for complex types, so if
899     // the type has an equals operater we need to write the operator call explicitly.
900     TClass* clas = TClass::GetClass(symbol->Type());
901     if (clas != NULL and clas->GetMethodAny("operator=") != NULL)
902     {
903       code << "    " << symbol->Name() << ".operator = (" << symbol->DefaultValue() << ");" << endl;
904     }
905     else
906     {
907       code << "    " << symbol->Name() << " = " << symbol->DefaultValue() << ";" << endl;
908     }
909   }
910   if (fDebugMode)
911   {
912     code << "    HLTDebug(Form(\"Finished filling domain entries from trigger menu symbols.\"));" << endl;
913   }
914   code << "  }" << endl;
915   
916   // Generate the NewEvent method.
917   code << "  virtual void NewEvent() {" << endl;
918   if (fDebugMode)
919   {
920     code << "#ifdef __CINT__" << endl;
921     code << "    gFunctionName = \"NewEvent\";" << endl;
922     code << "#endif" << endl;
923     code << "    HLTDebug(Form(\"New event for global trigger object %p, initialising variables to default values.\", this));" << endl;
924   }
925   // Write code to initialise the symbols in the trigger menu to their default values.
926   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
927   {
928     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
929     // The following is an optimisation. If the symbol does not have an assignment expression
930     // then it is effectively a constant symbol and can be initialised earlier and only once.
931     // In this case we initialise it in the FillFromMenu method instead.
932     if (TString(symbol->AssignExpression()) == "") continue;
933     // CINT has problems with the implicit equals operator for complex types, so if
934     // the type has an equals operater we need to write the operator call explicitly.
935     TClass* clas = TClass::GetClass(symbol->Type());
936     if (clas != NULL and clas->GetMethodAny("operator=") != NULL)
937     {
938       code << "    " << symbol->Name() << ".operator = (" << symbol->DefaultValue() << ");" << endl;
939     }
940     else
941     {
942       code << "    " << symbol->Name() << " = " << symbol->DefaultValue() << ";" << endl;
943     }
944     if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0)
945     {
946       code << "    " << symbol->Name() << "TriggerDomain.Clear();" << endl;
947     }
948   }
949   if (fDebugMode)
950   {
951     code << "    HLTDebug(Form(\"Finished initialising variables.\"));" << endl;
952   }
953   code << "  }" << endl;
954   
955   // Generate the Add method.
956   bool haveAssignments = false;
957   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
958   {
959     // First check if we have any symbols with assignment expressions.
960     // This is needed to get rid of the on the fly compilation warning about '_object_' not being used.
961     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
962     TString expr = symbol->AssignExpression();
963     if (expr == "") continue; // Skip entries that have no assignment expression.
964     haveAssignments = true;
965     break;
966   }
967   if (haveAssignments or fDebugMode)
968   {
969     code << "  virtual void Add(const TObject* _object_, const AliHLTComponentDataType& _type_, AliHLTUInt32_t _spec_) {" << endl;
970   }
971   else
972   {
973     code << "  virtual void Add(const TObject* /*_object_*/, const AliHLTComponentDataType& _type_, AliHLTUInt32_t _spec_) {" << endl;
974   }
975   if (fDebugMode)
976   {
977     code << "#ifdef __CINT__" << endl;
978     code << "    gFunctionName = \"Add\";" << endl;
979     code << "#endif" << endl;
980   }
981   code << "    AliHLTDomainEntry _type_spec_(_type_, _spec_);" << endl;
982   if (fDebugMode)
983   {
984     code << "    HLTDebug(Form(\"Adding TObject %p, with class name '%s' from data block"
985             " '%s', to global trigger object %p\", _object_, _object_->ClassName(),"
986             " _type_spec_.AsString().Data(), this));" << endl;
987     code << "    _object_->Print();" << endl;
988     code << "    bool _object_assigned_ = false;" << endl;
989   }
990   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
991   {
992     // Write code to check if the block type, specification and class name is correct.
993     // Then write code to assign the variable from the input object.
994     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
995     TString expr = symbol->AssignExpression();
996     if (expr == "") continue; // Skip entries that have no assignment expression.
997     bool isTrigDecision = strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0;
998     if (fDebugMode)
999     {
1000       if (isTrigDecision)
1001       {
1002         code << "    HLTDebug(Form(\"Trying to match input object to class '"
1003              << symbol->ObjectClass() << "', trigger name '" << symbol->RealName()
1004              << "' and block type '%s'\", " << symbol->Name()
1005              << "DomainEntry.AsString().Data()));" << endl;
1006       }
1007       else
1008       {
1009         code << "    HLTDebug(Form(\"Trying to match input object to class '"
1010              << symbol->ObjectClass() << "' and block type '%s'\", "
1011              << symbol->Name() << "DomainEntry.AsString().Data()));" << endl;
1012       }
1013     }
1014     // 30 Oct 2009 - CINT sometimes evaluates the dynamic_cast incorrectly.
1015     // Have to use the TClass system for extra protection.
1016     code << "    const " << symbol->ObjectClass() << "* " << symbol->Name() << "_object_ = NULL;" << endl;
1017     code << "    if (_object_->InheritsFrom(" << symbol->ObjectClass() << "::Class())) " << symbol->Name()
1018          << "_object_ = dynamic_cast<const " << symbol->ObjectClass()
1019          << "*>(_object_);" << endl;
1020     code << "    if (" << symbol->Name() << "_object_ != NULL && ";
1021     if (isTrigDecision)
1022     {
1023       code << "strcmp(" << symbol->Name() << "_object_->Name(), \""
1024            << symbol->RealName() << "\") == 0 && ";
1025     }
1026     code << symbol->Name() << "DomainEntry == _type_spec_) {" << endl;
1027     TString fullname = symbol->Name();
1028     fullname += "_object_";
1029     expr.ReplaceAll("this", fullname);
1030     code << "      this->" << symbol->Name() << " = " << expr.Data() << ";" << endl;
1031     if (isTrigDecision)
1032     {
1033       code << "      this->" << symbol->Name() << "TriggerDomain = "
1034            << fullname.Data() << "->TriggerDomain();" << endl;
1035     }
1036     if (fDebugMode)
1037     {
1038       code << "      HLTDebug(Form(\"Added TObject %p with class name '%s' to variable "
1039            << symbol->Name() << "\", _object_, _object_->ClassName()));" << endl;
1040       code << "      _object_assigned_ = true;" << endl;
1041     }
1042     code << "    }" << endl;
1043   }
1044   if (fDebugMode)
1045   {
1046     code << "    if (! _object_assigned_) {" << endl;
1047     code << "      HLTDebug(Form(\"Did not assign TObject %p"
1048             " with class name '%s' to any variable.\", _object_, _object_->ClassName()));"
1049          << endl;
1050     code << "    }" << endl;
1051   }
1052   code << "  }" << endl;
1053   
1054   // Generate the CalculateTriggerDecision method.
1055   // This requires code to be generated that checks which items in the trigger menu
1056   // have their conditions asserted and then the trigger domain is generated from
1057   // those fired items.
1058   // The processing will start from the highest priority trigger group and stop
1059   // after at least one trigger from the current priority group being processed
1060   // is positive. For each priority group all the trigger menu items are checked.
1061   // Their combined trigger condition expression must be true for the trigger priority
1062   // group to be triggered positive. The full condition expression is formed by
1063   // concatenating the individual condition expressions. If no trailing operators are
1064   // used in the individual expressions then the default condition operator is placed
1065   // between two concatenated condition expressions.
1066   // If a trigger priority group has at least one trigger fired then the trigger domain
1067   // is calculated such that it will give the same result as the concatenated trigger
1068   // domain merging expressions for all the individual trigger menu items with
1069   // positive results. Again, if no trailing operators are used in the individual
1070   // merging expressions then the default domain operator is placed between two
1071   // expression fragments.
1072   code << "  virtual bool CalculateTriggerDecision(AliHLTTriggerDomain& _domain_, TString& _description_) {" << endl;
1073   if (fDebugMode)
1074   {
1075     code << "#ifdef __CINT__" << endl;
1076     code << "    gFunctionName = \"CalculateTriggerDecision\";" << endl;
1077     code << "#endif" << endl;
1078     code << "    HLTDebug(Form(\"Calculating global HLT trigger result with trigger object at %p.\", this));" << endl;
1079   }
1080   
1081   // Build a list of priorities used in the trigger menu.
1082   std::vector<UInt_t> priorities;
1083   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
1084   {
1085     const AliHLTTriggerMenuItem* item = menu->Item(i);
1086     bool priorityNotInList = std::find(priorities.begin(), priorities.end(), item->Priority()) == priorities.end();
1087     if (priorityNotInList) priorities.push_back(item->Priority());
1088   }
1089   std::sort(priorities.begin(), priorities.end(), AliHLTDescendingNumbers);
1090   // From the priority list, build the priority groups in the correct order,
1091   // i.e. highest priority first.
1092   // The priority group is a list of vectors of integers. The integers are the
1093   // index numbers into the trigger menu item list for the items which form part
1094   // of the priority group.
1095   std::vector<std::vector<Int_t> > priorityGroup;
1096   priorityGroup.insert(priorityGroup.begin(), priorities.size(), std::vector<Int_t>());
1097   for (size_t n = 0; n < priorities.size(); n++)
1098   {
1099     UInt_t priority = priorities[n];
1100     for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
1101     {
1102       const AliHLTTriggerMenuItem* item = menu->Item(i);
1103       if (item->Priority() == priority) priorityGroup[n].push_back(i);
1104     }
1105   }
1106   
1107   for (size_t n = 0; n < priorityGroup.size(); n++)
1108   {
1109     if (fDebugMode)
1110     {
1111       code << "    HLTDebug(Form(\"Processing trigger priority group " << priorities[n] << "\"));" << endl;
1112     }
1113     code << "    ";
1114     if (n == 0) code << "UInt_t ";
1115     code << "_previous_match_ = 0xFFFFFFFF;" << endl;
1116     code << "    ";
1117     if (n == 0) code << "bool ";
1118     code << "_trigger_matched_ = false;" << endl;
1119     code << "    ";
1120     if (n == 0) code << "bool ";
1121     code << "_group_result_ = false;" << endl;
1122     std::vector<TString> conditionOperator;
1123     conditionOperator.insert(conditionOperator.begin(), priorityGroup[n].size(), TString(""));
1124     std::vector<TString> domainOperator;
1125     domainOperator.insert(domainOperator.begin(), priorityGroup[n].size(), TString(""));
1126     for (size_t m = 0; m < priorityGroup[n].size(); m++)
1127     {
1128       UInt_t i = priorityGroup[n][m];
1129       const AliHLTTriggerMenuItem* item = menu->Item(i);
1130       TString triggerCondition = item->TriggerCondition();
1131       TString mergeExpr = item->MergeExpression();
1132       // Replace the symbols found in the trigger condition and merging expressions
1133       // with appropriate compilable versions.
1134       for (Int_t j = 0; j < symbols.GetEntriesFast(); j++)
1135       {
1136         AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(j) );
1137         bool symbolNamesDifferent = strcmp(symbol->RealName(), symbol->Name()) != 0;
1138         if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0)
1139         {
1140           TString newname = symbol->Name();
1141           newname += "TriggerDomain";
1142           mergeExpr.ReplaceAll(symbol->RealName(), newname);
1143         }
1144         else
1145         {
1146           if (symbolNamesDifferent) mergeExpr.ReplaceAll(symbol->RealName(), symbol->Name());
1147         }
1148         if (symbolNamesDifferent) triggerCondition.ReplaceAll(symbol->RealName(), symbol->Name());
1149       }
1150       // We allow the trigger conditions and merging expressions to have trailing operators.
1151       // Thus, we need to extract the operators and cleanup the expressions so that they will
1152       // compile. This means that we silently ignore the trailing operator if not needed.
1153       if (ExtractedOperator(triggerCondition, conditionOperator[m]))
1154       {
1155         // If the trailing operator is the same as the default operator then reset
1156         // the value in the operator list so that the default is used in the generated
1157         // code. This creates more compact code.
1158         if (conditionOperator[m] == menu->DefaultConditionOperator()) conditionOperator[m] = "";
1159       }
1160       if (ExtractedOperator(mergeExpr, domainOperator[m]))
1161       {
1162         if (domainOperator[m] == menu->DefaultDomainOperator()) domainOperator[m] = "";
1163       }
1164       if (fDebugMode)
1165       {
1166         code << "    HLTDebug(Form(\"Trying trigger condition " << i
1167              << " (Description = '%s').\", fMenuItemDescription" << i << ".Data()));"
1168              << endl;
1169       }
1170       code << "    ";
1171       if (n == 0 and m == 0) code << "bool ";
1172       code << "_item_result_ = false;" << endl;
1173       code << "    if (" << triggerCondition << ") {" << endl;
1174       code << "      ++fCounter[" << i << "];" << endl;
1175       const char* indentation = "";
1176       if (item->PreScalar() != 0)
1177       {
1178         indentation = "  ";
1179         code << "      if ((fCounter[" << i << "] % " << item->PreScalar() << ") == 1) {" << endl;
1180       }
1181       code << indentation << "      _item_result_ = true;" << endl;
1182       if (fDebugMode)
1183       {
1184         code << indentation << "      HLTDebug(Form(\"Matched trigger condition " << i
1185              << " (Description = '%s').\", fMenuItemDescription" << i << ".Data()));" << endl;
1186       }
1187       if (item->PreScalar() != 0)
1188       {
1189         code << "      }" << endl;
1190       }
1191       code << "    }" << endl;
1192       if (m == 0)
1193       {
1194         // Since this is the first item of the trigger group,
1195         // the generated trigger logic can be simplified a little.
1196         code << "    _group_result_ = _item_result_;" << endl;
1197         code << "    if (_item_result_) {" << endl;
1198         code << "      _domain_ = " << mergeExpr.Data() << ";" << endl;
1199         code << "      _description_ = fMenuItemDescription" << i << ";" << endl;
1200         code << "      _previous_match_ = " << i << ";" << endl;
1201         code << "      _trigger_matched_ = true;" << endl;
1202         code << "    }" << endl;
1203       }
1204       else
1205       {
1206         if (conditionOperator[m-1] == "")
1207         {
1208           code << "    _group_result_ = _group_result_ "
1209                << menu->DefaultConditionOperator() << " _item_result_;" << endl;
1210         }
1211         else
1212         {
1213           code << "    _group_result_ = _group_result_ "
1214                << conditionOperator[m-1] << " _item_result_;" << endl;
1215         }
1216         code << "    if (_item_result_) {" << endl;
1217         code << "      if (_trigger_matched_) {" << endl;
1218         bool switchWillBeEmpty = true;
1219         for (size_t k = 0; k < m; k++)
1220         {
1221           if (domainOperator[k] == "") continue;
1222           switchWillBeEmpty = false;
1223         }
1224         if (switchWillBeEmpty)
1225         {
1226           code << "        _domain_ = _domain_ " << menu->DefaultDomainOperator() << " "
1227                << mergeExpr.Data() << ";" << endl;
1228         }
1229         else
1230         {
1231           code << "        switch(_previous_match_) {" << endl;
1232           for (size_t k = 0; k < m; k++)
1233           {
1234             if (domainOperator[k] == "") continue;
1235             code << "        case " << k << ": _domain_ = _domain_ "
1236                  << domainOperator[k] << " " << mergeExpr.Data() << "; break;" << endl;
1237           }
1238           code << "        default: _domain_ = _domain_ "
1239                << menu->DefaultDomainOperator() << " " << mergeExpr.Data() << ";" << endl;
1240           code << "        }" << endl;
1241         }
1242         code << "        _description_ += \",\";" << endl;
1243         code << "        _description_ += fMenuItemDescription" << i << ";" << endl;
1244         code << "      } else {" << endl;
1245         code << "        _domain_ = " << mergeExpr.Data() << ";" << endl;
1246         code << "        _description_ = fMenuItemDescription" << i << ";" << endl;
1247         code << "      }" << endl;
1248         code << "      _previous_match_ = " << i << ";" << endl;
1249         code << "      _trigger_matched_ = true;" << endl;
1250         code << "    }" << endl;
1251       }
1252     }
1253     code << "    if (_group_result_) {" << endl;
1254     if (fDebugMode)
1255     {
1256       if (n < priorities.size() - 1)
1257       {
1258         code << "      HLTDebug(Form(\"Matched triggers in trigger priority group " << priorities[n]
1259              << ". Stopping processing here because all other trigger groups have lower priority.\"));" << endl;
1260       }
1261       else
1262       {
1263         code << "      HLTDebug(Form(\"Matched triggers in trigger priority group " << priorities[n] << ".\"));" << endl;
1264       }
1265     }
1266     code << "      return true;" << endl;
1267     code << "    }" << endl;
1268   }
1269   code << "    _domain_.Clear();" << endl;
1270   code << "    _description_ = \"\";" << endl;
1271   code << "    return false;" << endl;
1272   code << "  }" << endl;
1273   
1274   // Generate getter and setter methods for the counters.
1275   code << "  const TArrayL64& GetCounters() const { return fCounter; }" << endl;
1276   code << "  void SetCounters(const TArrayL64& counters) { fCounter = counters; }" << endl;
1277   
1278   code << "private:" << endl;
1279   // Add the symbols in the trigger menu to the list of private variables.
1280   for (Int_t i = 0; i < symbols.GetEntriesFast(); i++)
1281   {
1282     AliHLTTriggerMenuSymbol* symbol = static_cast<AliHLTTriggerMenuSymbol*>( symbols.UncheckedAt(i) );
1283     code << "  " << symbol->Type() << " " << symbol->Name() << ";" << endl;
1284     if (strcmp(symbol->ObjectClass(), "AliHLTTriggerDecision") == 0)
1285     {
1286       code << "  AliHLTTriggerDomain " << symbol->Name() << "TriggerDomain;" << endl;
1287     }
1288     code << "  AliHLTDomainEntry " << symbol->Name() << "DomainEntry;" << endl;
1289   }
1290   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
1291   {
1292     code << "  TString fMenuItemDescription" << i << ";" << endl;
1293   }
1294   code << "  TArrayL64 fCounter;" << endl;
1295   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
1296   code << "  ClassDef(" << name.Data() << ", 0)" << endl;
1297   code << "#else" << endl;
1298   code << "  virtual const char* Class_Name() const { return \"" << name.Data() << "\"; }" << endl;
1299   code << "#endif" << endl;
1300   code << "};" << endl;
1301   code << "#if !defined(__CINT__) || defined(__MAKECINT__)" << endl;
1302   code << "ClassImp(" << name.Data() << ")" << endl;
1303   code << "#endif" << endl;
1304   
1305   code.close();
1306   
1307   // Now we need to compile and load the new class.
1308   result = LoadTriggerClass(filename, includePaths);
1309   return result;
1310 }
1311
1312
1313 int AliHLTGlobalTriggerComponent::LoadTriggerClass(
1314     const char* filename, const TClonesArray& includePaths
1315   )
1316 {
1317   // Loads the code for a custom global trigger class implementation on the fly.
1318   
1319   HLTDebug("Loading HLT trigger class from file '%s'.", filename);
1320   
1321   TString compiler = gSystem->GetBuildCompilerVersion();
1322   if (fRuntimeCompile && (compiler.Contains("gcc") or compiler.Contains("icc")))
1323   {
1324     TString includePath;
1325 #if defined(PKGINCLUDEDIR)
1326     // this is especially for the HLT build system where the package is installed
1327     // in a specific directory including proper treatment of include files
1328     includePath.Form("-I%s", PKGINCLUDEDIR);
1329 #else
1330     // the default AliRoot behavior, all include files can be found in the
1331     // $ALICE_ROOT subfolders
1332     includePath = "-I${ALICE_ROOT}/include -I${ALICE_ROOT}/HLT/BASE -I${ALICE_ROOT}/HLT/trigger";
1333 #endif
1334     // Add any include paths that were specified on the command line.
1335     for (Int_t i = 0; i < includePaths.GetEntriesFast(); i++)
1336     {
1337       TString path = static_cast<TObjString*>(includePaths.UncheckedAt(i))->String();
1338       includePath += " -I";
1339       includePath += path;
1340     }
1341     HLTDebug("using include settings: %s", includePath.Data());
1342     gSystem->SetIncludePath(includePath);
1343     gSystem->SetFlagsOpt("-O3 -DNDEBUG");
1344     gSystem->SetFlagsDebug("-g3 -DDEBUG -D__DEBUG");
1345     
1346     int result = kTRUE;
1347     if (fDebugMode)
1348     {
1349       result = gSystem->CompileMacro(filename, "g");
1350     }
1351     else
1352     {
1353       result = gSystem->CompileMacro(filename, "O");
1354     }
1355     if (result != kTRUE)
1356     {
1357       HLTFatal("Could not compile and load global trigger menu implementation.");
1358       return -ENOENT;
1359     }
1360   }
1361   else
1362   {
1363     // Store the library state to be checked later in UnloadTriggerClass.
1364     fLibStateAtLoad = gSystem->GetLibraries();
1365     
1366     // If we do not support the compiler then try interpret the class instead.
1367     TString cmd = ".L ";
1368     cmd += filename;
1369     Int_t errorcode = TInterpreter::kNoError;
1370     gROOT->ProcessLine(cmd, &errorcode);
1371     if (errorcode != TInterpreter::kNoError)
1372     {
1373       HLTFatal("Could not load interpreted global trigger menu implementation"
1374                " (Interpreter error code = %d).",
1375                errorcode
1376       );
1377       return -ENOENT;
1378     }
1379   }
1380   
1381   return 0;
1382 }
1383
1384
1385 int AliHLTGlobalTriggerComponent::UnloadTriggerClass(const char* filename)
1386 {
1387   // Unloads the code previously loaded by LoadTriggerClass.
1388   
1389   HLTDebug("Unloading HLT trigger class in file '%s'.", filename);
1390   
1391   TString compiler = gSystem->GetBuildCompilerVersion();
1392   if (fRuntimeCompile && (compiler.Contains("gcc") or compiler.Contains("icc")))
1393   {
1394     // Generate the library name.
1395     TString libname = filename;
1396     Ssiz_t dotpos = libname.Last('.');
1397     if (0 <= dotpos and dotpos < libname.Length()) libname[dotpos] = '_';
1398     libname += ".";
1399     libname += gSystem->GetSoExt();
1400     
1401     // This is a workaround for a problem with unloading shared libraries in ROOT.
1402     // If the trigger logic library is loaded before the libAliHLTHOMER.so library
1403     // or any other library is loaded afterwards, then during the gInterpreter->UnloadFile
1404     // call all the subsequent libraries get unloded. This means that any objects created
1405     // from classes implemented in the libAliHLTHOMER.so library will generate segfaults
1406     // since the executable code has been unloaded.
1407     // We need to check if there are any more libraries loaded after the class we
1408     // are unloading and in that case don't unload the class.
1409     TString libstring = gSystem->GetLibraries();
1410     TString token, lastlib;
1411     Ssiz_t from = 0;
1412     Int_t numOfLibs = 0, posOfLib = -1;
1413     while (libstring.Tokenize(token, from, " "))
1414     {
1415       ++numOfLibs;
1416       lastlib = token;
1417       if (token.Contains(libname)) posOfLib = numOfLibs;
1418     }
1419     if (numOfLibs != posOfLib)
1420     {
1421       HLTWarning(Form("ROOT limitation! Cannot properly cleanup and unload the shared"
1422           " library '%s' since another library '%s' was loaded afterwards. Trying to"
1423           " unload this library will remove the others and lead to serious memory faults.",
1424           libname.Data(), lastlib.Data()
1425       ));
1426       return 0;
1427     }
1428     
1429     char* path = NULL;
1430     int result = 0;
1431     if ((path = gSystem->DynamicPathName(libname)) != NULL)
1432     {
1433       result = gInterpreter->UnloadFile(path);
1434       delete [] path;
1435     }
1436     if (result != TInterpreter::kNoError) return -ENOENT;
1437   }
1438   else
1439   {
1440     // This is again a workaround for the problem with unloading files in ROOT.
1441     // If the trigger logic class is loaded before the libAliHLTHOMER.so library
1442     // or any other library is loaded afterwards, then during the gInterpreter->UnloadFile
1443     // call all the subsequent libraries get unloded.
1444     // We need to check if the list of loaded libraries has changed since the last
1445     // call to LoadTriggerClass. If it has then don't unload the class.
1446     if (fLibStateAtLoad != gSystem->GetLibraries())
1447     {
1448       TString libstring = gSystem->GetLibraries();
1449       TString token;
1450       Ssiz_t from = 0;
1451       while (libstring.Tokenize(token, from, " "))
1452       {
1453         if (not fLibStateAtLoad.Contains(token)) break;
1454       }
1455       HLTWarning(Form("ROOT limitation! Cannot properly cleanup and unload the file"
1456           " '%s' since another library '%s' was loaded afterwards. Trying to unload"
1457           " this file will remove the other library and lead to serious memory faults.",
1458           filename, token.Data()
1459       ));
1460       return 0;
1461     }
1462   
1463     // If we did not compile the trigger logic then remove the interpreted class.
1464     TString cmd = ".U ";
1465     cmd += filename;
1466     Int_t errorcode = TInterpreter::kNoError;
1467     gROOT->ProcessLine(cmd, &errorcode);
1468     if (errorcode != TInterpreter::kNoError)
1469     {
1470       HLTFatal("Could not unload interpreted global trigger menu implementation"
1471                " (Interpreter error code = %d).",
1472                errorcode
1473       );
1474       return -ENOENT;
1475     }
1476   }
1477   
1478   return 0;
1479 }
1480
1481
1482 int AliHLTGlobalTriggerComponent::FindSymbol(const char* name, const TClonesArray& list)
1483 {
1484   // Searches for the named symbol in the given list.
1485   // See header for more details.
1486   
1487   for (int i = 0; i < list.GetEntriesFast(); i++)
1488   {
1489     const AliHLTTriggerMenuSymbol* symbol = dynamic_cast<const AliHLTTriggerMenuSymbol*>( list.UncheckedAt(i) );
1490     if (symbol == NULL) continue;
1491     if (strcmp(symbol->Name(), name) == 0) return i;
1492   }
1493   return -1;
1494 }
1495
1496
1497 int AliHLTGlobalTriggerComponent::BuildSymbolList(const AliHLTTriggerMenu* menu, TClonesArray& list)
1498 {
1499   // Builds the list of symbols to use in the custom global trigger menu
1500   // implementation class.
1501   // See header for more details.
1502   
1503   // Note: when we build the symbol list we must use the symbol name as returned
1504   // by the Name() method and not the RealName() method when using FindSymbol.
1505   // This is so that we avoid problems with the generated code not compiling
1506   // because names like "abc-xyz" and "abc_xyz" are synonymous.
1507   // Name() returns the converted C++ symbol name as used in the generated code.
1508   
1509   for (UInt_t i = 0; i < menu->NumberOfSymbols(); i++)
1510   {
1511     const AliHLTTriggerMenuSymbol* symbol = menu->Symbol(i);
1512     if (FindSymbol(symbol->Name(), list) != -1)
1513     {
1514       HLTError("Multiple symbols with the name '%s' defined in the trigger menu.", symbol->Name());
1515       return -EIO;
1516     }
1517     try
1518     {
1519       new (list[list.GetEntriesFast()]) AliHLTTriggerMenuSymbol(*symbol);
1520     }
1521     catch (const std::bad_alloc&)
1522     {
1523       HLTError("Could not allocate more memory for the symbols list when adding a trigger menu symbol.");
1524       return -ENOMEM;
1525     }
1526   }
1527   
1528   TRegexp exp("[_a-zA-Z][-_a-zA-Z0-9]*");
1529   TRegexp hexexp("x[a-fA-F0-9]+");
1530   for (UInt_t i = 0; i < menu->NumberOfItems(); i++)
1531   {
1532     const AliHLTTriggerMenuItem* item = menu->Item(i);
1533     TString str = item->TriggerCondition();
1534     Ssiz_t start = 0;
1535     do
1536     {
1537       Ssiz_t length = 0;
1538       Ssiz_t pos = exp.Index(str, &length, start);
1539       if (pos == kNPOS) break;
1540       start = pos+length;
1541       
1542       // Check if there is a numerical character before the found
1543       // regular expression. If so, then the symbol is not a valid one
1544       // and should be skipped.
1545       if (pos > 0)
1546       {
1547         bool notValid = false;
1548         switch (str[pos-1])
1549         {
1550         case '0': case '1': case '2': case '3': case '4':
1551         case '5': case '6': case '7': case '8': case '9':
1552           notValid = true;
1553           break;
1554         default:
1555           notValid = false;
1556           break;
1557         }
1558         if (notValid) continue;
1559       }
1560       TString s = str(pos, length);
1561       
1562       if (s == "and" or s == "and_eq" or s == "bitand" or s == "bitor" or
1563           s == "compl" or s == "not" or s == "not_eq" or s == "or" or
1564           s == "or_eq" or s == "xor" or s == "xor_eq" or s == "true" or
1565           s == "false"
1566          )
1567       {
1568         // Ignore iso646.h and other keywords.
1569         continue;
1570       }
1571
1572       // Need to create the symbols first and check if its name is in the list
1573       // before actually adding it to the symbols list.
1574       AliHLTTriggerMenuSymbol newSymbol;
1575       newSymbol.Name(s.Data());
1576       newSymbol.Type("bool");
1577       newSymbol.ObjectClass("AliHLTTriggerDecision");
1578       newSymbol.AssignExpression("this->Result()");
1579       newSymbol.DefaultValue("false");
1580       if (FindSymbol(newSymbol.Name(), list) == -1)
1581       {
1582         try
1583         {
1584           new (list[list.GetEntriesFast()]) AliHLTTriggerMenuSymbol(newSymbol);
1585         }
1586         catch (const std::bad_alloc&)
1587         {
1588           HLTError("Could not allocate more memory for the symbols list when adding a trigger name symbol.");
1589           return -ENOMEM;
1590         }
1591       }
1592     }
1593     while (start < str.Length());
1594   }
1595   
1596   return 0;
1597 }
1598
1599
1600 bool AliHLTGlobalTriggerComponent::ExtractedOperator(TString& expr, TString& op)
1601 {
1602   // Extracts the trailing operator from the expression.
1603   
1604   Ssiz_t i = 0;
1605   // First skip the trailing whitespace.
1606   bool whitespace = true;
1607   for (i = expr.Length()-1; i >= 0 and whitespace; i--)
1608   {
1609     switch (expr[i])
1610     {
1611     case ' ': case '\t': case '\r': case '\n':
1612       whitespace = true;
1613       break;
1614     default:
1615       whitespace = false;
1616     }
1617   }
1618   if (i < 0 or whitespace) return false;
1619   
1620   // Now find the first whitespace character before the trailing symbol.
1621   bool nonwhitespace = true;
1622   for (; i >= 0 and nonwhitespace; i--)
1623   {
1624     switch (expr[i])
1625     {
1626     case ' ': case '\t': case '\r': case '\n':
1627       nonwhitespace = false;
1628       break;
1629     default:
1630       nonwhitespace = true;
1631     }
1632   }
1633   if (i < 0 or nonwhitespace) return false;
1634   
1635   // Extract the last symbols and check if it is a valid operator.
1636   TString s = expr;
1637   s.Remove(0, i+2);
1638   if (s == "and" or s == "and_eq" or s == "bitand" or s == "bitor" or
1639       s == "compl" or s == "not" or s == "not_eq" or s == "or" or
1640       s == "or_eq" or s == "xor" or s == "xor_eq" or s == "&&" or
1641       s == "&=" or s == "&" or s == "|" or s == "~" or s == "!" or
1642       s == "!=" or s == "||" or s == "|=" or s == "^" or s == "^=" or
1643       s == "==" or s == "+" or s == "-" or s == "*" or s == "/" or
1644       s == "%" or s == ">" or s == "<" or s == ">=" or s == "<="
1645      )
1646   {
1647     expr.Remove(i+1);
1648     op = s;
1649     return true;
1650   }
1651   
1652   return false;
1653 }
1654
1655
1656 int AliHLTGlobalTriggerComponent::PrintStatistics(const AliHLTGlobalTrigger* pTrigger, AliHLTComponentLogSeverity level, int offset) const
1657 {
1658   // print some statistics
1659   int totalEvents=GetEventCount()+offset;
1660   const TArrayL64& counters = pTrigger->GetCounters();
1661   if (pTrigger->CallFailed()) return -EPROTO;
1662   for (int i = 0; i < counters.GetSize(); i++) {
1663     ULong64_t count = counters[i];
1664     float ratio=0;
1665     if (totalEvents>0) ratio=100*(float)count/totalEvents;
1666     HLTLog(level, "Item %d: total events: %d - counted events: %llu (%.1f%%)", i, totalEvents, count, ratio);
1667   }
1668   return 0;
1669 }
1670
1671 int AliHLTGlobalTriggerComponent::AddCTPDecisions(AliHLTGlobalTrigger* pTrigger, const AliHLTCTPData* pCTPData, const AliHLTComponentTriggerData* trigData)
1672 {
1673   // add trigger decisions for the valid CTP classes
1674   if (!pCTPData || !pTrigger) return 0;
1675
1676   AliHLTUInt64_t triggerMask=pCTPData->Mask();
1677   AliHLTUInt64_t bit0=0x1;
1678   if (!fCTPDecisions) {
1679     try
1680     {
1681       fCTPDecisions=new TClonesArray(AliHLTTriggerDecision::Class(), gkNCTPTriggerClasses);
1682     }
1683     catch (const std::bad_alloc&)
1684     {
1685       HLTError("Could not allocate memory for the CTP decisions array.");
1686       return -ENOMEM;
1687     }
1688     if (!fCTPDecisions) return -ENOMEM;
1689
1690     try
1691     {
1692       fCTPDecisions->ExpandCreate(gkNCTPTriggerClasses);
1693     }
1694     catch (const std::bad_alloc&)
1695     {
1696       HLTError("Could not allocate more memory for the CTP decisions array.");
1697       return -ENOMEM;
1698     }
1699     for (int i=0; i<gkNCTPTriggerClasses; i++) {
1700       const char* name=pCTPData->Name(i);
1701       if (triggerMask&(bit0<<i) && name) {
1702         AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(fCTPDecisions->At(i));
1703         assert(pDecision);
1704         if (!pDecision) {
1705           delete fCTPDecisions;
1706           fCTPDecisions=NULL;
1707           return -ENOENT;
1708         }
1709         pDecision->Name(name);
1710       }
1711     }
1712   }
1713
1714   for (int i=0; i<gkNCTPTriggerClasses; i++) {
1715     const char* name=pCTPData->Name(i);
1716     if ((triggerMask&(bit0<<i))==0 || name==NULL) continue;
1717     AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(fCTPDecisions->At(i));
1718     HLTDebug("updating CTP trigger decision %d %s (%p casted %p)", i, name, fCTPDecisions->At(i), pDecision);
1719     if (!pDecision) return -ENOENT;
1720
1721     bool result=false;
1722     // 13 March 2010 - Optimisation:
1723     // Dont use the EvaluateCTPTriggerClass method, which uses slow TFormula objects.
1724     AliHLTUInt64_t triggers = 0;
1725     if (trigData) triggers = pCTPData->ActiveTriggers(*trigData);
1726     else triggers = pCTPData->Triggers();
1727     result = (triggers&((AliHLTUInt64_t)0x1<<i)) ? true : false;
1728     //if (trigData) result=pCTPData->EvaluateCTPTriggerClass(name, *trigData);
1729     //else result=pCTPData->EvaluateCTPTriggerClass(name);
1730     pDecision->Result(result);
1731     pDecision->TriggerDomain().Clear();
1732     if (trigData) pDecision->TriggerDomain().Add(pCTPData->ReadoutList(*trigData));
1733     else pDecision->TriggerDomain().Add(pCTPData->ReadoutList());
1734
1735     pTrigger->Add(fCTPDecisions->At(i), kAliHLTDataTypeTriggerDecision, kAliHLTVoidDataSpec);
1736     if (pTrigger->CallFailed()) return -EPROTO;
1737   }
1738
1739   return 0;
1740 }