adding the MonitoringRelay component
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 16 Nov 2009 23:55:49 +0000 (23:55 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 16 Nov 2009 23:55:49 +0000 (23:55 +0000)
The MonitoringRelay can be used together with components producing histograms and publishing those
just for a scaled down number of events. The relay keeps a copy of the binary data block for every
new TObject, though objects are unpacked in order to extract name and title. The component publishes
the binary blocks for every event, the time consuming streaming however is avoided.
First version, needs to be fully tested.

HLT/BASE/util/AliHLTAgentUtil.cxx
HLT/BASE/util/AliHLTMonitoringRelay.cxx [new file with mode: 0644]
HLT/BASE/util/AliHLTMonitoringRelay.h [new file with mode: 0644]
HLT/libAliHLTUtil.pkg

index 75e831c..e22492b 100644 (file)
@@ -40,6 +40,7 @@
 #include "AliHLTFileWriter.h"
 #include "AliHLTFilePublisher.h"
 #include "AliHLTBlockFilterComponent.h"
+#include "AliHLTMonitoringRelay.h"
 #include "AliHLTEsdCollectorComponent.h"
 #include "AliHLTReadoutListDumpComponent.h"
 #include "AliHLTOUTPublisherComponent.h"
@@ -122,6 +123,7 @@ int AliHLTAgentUtil::RegisterComponents(AliHLTComponentHandler* pHandler) const
   pHandler->AddComponent(new AliHLTFileWriter);
   pHandler->AddComponent(new AliHLTFilePublisher);
   pHandler->AddComponent(new AliHLTBlockFilterComponent);
+  pHandler->AddComponent(new AliHLTMonitoringRelay);
   pHandler->AddComponent(new AliHLTEsdCollectorComponent);
   pHandler->AddComponent(new AliHLTReadoutListDumpComponent);
   pHandler->AddComponent(new AliHLTOUTPublisherComponent);
diff --git a/HLT/BASE/util/AliHLTMonitoringRelay.cxx b/HLT/BASE/util/AliHLTMonitoringRelay.cxx
new file mode 100644 (file)
index 0000000..9242666
--- /dev/null
@@ -0,0 +1,282 @@
+// $Id$
+
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
+//*                  for The ALICE HLT Project.                            *
+//*                                                                        *
+//* Permission to use, copy, modify and distribute this software and its   *
+//* documentation strictly for non-commercial purposes is hereby granted   *
+//* without fee, provided that the above copyright notice appears in all   *
+//* copies and that both the copyright notice and this permission notice   *
+//* appear in the supporting documentation. The authors make no claims     *
+//* about the suitability of this software for any purpose. It is          *
+//* provided "as is" without express or implied warranty.                  *
+//**************************************************************************
+
+/** @file   AliHLTMonitoringRelay.cxx
+    @author Matthias Richter
+    @date   2009-11-11
+    @brief  Relay components for monitoring objects.
+*/
+
+#include <cstdlib>
+#include <cassert>
+#include "AliHLTMonitoringRelay.h"
+#include "AliHLTMessage.h"
+#include "TArrayC.h"
+#include "TObject.h"
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTMonitoringRelay)
+
+AliHLTMonitoringRelay::AliHLTMonitoringRelay()
+  : AliHLTProcessor()
+  , fItems()
+  , fOutputSize()
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+AliHLTMonitoringRelay::~AliHLTMonitoringRelay()
+{
+  // see header file for class documentation
+}
+
+void AliHLTMonitoringRelay::GetInputDataTypes(AliHLTComponentDataTypeList& list)
+{
+  // see header file for class documentation
+  list.clear();
+  list.push_back(kAliHLTAnyDataType);
+}
+
+AliHLTComponentDataType AliHLTMonitoringRelay::GetOutputDataType()
+{
+  // see header file for class documentation
+  return kAliHLTAnyDataType;
+}
+
+void AliHLTMonitoringRelay::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
+{
+  // see header file for class documentation
+  constBase=fOutputSize;
+  inputMultiplier=1.0;
+}
+
+int AliHLTMonitoringRelay::DoInit( int argc, const char** argv )
+{
+  // see header file for class documentation
+  int iResult=0;
+  fOutputSize=0;
+
+  iResult=ConfigureFromArgumentString(argc, argv);
+
+  return iResult;
+}
+
+int AliHLTMonitoringRelay::ScanConfigurationArgument(int argc, const char** argv)
+{
+  // see header file for class documentation
+  if (argc<=0) return 0;
+  int i=0;
+  TString argument=argv[i];
+
+  // -verbose
+  if (argument.CompareTo("-verbose")==0) {
+    // 
+    return 1;
+  }    
+
+  return 0;
+}
+
+int AliHLTMonitoringRelay::DoDeinit()
+{
+  // see header file for class documentation
+  int iResult=0;
+  AliHLTMonitoringItemPList::iterator element=fItems.begin();
+  while (element!=fItems.end()) {
+    AliHLTMonitoringItem* pItem=*element;
+    element=fItems.erase(element);
+    if (pItem) {
+      delete pItem;
+    }
+  }
+  return iResult;
+}
+
+int AliHLTMonitoringRelay::DoEvent(const AliHLTComponentEventData& /*evtData*/,
+                                  AliHLTComponentTriggerData& /*trigData*/)
+{
+  // see header file for class documentation
+  int iResult=0;
+  for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock();
+       pBlock!=NULL; 
+       pBlock=GetNextInputBlock()) {
+    TObject* pObject=AliHLTMessage::Extract(pBlock->fPtr, pBlock->fSize);
+    if (!pObject) continue; // consider only TObjects
+    
+    AliHLTMonitoringItem* pItem=FindItem(pBlock, pObject);
+    if (pItem) {
+      HLTInfo("found block %s 0x%0lx %s %s", DataType2Text(pItem->GetDataType()).c_str(), pItem->GetSpecification(), pObject->GetName(), pObject->GetName());
+      if (pItem->GetSize()<pBlock->fSize) {
+       // update with the new maximum
+       assert(fOutputSize>=pItem->GetSize());
+       fOutputSize-=pItem->GetSize();
+       fOutputSize+=pBlock->fSize;
+      }
+      pItem->SetData(pBlock->fPtr, pBlock->fSize);
+      HLTInfo("setting item size %d, total size %d", pItem->GetSize(), fOutputSize);
+    } else {
+      pItem=new AliHLTMonitoringItem(pBlock, pObject);
+      fItems.push_back(pItem);
+      fOutputSize+=pBlock->fSize;
+      HLTInfo("new item size %d (%d),  %s 0x%0lx %s %s", pItem->GetSize(), fOutputSize, DataType2Text(pItem->GetDataType()).c_str(), pItem->GetSpecification(), pObject->GetName(), pObject->GetName());
+    }
+    delete pObject;
+  }
+
+  for (AliHLTMonitoringItemPList::iterator element=fItems.begin();
+       element!=fItems.end(); element++) {
+    AliHLTMonitoringItem* pItem=*element;
+    if (pItem) {
+      HLTInfo("push back item size %d (%d),  %s 0x%0lx", pItem->GetSize(), fOutputSize, DataType2Text(pItem->GetDataType()).c_str(), pItem->GetSpecification());
+      PushBack(pItem->GetBuffer(), pItem->GetSize(), pItem->GetDataType(), pItem->GetSpecification());
+    }
+  }
+
+  return iResult;
+}
+
+AliHLTMonitoringRelay::AliHLTMonitoringItem* AliHLTMonitoringRelay::FindItem(const AliHLTComponentBlockData* pBlock, const TObject* pObject) const
+{
+  // find an item by data type, specification, name and title
+  for (unsigned i=0; i<fItems.size(); i++) {
+    AliHLTMonitoringItem* pItem=fItems[i];
+    if (pItem &&
+       (*pItem)==(*pBlock) &&
+       (pObject==NULL || (*pItem)==(*pObject))) {
+      return pItem;
+    }
+  }
+  return NULL;  
+}
+
+AliHLTMonitoringRelay::AliHLTMonitoringItem::AliHLTMonitoringItem()
+  : fDt(kAliHLTVoidDataType)
+  , fSpecification(kAliHLTVoidDataSpec)
+  , fName()
+  , fTitle()
+  , fData(new TArrayC)
+  , fDataSize(0)
+{
+  // standard constructor
+}
+
+AliHLTMonitoringRelay::AliHLTMonitoringItem::AliHLTMonitoringItem(const AliHLTComponentBlockData* pBlock, const TObject* pObject)
+  : fDt(kAliHLTVoidDataType)
+  , fSpecification(kAliHLTVoidDataSpec)
+  , fName()
+  , fTitle()
+  , fData(new TArrayC)
+  , fDataSize(0)
+{
+  // constructor
+  if (pBlock) {
+    fDt=pBlock->fDataType;
+    fSpecification=pBlock->fSpecification;
+    if (fData) {
+      fData->Set(pBlock->fSize, reinterpret_cast<const Char_t*>(pBlock->fPtr));
+      fDataSize=pBlock->fSize;
+    }
+  }
+  if (pObject) {
+    fName=pObject->GetName();
+    fTitle=pObject->GetTitle();
+  }
+}
+
+AliHLTMonitoringRelay::AliHLTMonitoringItem::~AliHLTMonitoringItem()
+{
+  // desstructor
+  if (fData) delete fData;
+}
+
+int AliHLTMonitoringRelay::AliHLTMonitoringItem::SetData(void* pBuffer, int size)
+{
+  // copy the data buffer
+  if (!fData) {
+    fData=new TArrayC(size, reinterpret_cast<const Char_t*>(pBuffer));
+  }
+  if (fData->GetSize()<size) {
+    fData->Set(size, reinterpret_cast<const Char_t*>(pBuffer));
+  } else {
+    memcpy(fData->GetArray(), pBuffer, size);
+  }
+
+  if (fData) {
+    fDataSize=size;
+    return 0;
+  }
+  return -ENOMEM;
+
+}
+
+
+void* AliHLTMonitoringRelay::AliHLTMonitoringItem::GetBuffer() const
+{
+  // get buffer pointer of the current data
+  return fData!=NULL?fData->GetArray():NULL;
+}
+
+unsigned AliHLTMonitoringRelay::AliHLTMonitoringItem::GetSize() const
+{
+  // get size of the current data
+  return fDataSize;
+}
+
+const AliHLTComponentDataType& AliHLTMonitoringRelay::AliHLTMonitoringItem::GetDataType() const
+{
+  // get data type
+  return fDt;
+}
+
+AliHLTUInt32_t AliHLTMonitoringRelay::AliHLTMonitoringItem::GetSpecification() const
+{
+  // get specification
+  return fSpecification;
+}
+
+bool AliHLTMonitoringRelay::AliHLTMonitoringItem::operator==(const AliHLTComponentBlockData& bd) const
+{
+  // equal to data type and specification
+  if (bd.fDataType!=fDt) return false;
+  if (bd.fSpecification!=fSpecification) return false;
+  return true;
+}
+
+bool AliHLTMonitoringRelay::AliHLTMonitoringItem::operator!=(const AliHLTComponentBlockData& bd) const
+{
+  // not equal to data type and specification
+  return not operator==(bd);
+}
+
+bool AliHLTMonitoringRelay::AliHLTMonitoringItem::operator==(const TObject& object) const
+{
+  // equal to name and title
+  if (fName.CompareTo(object.GetName())!=0) return false;
+  if (!fTitle.IsNull() && fTitle.CompareTo(object.GetTitle())!=0) return false;
+  return true;
+}
+
+bool AliHLTMonitoringRelay::AliHLTMonitoringItem::operator!=(const TObject& object) const
+{
+  // not equal to name and title
+  return not operator==(object);
+}
diff --git a/HLT/BASE/util/AliHLTMonitoringRelay.h b/HLT/BASE/util/AliHLTMonitoringRelay.h
new file mode 100644 (file)
index 0000000..ce15d97
--- /dev/null
@@ -0,0 +1,167 @@
+// -*- Mode: C++ -*-
+// $Id$
+
+#ifndef ALIHLTMONITORINGRELAY_H
+#define ALIHLTMONITORINGRELAY_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
+
+/** @file   AliHLTMonitoringRelay.h
+    @author Matthias Richter
+    @date   2009-11-11
+    @brief  Relay components for monitoring objects.
+*/
+
+#include "AliHLTProcessor.h"
+#include "TString.h"
+
+class TArrayC;
+class TObject;
+
+/**
+ * @class AliHLTMonitoringRelay
+ * A relay component for monitoring data objects.
+ * It keeps a copy of the last block of every parent and forwards all
+ * the blocks together. By that, the output of histograms (rarely to
+ * be published but for every event filled.
+ *
+ * Input data blocks must be uniquely identified by the combination of
+ * - data type (id and origin)
+ * - block specification
+ * - object name
+ * - object title
+ *
+ * <h2>General properties:</h2>
+ *
+ * Component ID: \b MonitoringRelay                                         <br>
+ * Library: \b libAliHLTUtil.so                                                <br>
+ * Input Data Types: kAliHLTAnyDataType                                        <br>
+ * Output Data Types: according to input blocks                <br>
+ *
+ * <h2>Mandatory arguments:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ *      
+ * <h2>Optional arguments:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ * \li -verbose                                                         <br>
+ *      print out some more info messages, mainly for the sake of tutorials
+ *
+ * <h2>Configuration:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ * Configuration by component arguments.
+ *
+ * <h2>Default CDB entries:</h2>
+ * The component loads no CDB entries.
+ *
+ * <h2>Performance:</h2>
+ * Low profile: input objects are unpacked and binary copied, no streaming
+ * of obejcts.
+ *
+ * <h2>Memory consnumption:</h2>
+ * The component allocates memory of the maximum size for every input
+ * object.
+ *
+ * <h2>Output size:</h2>
+ * 
+ * @ingroup alihlt_util_components
+ */
+class AliHLTMonitoringRelay : public AliHLTProcessor
+{
+ public:
+  /// standard constructor
+  AliHLTMonitoringRelay();
+  /// destructor
+  virtual ~AliHLTMonitoringRelay();
+
+  /// inherited from AliHLTComponent, get component id
+  virtual const char* GetComponentID() {return "MonitoringRelay";};
+
+  /// inherited from AliHLTComponent, get the input data type
+  void GetInputDataTypes( AliHLTComponentDataTypeList& );
+
+  /// inherited from AliHLTComponent, get the output data type
+  AliHLTComponentDataType GetOutputDataType();
+
+  /// inherited from AliHLTComponent, get the output data size estimator
+  void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+
+  /// inherited from AliHLTComponent, create a component
+  virtual AliHLTComponent* Spawn() {return new AliHLTMonitoringRelay;}
+
+  /// descriptor of monitoring items
+  class AliHLTMonitoringItem {
+  public:
+    // standard constructor
+    AliHLTMonitoringItem();
+    // constructor
+    AliHLTMonitoringItem(const AliHLTComponentBlockData* pBlock, const TObject* pObject);
+    // destructor
+    ~AliHLTMonitoringItem();
+
+    /// copy data from buffer
+    int SetData(void* pBuffer, int size);
+
+    /// get buffer pointer of the current data
+    void* GetBuffer() const;
+    /// get size of the current data
+    unsigned GetSize() const;
+    /// get data type
+    const AliHLTComponentDataType& GetDataType() const;
+    /// get specification
+    AliHLTUInt32_t GetSpecification() const;
+
+    bool operator==(const AliHLTComponentBlockData& bd) const;
+    bool operator!=(const AliHLTComponentBlockData& bd) const;
+    bool operator==(const TObject& object) const;
+    bool operator!=(const TObject& object) const;
+
+  protected:
+  private:
+    /// copy constructor prohibited
+    AliHLTMonitoringItem(const AliHLTMonitoringItem&);
+    /// assignment operator prohibited
+    AliHLTMonitoringItem& operator=(const AliHLTMonitoringItem&);
+    
+    AliHLTComponentDataType fDt;                //! transient
+    AliHLTUInt32_t          fSpecification;     //! transient
+    TString                 fName;              //! transient
+    TString                 fTitle;             //! transient
+    TArrayC*                fData;              //! transient
+    int                     fDataSize;          //! transient
+  };
+  typedef vector<AliHLTMonitoringItem*>  AliHLTMonitoringItemPList;
+ protected:
+
+  /// inherited from AliHLTProcessor, data processing
+  int DoEvent( const AliHLTComponentEventData& evtData,
+              AliHLTComponentTriggerData& trigData );
+  
+  using AliHLTProcessor::DoEvent;
+
+  /// inherited from AliHLTComponent, component initialisation
+  int DoInit( int argc, const char** argv );
+
+  /// inherited from AliHLTComponent, scan argument
+  int ScanConfigurationArgument(int argc, const char** argv);
+
+  /// inherited from AliHLTComponent, component cleanup.
+  int DoDeinit();
+
+ private:
+  /// copy constructor prohibited
+  AliHLTMonitoringRelay(const AliHLTMonitoringRelay&);
+  /// assignment operator prohibited
+  AliHLTMonitoringRelay& operator=(const AliHLTMonitoringRelay&);
+
+  /// find a block of data type and specificaton
+  AliHLTMonitoringItem* FindItem(const AliHLTComponentBlockData* pBlock, const TObject* pObject) const;
+
+  /// the list of items
+  AliHLTMonitoringItemPList  fItems; //! transient
+  /// actual size of the data sample
+  unsigned fOutputSize; //! transient
+
+  ClassDef(AliHLTMonitoringRelay, 0)
+};
+#endif
index 72d99ce..f455e30 100644 (file)
@@ -17,6 +17,7 @@ CLASS_HDRS:=          AliHLTFilePublisher.h \
                AliHLTReadoutListDumpComponent.h \
                AliHLTDataGenerator.h \
                AliHLTBlockFilterComponent.h \
+               AliHLTMonitoringRelay.h \
                AliHLTCompStatCollector.h \
                AliHLTGlobalBarrelTrack.h \
                AliHLTAgentUtil.h \