HLT/BASE/AliHLTProcessor.cxx

   1 // $Id$
   2
   3 ///**************************************************************************
   4 // * This file is property of and copyright by the                          *
   5 // * ALICE Experiment at CERN, All rights reserved.                         *
   6 // *                                                                        *
   7 // * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
   8 // *                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
   9 // *                  for The ALICE HLT Project.                            *
  10 // *                                                                        *
  11 // * Permission to use, copy, modify and distribute this software and its   *
  12 // * documentation strictly for non-commercial purposes is hereby granted   *
  13 // * without fee, provided that the above copyright notice appears in all   *
  14 // * copies and that both the copyright notice and this permission notice   *
  15 // * appear in the supporting documentation. The authors make no claims     *
  16 // * about the suitability of this software for any purpose. It is          *
  17 // * provided "as is" without express or implied warranty.                  *
  18 // **************************************************************************
  19
  20 /// @file   AliHLTProcessor.cxx
  21 /// @author Matthias Richter, Timm Steinbeck
  22 /// @date
  23 /// @brief  Base class implementation for HLT analysis components.
  24 ///
  25
  26 #include "AliHLTProcessor.h"
  27 #include <string.h>
  28 #include "TDatime.h"
  29 #include "TString.h"
  30
  31 /** ROOT macro for the implementation of ROOT specific class methods */
  32 ClassImp(AliHLTProcessor)
  33
  34 AliHLTProcessor::AliHLTProcessor()
  35   : AliHLTComponent()
  36   , fpDebugCounters(NULL)
  37 {
  38 }
  39
  40 AliHLTProcessor::~AliHLTProcessor()
  41 {
  42   // destructor
  43   if (fpDebugCounters) delete fpDebugCounters;
  44   fpDebugCounters=NULL;
  45 }
  46
  47 int AliHLTProcessor::DoProcessing( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
  48                             AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
  49                             AliHLTUInt32_t& size,
  50                             AliHLTComponentBlockDataList& outputBlocks,
  51                             AliHLTComponentEventDoneData*& edd )
  52 {
  53   // Processing method, calls child's DoEvent
  54   int iResult=0;
  55   ReleaseEventDoneData();
  56
  57   iResult=DoEvent(evtData, blocks, trigData, outputPtr, size, outputBlocks);
  58
  59   edd = NULL;
  60   AliHLTComponentEventDoneData* eddTmp = GetCurrentEventDoneData();
  61   if (eddTmp) {
  62     int ret = GetEventDoneData(eddTmp->fDataSize, &edd);
  63     if (ret) {
  64       HLTError( "Cannot get event done data of %u bytes for event %lu: error (%d)",
  65                 eddTmp->fDataSize, evtData.fEventID, ret );
  66       return -ENOMEM;
  67     }
  68     edd->fStructSize = sizeof(AliHLTComponentEventDoneData);
  69     edd->fDataSize = eddTmp->fDataSize;
  70     edd->fData = reinterpret_cast<AliHLTUInt8_t*>(edd)+edd->fStructSize;
  71     memcpy( edd->fData, eddTmp->fData, eddTmp->fDataSize );
  72
  73     // 2009-12-07 want to make this switchable, but this first needs some
  74     // extension in the online framework to change the log level settings
  75     // in the component while running
  76     if (false/*CheckFilter(kHLTLogDebug)*/) {
  77       if (!fpDebugCounters) {
  78         fpDebugCounters=new AliHLTProcessorCounters;
  79       }
  80       if (fpDebugCounters) {
  81         int wordCnt=edd->fDataSize/4;
  82         AliHLTUInt32_t* buffer=reinterpret_cast<AliHLTUInt32_t*>(edd->fData);
  83         int word=0;
  84         while (word<wordCnt) {
  85           switch (buffer[word]) {
  86           case 3:
  87             fpDebugCounters->fReadoutFilter++;
  88             word+=1+buffer[word+1]*4;
  89             break;
  90           case 4:
  91             fpDebugCounters->fMonitoringFilter++;
  92             word+=1+buffer[word+1]*4;
  93             break;
  94           case 5:
  95             fpDebugCounters->fMonitoringEvent++;
  96             break;
  97           default:
  98             fpDebugCounters->fMismatch++;
  99             break;
 100           }
 101           word++;
 102         }
 103
 104         static UInt_t lastTime=0;
 105         TDatime time;
 106         if (time.Get()-lastTime>1) {
 107           lastTime=time.Get();
 108           HLTImportant("EventDoneData size %d: readout %d, monitoring filter %d, monitoring event %d, format error %d",
 109                        edd->fDataSize, fpDebugCounters->fReadoutFilter, fpDebugCounters->fMonitoringFilter, fpDebugCounters->fMonitoringEvent, fpDebugCounters->fMismatch);
 110           for (int i=0; i< wordCnt; ) {
 111             TString message;
 112             for (int j=0; j<4 && i<wordCnt; j++) {
 113               TString number; number.Form("0x%08x ", buffer[i++]);
 114               message+=number;
 115             }
 116             HLTImportant("   %s", message.Data());
 117           }
 118         }
 119       }
 120     }
 121   }
 122   return iResult;
 123 }
 124
 125 int AliHLTProcessor::DoEvent( const AliHLTComponentEventData& evtData,
 126                               const AliHLTComponentBlockData* /*blocks*/,
 127                               AliHLTComponentTriggerData& trigData,
 128                               AliHLTUInt8_t* /*outputPtr*/,
 129                               AliHLTUInt32_t& size,
 130                               AliHLTComponentBlockDataList& /*outputBlocks*/ )
 131 {
 132   // we just forward to the high level method, all other parameters already
 133   // have been stored internally
 134   size=0;
 135   return DoEvent(evtData, trigData);
 136 }
 137
 138 int AliHLTProcessor::DoEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
 139 {
 140   // default method: one of DoEvent methods must be implemented
 141   HLTFatal("no processing method implemented");
 142   return -ENOSYS;
 143 }