finalizing DataGenerator component producing fake data for benchmark purpose
[u/mrichter/AliRoot.git] / HLT / BASE / util / AliHLTDataGenerator.h
index 52a7da068ccfed5ef8edf63139279850c8379f18..e99b32a9cde4cd54f8179d5fc4cc519cc3d6f44b 100644 (file)
@@ -1,11 +1,11 @@
 // -*- Mode: C++ -*-
-// @(#) $Id$
+// $Id$
 
 #ifndef ALIHLTDATAGENERATOR_H
 #define ALIHLTDATAGENERATOR_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                               */
+//* 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   AliHLTDataGenerator.h
     @author Matthias Richter
     @note   The class is used in Offline (AliRoot) context
 */
 
-#include "AliHLTDataSource.h"
+#include "AliHLTProcessor.h"
+
+class TRandom;
 
 /**
  * @class AliHLTDataGenerator
  * An HLT data source component to produce random data.
  *
+ * The component produces fake data blocks according to the size range
+ * or the total input size. For the former, the initial size can be set
+ * by the \em -size, \em -minsize arguments, and the range respectivly.
+ * Tn this mode, the size can be decremented (\em -decrement) after n
+ * events (\em -modulo).
+ *
+ * When producing fake blocks with respect to the total input data,
+ * \em -offset and \em -multiplier can be used to set ratio and offset.
+ *
  * Component ID: \b DataGenerator <br>
  * Library: \b libAliHLTUtil.
  *
  * Mandatory arguments: <br>
  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ *
+ * Optional arguments:<br>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
  * \li -datatype     <i> datatype   dataorigin </i> <br>
  *      data type ID and origin, e.g. <tt>-datatype 'CLUSTERS' 'TPC ' </tt>
  * \li -dataspec     <i> specification </i> <br>
  *      data specification treated as decimal number or hex number if
  *      prepended by '0x'
+ * \li -size      <i> size </i> <br>
+ *      initial size of the data to be produced
+ * \li -range      <i> n </i> <br>
+ *      range of the data to be produced [size,size+range]
  * \li -minsize      <i> size </i> <br>
  *      the minimum size of the data to be produced
  * \li -maxsize      <i> size </i> <br>
  *      the maximum size of the data to be produced, default = minsize
  *
- * Optional arguments:<br>
- * \li -divisor <i> m </i> <br>
- *      a divisor to shrink the size after \em modulo events
- * \li -offset <i> m </i> <br>
- *      an offset to subtract from the size after \em modulo events
+ * \li -decrement <i> m </i> <br>
+ *      subtract after \em modulo events
  * \li -modulo <i> n </i> <br>
- *      size manipulated by the disisor or subtractor after \em n events
+ *      size manipulated after \em n events
+ *
+ * \li -offset <i> m </i> <br>
+ *      output size = offset + factor * (total size of input blocks)
+ * \li -multiplier <i> factor </i> <br>
+ *      output size = offset + factor * (total size of input blocks)
  *
  * The component produces data blocks of random content and random size in the
  * range of [\em minsize , \em maxsize ]. The size arguments can contain 'k' or
  * 'M' to indicate kByte or MByte.
- * @ingroup alihlt_component
+ *
+ * @ingroup alihlt_util_components
  */
-class AliHLTDataGenerator : public AliHLTDataSource  {
+class AliHLTDataGenerator : public AliHLTProcessor  {
  public:
   /** standard constructor */
   AliHLTDataGenerator();
@@ -56,39 +77,23 @@ class AliHLTDataGenerator : public AliHLTDataSource  {
   virtual ~AliHLTDataGenerator();
 
   const char* GetComponentID();
+  void GetInputDataTypes( AliHLTComponentDataTypeList& list);
   AliHLTComponentDataType GetOutputDataType();
   int GetOutputDataTypes(vector<AliHLTComponentDataType>& tgtList);
   void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
   AliHLTComponent* Spawn();
 
  protected:
-  /**
-   * Init method.
-   */
   int DoInit( int argc, const char** argv );
-
-  /**
-   * Deinit method.
-   */
   int DoDeinit();
+  int DoEvent( const AliHLTComponentEventData& evtData,
+              const AliHLTComponentBlockData* blocks, 
+              AliHLTComponentTriggerData& trigData,
+              AliHLTUInt8_t* outputPtr, 
+              AliHLTUInt32_t& size,
+              AliHLTComponentBlockDataList& outputBlocks );
 
-  /**
-   * Data processing method for the component.
-   * @param evtData       event data structure
-   * @param trigData     trigger data structure
-   * @param outputPtr    pointer to target buffer
-   * @param size         <i>input</i>: size of target buffer
-   *                     <i>output</i>:size of produced data
-   * @param outputBlocks  list to receive output block descriptors
-   * @return
-   */
-  int GetEvent( const AliHLTComponentEventData& evtData,
-                       AliHLTComponentTriggerData& trigData,
-                       AliHLTUInt8_t* outputPtr, 
-                       AliHLTUInt32_t& size,
-                       vector<AliHLTComponentBlockData>& outputBlocks );
-
-  using AliHLTDataSource::GetEvent;
+  using AliHLTProcessor::DoEvent;
 
   /**
    * Scan one argument and adjacent parameters.
@@ -113,6 +118,13 @@ class AliHLTDataGenerator : public AliHLTDataSource  {
    */
   int ScanSizeArgument(AliHLTUInt32_t &size, const char* arg);
 
+  /**
+   * Scan a float argument.
+   * @param value     target to store the size
+   * @param arg       the argument to scan
+   */
+  int ScanFloatArgument(float &value, const char* arg);
+
  private:
   /** prohibit copy constructor */
   AliHLTDataGenerator(const AliHLTDataGenerator&);
@@ -125,24 +137,31 @@ class AliHLTDataGenerator : public AliHLTDataSource  {
   /** specification */
   AliHLTUInt32_t fSpecification;                                    //! transient
 
+  // mode 1: just fake data independent of the input data
+
   /** the original size size */
   AliHLTUInt32_t fSize;                                             //! transient
-
+  /** range: [size, size+range] */
+  AliHLTUInt32_t fRange;                                                     //! transient
   /** the manipulated size */
   AliHLTUInt32_t fCurrSize;                                         //! transient
-
-  /** range */
-  AliHLTUInt32_t fRange;                                            //! transient
-
-  /** divisor */
+  /** divisor: each modulo event ignoring the input data size) */
   AliHLTUInt32_t fDivisor;                                          //! transient
-
-  /** subtractor */
-  AliHLTUInt32_t fSubtractor;                                       //! transient
-
+  /** decrement: each modulo event ignoring the input data size */
+  AliHLTUInt32_t fDecrement;                                        //! transient
   /** modulo for size manipulation */
   AliHLTUInt32_t fModulo;                                           //! transient
 
+  // mode 2: generate data depending on input data size
+
+  /** offset (generation of data from input data size) */
+  AliHLTUInt32_t fOffset;                                           //! transient
+  /** multiplier (generation of data from input data size) */
+  float fMultiplier;                                                //! transient
+
+  /** random number generator */
+  TRandom* fpDice;                                                  //! transient
+
   ClassDef(AliHLTDataGenerator, 0)
 };
 #endif