[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTTask.cxx

// $Id$
// splitted from AliHLTConfiguration.cxx,v 1.25 2007/10/12 13:24:47
/**************************************************************************
 * 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   AliHLTTask.cxx
    @author Matthias Richter
    @date   
    @brief  Implementation of HLT tasks.
*/

// see header file for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

#if __GNUC__>= 3
using namespace std;
#endif

#include <cerrno>
#include <iostream>
#include <string>
#include "AliHLTTask.h"
#include "AliHLTConfiguration.h"
#include "AliHLTComponent.h"
#include "AliHLTComponentHandler.h"
#include "TList.h"

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTask)

AliHLTTask::AliHLTTask()
  :
  fpConfiguration(NULL),
  fpComponent(NULL),
  fpDataBuffer(NULL),
  fListTargets(),
  fListDependencies(),
  fBlockDataArray()
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTTask::AliHLTTask(AliHLTConfiguration* pConf)
  :
  fpConfiguration(pConf),
  fpComponent(NULL),
  fpDataBuffer(NULL),
  fListTargets(),
  fListDependencies(),
  fBlockDataArray()
{
  // see header file for function documentation
}

AliHLTTask::~AliHLTTask()
{
  // see header file for function documentation
  TObjLink* lnk=fListDependencies.FirstLink();

  while (lnk!=NULL) {
    AliHLTTask* pTask=(AliHLTTask*)lnk->GetObject();
    pTask->UnsetTarget(this);
    lnk=lnk->Next();
  }
  lnk=fListTargets.FirstLink();

  while (lnk!=NULL) {
    AliHLTTask* pTask=(AliHLTTask*)lnk->GetObject();
    pTask->UnsetDependency(this);
    lnk=lnk->Next();
  }

  if (fpComponent) delete fpComponent;
  fpComponent=NULL;
}

int AliHLTTask::Init(AliHLTConfiguration* pConf, AliHLTComponentHandler* pCH)
{
  // see header file for function documentation
  int iResult=0;
  if (fpConfiguration!=NULL && pConf!=NULL && fpConfiguration!=pConf) {
    HLTWarning("overriding existing reference to configuration object %p (%s) by %p",
	       fpConfiguration, GetName(), pConf);
  }
  if (pConf!=NULL) fpConfiguration=pConf;
  if (fpConfiguration) {
    if (pCH) {
      int argc=0;
      const char** argv=NULL;
      if ((iResult=fpConfiguration->GetArguments(&argv))>=0) {
	argc=iResult; // just to make it clear
	// TODO: we have to think about the optional environment parameter,
	// currently just set to NULL. 
	iResult=pCH->CreateComponent(fpConfiguration->GetComponentID(), NULL, argc, argv, fpComponent);
	if (fpComponent || iResult<=0) {
	  //HLTDebug("component %s (%p) created", fpComponent->GetComponentID(), fpComponent); 
	} else {
	  HLTError("can not find component \"%s\" (%d)", fpConfiguration->GetComponentID(), iResult);
	}
      } else {
	HLTError("can not get argument list for configuration %s (%s)", fpConfiguration->GetName(), fpConfiguration->GetComponentID());
	iResult=-EINVAL;
      }
    } else {
      HLTError("component handler instance needed for task initialization");
      iResult=-EINVAL;
    }
  } else {
    HLTError("configuration object instance needed for task initialization");
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTTask::Deinit()
{
  // see header file for function documentation
  int iResult=0;
  AliHLTComponent* pComponent=GetComponent();
  fpComponent=NULL;
  if (pComponent) {
    //HLTDebug("delete component %s (%p)", pComponent->GetComponentID(), pComponent); 
    pComponent->Deinit();
    delete pComponent;
  } else {
    HLTWarning("task %s (%p) doesn't seem to be in initialized", GetName(), this);
  }
  return iResult;
}

const char *AliHLTTask::GetName() const
{
  // see header file for function documentation
  if (fpConfiguration)
    return fpConfiguration->GetName();
  return TObject::GetName();
}

AliHLTConfiguration* AliHLTTask::GetConf() const
{
  // see header file for function documentation
  return fpConfiguration;
}

AliHLTComponent* AliHLTTask::GetComponent() const
{
  // see header file for function documentation
  return fpComponent;
}

AliHLTTask* AliHLTTask::FindDependency(const char* id)
{
  // see header file for function documentation
  AliHLTTask* pTask=NULL;
  if (id) {
    pTask=(AliHLTTask*)fListDependencies.FindObject(id);
  }
  return pTask;
}

int AliHLTTask::FollowDependency(const char* id, TList* pTgtList)
{
  // see header file for function documentation
  int iResult=0;
  if (id) {
    AliHLTTask* pDep=NULL;
    if ((pDep=(AliHLTTask*)fListDependencies.FindObject(id))!=NULL) {
      if (pTgtList) pTgtList->Add(pDep);
      iResult++;
    } else {
      TObjLink* lnk=fListDependencies.FirstLink();
      while (lnk && iResult==0) {
	pDep=(AliHLTTask*)lnk->GetObject();
	if (pDep) {
	  if ((iResult=pDep->FollowDependency(id, pTgtList))>0) {
	    if (pTgtList) pTgtList->AddFirst(pDep);
	    iResult++;
	  }
	} else {
	  iResult=-EFAULT;
	}
	lnk=lnk->Next();
      }
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

void AliHLTTask::PrintDependencyTree(const char* id, int bFromConfiguration)
{
  // see header file for function documentation
  HLTLogKeyword("task dependencies");
  int iResult=0;
  TList tgtList;
  if (bFromConfiguration) {
    if (fpConfiguration)
      iResult=fpConfiguration->FollowDependency(id, &tgtList);
    else
      iResult=-EFAULT;
  } else
    iResult=FollowDependency(id, &tgtList);
  if (iResult>0) {
    HLTMessage("     task \"%s\": dependency level %d ", GetName(), iResult);
    TObjLink* lnk=tgtList.FirstLink();
    int i=iResult;
    char* pSpace = new char[iResult+1];
    if (pSpace) {
      memset(pSpace, 32, iResult);
      pSpace[i]=0;
      while (lnk) {
	TObject* obj=lnk->GetObject();
	HLTMessage("     %s^-- %s ", &pSpace[i--], obj->GetName());
	lnk=lnk->Next();
      }
      delete [] pSpace;
    } else {
      iResult=-ENOMEM;
    }
  }
}

int AliHLTTask::SetDependency(AliHLTTask* pDep)
{
  // see header file for function documentation
  int iResult=0;
  if (pDep) {
    if (FindDependency(pDep->GetName())==NULL) {
      fListDependencies.Add(pDep);
    } else {
      iResult=-EEXIST;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTTask::UnsetDependency(AliHLTTask* pDep)
{
  // see header file for function documentation
  fListDependencies.Remove(pDep);
  if (fpConfiguration) {
    fpConfiguration->InvalidateSources();
  }
  return 0;
}

int AliHLTTask::CheckDependencies()
{
  // see header file for function documentation
  int iResult=0;
  AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource();
  while (pSrc) {
    if (FindDependency(pSrc->GetName())==NULL) {
      //HLTDebug("dependency \"%s\" unresolved", pSrc->GetName());
      iResult++;
    }
    pSrc=fpConfiguration->GetNextSource();
  }
  return iResult;
}


int AliHLTTask::Depends(AliHLTTask* pTask)
{
  // see header file for function documentation
  int iResult=0;
  if (pTask) {
    if (fpConfiguration) {
      iResult=fpConfiguration->GetSource(pTask->GetName())!=NULL;
      if (iResult>0) {
	//HLTDebug("task  \"%s\" depends on \"%s\"", GetName(), pTask->GetName());
      } else {
	//HLTDebug("task  \"%s\" independend of \"%s\"", GetName(), pTask->GetName());
      }
    } else {
      iResult=-EFAULT;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

AliHLTTask* AliHLTTask::FindTarget(const char* id)
{
  // see header file for function documentation
  AliHLTTask* pTask=NULL;
  if (id) {
    pTask=(AliHLTTask*)fListTargets.FindObject(id);
  }
  return pTask;
}

int AliHLTTask::SetTarget(AliHLTTask* pTgt)
{
  // see header file for function documentation
  int iResult=0;
  if (pTgt) {
    if (FindTarget(pTgt->GetName())==NULL) {
      fListTargets.Add(pTgt);
    } else {
      iResult=-EEXIST;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTTask::UnsetTarget(AliHLTTask* pTarget)
{
  // see header file for function documentation
  fListTargets.Remove(pTarget);
  return 0;
}

int AliHLTTask::StartRun()
{
  // see header file for function documentation
  int iResult=0;
  int iNofInputDataBlocks=0;
  AliHLTComponent* pComponent=GetComponent();
  if (pComponent) {
    // determine the number of input data blocks provided from the source tasks
    TObjLink* lnk=fListDependencies.FirstLink();
    while (lnk && iResult>=0) {
      AliHLTTask* pSrcTask=(AliHLTTask*)lnk->GetObject();
      if (pSrcTask) {
	if ((iResult=pSrcTask->GetNofMatchingDataTypes(this))>0) {
	  iNofInputDataBlocks+=iResult;
	} else if (iResult==0) {
	  HLTWarning("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this);
	} else {
	  HLTError("task %s (%p): error getting matching data types for source task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask);
	  iResult=-EFAULT;
	}
      }
      lnk=lnk->Next();
    }
    if (iResult>=0) {
      if (fBlockDataArray.size()>0) {
	HLTWarning("block data array for task %s (%p) was not cleaned", GetName(), this);
	fBlockDataArray.resize(0);
      }

      // component init
      // the initialization of the component is done by the ComponentHandler after creation
      // of the component.
      //iResult=Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv );

      // allocate internal task variables for bookkeeping aso.
      // we allocate the BlockData array with at least one member
      if (iNofInputDataBlocks==0) iNofInputDataBlocks=1;
      AliHLTComponentBlockData init;
      memset(&init, 0, sizeof(AliHLTComponentBlockData));
      fBlockDataArray.resize(iNofInputDataBlocks, init);

      // allocate the data buffer, which controls the output buffer and subscriptions
      if (iResult>=0) {
	fpDataBuffer=new AliHLTDataBuffer;
	if (fpDataBuffer!=NULL) {
	  HLTDebug("created data buffer %p for task %s (%p)", fpDataBuffer, GetName(), this);
	  TObjLink* lnk=fListTargets.FirstLink();
	  while (lnk && iResult>=0) {
	    AliHLTTask* pTgtTask=(AliHLTTask*)lnk->GetObject();
	    if (pTgtTask) {
	      if ((iResult=fpDataBuffer->SetConsumer(pTgtTask->GetComponent()))>=0) {
	      }
	    } else {
	      break;
	      iResult=-EFAULT;
	    }
	    lnk=lnk->Next();
	  }
	} else {
	  HLTFatal("can not create data buffer object, memory allocation failed");
	  iResult=-ENOMEM;
	}
      }
    }
  } else {
    HLTError("task %s (%p) does not have a component", GetName(), this);
    iResult=-EFAULT;
  }
  return iResult;
}

int AliHLTTask::EndRun()
{
  // see header file for function documentation
  int iResult=0;
  if (fBlockDataArray.size()>0) {
    fBlockDataArray.resize(0);
  } else {
    HLTWarning("task %s (%p) doesn't seem to be in running mode", GetName(), this);
  }
  if (fpDataBuffer) {
    AliHLTDataBuffer* pBuffer=fpDataBuffer;
    fpDataBuffer=NULL;
    delete pBuffer;
  }
  return iResult;
}

int AliHLTTask::ProcessTask(Int_t eventNo)
{
  // see header file for function documentation
  int iResult=0;
  AliHLTComponent* pComponent=GetComponent();
  if (pComponent && fpDataBuffer) {
    HLTDebug("Processing task %s (%p) fpDataBuffer %p", GetName(), this, fpDataBuffer);
    fpDataBuffer->Reset();
    int iSourceDataBlock=0;
    int iInputDataVolume=0;

    AliHLTTask* pSrcTask=NULL;
    TList subscribedTaskList;
    TObjLink* lnk=fListDependencies.FirstLink();

    // subscribe to all source tasks
    while (lnk && iResult>=0) {
      pSrcTask=(AliHLTTask*)lnk->GetObject();
      if (pSrcTask) {
	int iMatchingDB=pSrcTask->GetNofMatchingDataBlocks(this);
	if (iMatchingDB>=0 && static_cast<unsigned int>(iMatchingDB)>fBlockDataArray.size()-iSourceDataBlock) {
	  AliHLTComponentBlockData init;
	  memset(&init, 0, sizeof(AliHLTComponentBlockData));
	  fBlockDataArray.resize(iSourceDataBlock+iMatchingDB, init);
	} else {
	  if (iMatchingDB<0) {
	    HLTError("task %s (%p): error getting no of matching data blocks from task %s (%p), error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iMatchingDB);
	    iResult=iMatchingDB;
	    break;
	  } else if (iMatchingDB==0) {
	    HLTDebug("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this);
	  }
	}
	if ((iResult=pSrcTask->Subscribe(this, &fBlockDataArray[iSourceDataBlock],fBlockDataArray.size()-iSourceDataBlock))>=0) {
	  for (int i=0; i<iResult; i++) {
	    iInputDataVolume+=fBlockDataArray[i+iSourceDataBlock].fSize;
	    // put the source task as many times into the list as it provides data blocks
	    // makes the bookkeeping for the data release easier
	    subscribedTaskList.Add(pSrcTask);
	  }
	  HLTDebug("Task %s (%p) successfully subscribed to %d data block(s) of task %s (%p)", GetName(), this, iResult, pSrcTask->GetName(), pSrcTask);
	  iSourceDataBlock+=iResult;	  
	  iResult=0;
	} else {
	  HLTError("Task %s (%p): subscription to task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iResult);
	  iResult=-EFAULT;
	}
      } else {
	HLTFatal("fatal internal error in ROOT list handling");
	iResult=-EFAULT;
      }
      lnk=lnk->Next();
    }

    // process the event
    int iNofTrial=0; // repeat processing if component returns -ENOSPC
    AliHLTUInt32_t size=0;
    if (iResult>=0) {
    do {
      long unsigned int iConstBase=0;
      double fInputMultiplier=0;
      if (pComponent->GetComponentType()!=AliHLTComponent::kSink)
	pComponent->GetOutputDataSize(iConstBase, fInputMultiplier);
      if (fInputMultiplier<0) {
	HLTWarning("ignoring negative input multiplier");
	fInputMultiplier=0;
      }
      long unsigned int iOutputDataSize=int(fInputMultiplier*iInputDataVolume) + iConstBase;
      //HLTDebug("task %s: reqired output size %d", GetName(), iOutputDataSize);
      if (iNofTrial>0) {
	// dont process again if the buffer size is the same
	if (size==iOutputDataSize) break;
	HLTInfo("processing task %s again with buffer size %d", GetName(), iOutputDataSize);
      }
      AliHLTUInt8_t* pTgtBuffer=NULL;
      if (iOutputDataSize>0) pTgtBuffer=fpDataBuffer->GetTargetBuffer(iOutputDataSize);
      //HLTDebug("provided raw buffer %p", pTgtBuffer);
      AliHLTComponentEventData evtData;
      AliHLTComponent::FillEventData(evtData);
      evtData.fEventID=(AliHLTEventID_t)eventNo;
      evtData.fBlockCnt=iSourceDataBlock;
      AliHLTComponentTriggerData trigData;
      size=iOutputDataSize;
      AliHLTUInt32_t outputBlockCnt=0;
      AliHLTComponentBlockData* outputBlocks=NULL;
      AliHLTComponentEventDoneData* edd;
      if (pTgtBuffer!=NULL || iOutputDataSize==0) {
	iResult=pComponent->ProcessEvent(evtData, &fBlockDataArray[0], trigData, pTgtBuffer, size, outputBlockCnt, outputBlocks, edd);
	HLTDebug("task %s: component %s ProcessEvent finnished (%d): size=%d blocks=%d", GetName(), pComponent->GetComponentID(), iResult, size, outputBlockCnt);
	if (iResult>=0 && pTgtBuffer && outputBlocks) {
	  iResult=fpDataBuffer->SetSegments(pTgtBuffer, outputBlocks, outputBlockCnt);
	  delete [] outputBlocks; outputBlocks=NULL; outputBlockCnt=0;
	} else {
	  fpDataBuffer->Reset();
	}
      } else {
	HLTError("task %s: no target buffer available", GetName());
	iResult=-EFAULT;
      }
    } while (iResult==-ENOSPC && iNofTrial++<1);
    }

    // now release all buffers which we have subscribed to
    iSourceDataBlock=0;
    lnk=subscribedTaskList.FirstLink();
    while (lnk) {
      pSrcTask=(AliHLTTask*)lnk->GetObject();
      if (pSrcTask) {
	int iTempRes=0;
	if ((iTempRes=pSrcTask->Release(&fBlockDataArray[iSourceDataBlock], this))>=0) {
	  HLTDebug("Task %s (%p) successfully released segment of task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask);
	} else {
	  HLTError("Task %s (%p): realease of task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iTempRes);
	}
      } else {
	HLTFatal("task %s (%p): internal error in ROOT list handling", GetName(), this);
	if (iResult>=0) iResult=-EFAULT;
      }
      subscribedTaskList.Remove(lnk);
      lnk=subscribedTaskList.FirstLink();
      iSourceDataBlock++;
    }
    if (subscribedTaskList.GetSize()>0) {
      HLTError("task %s (%p): could not release all data buffers", GetName(), this);
    }
  } else {
    HLTError("task %s (%p): internal failure (not initialized component %p, data buffer %p)", GetName(), this, fpComponent, fpDataBuffer);
    iResult=-EFAULT;
  }
  return iResult;
}

int AliHLTTask::GetNofMatchingDataBlocks(const AliHLTTask* pConsumerTask) const
{
  // see header file for function documentation
  int iResult=0;
  if (pConsumerTask) {
    if (fpDataBuffer) {
      iResult=fpDataBuffer->FindMatchingDataBlocks(pConsumerTask->GetComponent(), NULL);
    } else {
      HLTFatal("internal data buffer missing");
      iResult=-EFAULT;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTTask::GetNofMatchingDataTypes(const AliHLTTask* pConsumerTask) const
{
  // see header file for function documentation
  int iResult=0;
  if (pConsumerTask) {
    AliHLTComponent* pComponent=GetComponent();
    if (!pComponent) {
      // init ?
      HLTError("component not initialized");
      iResult=-EFAULT;
    }
    if (pComponent) {
      iResult=pComponent->FindMatchingDataTypes(pConsumerTask->GetComponent(), NULL);
    } else {
      HLTFatal("task initialization failed");
      iResult=-EFAULT;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponentBlockData* pBlockDesc, int iArraySize)
{
  // see header file for function documentation
  int iResult=0;
  if (pConsumerTask) {
    if (fpDataBuffer) {
      iResult=fpDataBuffer->Subscribe(pConsumerTask->GetComponent(), pBlockDesc, iArraySize);
    } else {
      HLTFatal("internal data buffer missing");
      iResult=-EFAULT;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTTask::Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTTask* pConsumerTask)
{
  // see header file for function documentation
  int iResult=0;
  if (pConsumerTask && pBlockDesc) {
    if (fpDataBuffer) {
      iResult=fpDataBuffer->Release(pBlockDesc, pConsumerTask->GetComponent());
    } else {
      HLTFatal("internal data buffer missing");
      iResult=-EFAULT;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

void AliHLTTask::PrintStatus()
{
  // see header file for function documentation
  HLTLogKeyword("task properties");
  AliHLTComponent* pComponent=GetComponent();
  if (pComponent) {
    HLTMessage("     component: %s (%p)", pComponent->GetComponentID(), pComponent);
  } else {
    HLTMessage("     no component set!");
  }
  if (fpConfiguration) {
    AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource();
    while (pSrc) {
      const char* pQualifier="unresolved";
      if (FindDependency(pSrc->GetName()))
	pQualifier="resolved";
      HLTMessage("     source: %s (%s)", pSrc->GetName(), pQualifier);
      pSrc=fpConfiguration->GetNextSource();
    }
    TObjLink* lnk = fListTargets.FirstLink();
    while (lnk) {
      TObject *obj = lnk->GetObject();
      HLTMessage("     target: %s", obj->GetName());
      lnk = lnk->Next();
    }
  } else {
    HLTMessage("     task \"%s\" not initialized", GetName());
  }
}
Commit	Line	Data
7a436c89	1	// $Id$
	2	// splitted from AliHLTConfiguration.cxx,v 1.25 2007/10/12 13:24:47
	3	/**************************************************************************
	4	* This file is property of and copyright by the ALICE HLT Project *
	5	* ALICE Experiment at CERN, All rights reserved. *
	6	* *
	7	* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
	8	* for The ALICE HLT Project. *
	9	* *
	10	* Permission to use, copy, modify and distribute this software and its *
	11	* documentation strictly for non-commercial purposes is hereby granted *
	12	* without fee, provided that the above copyright notice appears in all *
	13	* copies and that both the copyright notice and this permission notice *
	14	* appear in the supporting documentation. The authors make no claims *
	15	* about the suitability of this software for any purpose. It is *
	16	* provided "as is" without express or implied warranty. *
	17	**************************************************************************/
	18
	19	/** @file AliHLTTask.cxx
	20	@author Matthias Richter
	21	@date
	22	@brief Implementation of HLT tasks.
	23	*/
	24
	25	// see header file for class documentation
	26	// or
	27	// refer to README to build package
	28	// or
	29	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	30
	31	#if __GNUC__>= 3
	32	using namespace std;
	33	#endif
	34
	35	#include <cerrno>
	36	#include <iostream>
	37	#include <string>
	38	#include "AliHLTTask.h"
	39	#include "AliHLTConfiguration.h"
	40	#include "AliHLTComponent.h"
	41	#include "AliHLTComponentHandler.h"
	42	#include "TList.h"
	43
	44	/** ROOT macro for the implementation of ROOT specific class methods */
	45	ClassImp(AliHLTTask)
	46
	47	AliHLTTask::AliHLTTask()
	48	:
	49	fpConfiguration(NULL),
	50	fpComponent(NULL),
	51	fpDataBuffer(NULL),
	52	fListTargets(),
	53	fListDependencies(),
	54	fBlockDataArray()
	55	{
	56	// see header file for class documentation
	57	// or
	58	// refer to README to build package
	59	// or
	60	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	61	}
	62
	63	AliHLTTask::AliHLTTask(AliHLTConfiguration* pConf)
	64	:
65	fpConfiguration(pConf),
66	fpComponent(NULL),
67	fpDataBuffer(NULL),
68	fListTargets(),
69	fListDependencies(),
70	fBlockDataArray()
71	{
72	// see header file for function documentation
73	}
74
75	AliHLTTask::~AliHLTTask()
76	{
77	// see header file for function documentation
78	TObjLink* lnk=fListDependencies.FirstLink();
79
80	while (lnk!=NULL) {
81	AliHLTTask* pTask=(AliHLTTask*)lnk->GetObject();
82	pTask->UnsetTarget(this);
83	lnk=lnk->Next();
84	}
85	lnk=fListTargets.FirstLink();
86
87	while (lnk!=NULL) {
88	AliHLTTask* pTask=(AliHLTTask*)lnk->GetObject();
89	pTask->UnsetDependency(this);
90	lnk=lnk->Next();
91	}
92
93	if (fpComponent) delete fpComponent;
94	fpComponent=NULL;
95	}
96
97	int AliHLTTask::Init(AliHLTConfiguration* pConf, AliHLTComponentHandler* pCH)
98	{
99	// see header file for function documentation
100	int iResult=0;
101	if (fpConfiguration!=NULL && pConf!=NULL && fpConfiguration!=pConf) {
102	HLTWarning("overriding existing reference to configuration object %p (%s) by %p",
103	fpConfiguration, GetName(), pConf);
104	}
105	if (pConf!=NULL) fpConfiguration=pConf;
106	if (fpConfiguration) {
107	if (pCH) {
108	int argc=0;
109	const char** argv=NULL;
110	if ((iResult=fpConfiguration->GetArguments(&argv))>=0) {
111	argc=iResult; // just to make it clear
112	// TODO: we have to think about the optional environment parameter,
113	// currently just set to NULL.
114	iResult=pCH->CreateComponent(fpConfiguration->GetComponentID(), NULL, argc, argv, fpComponent);
115	if (fpComponent \|\| iResult<=0) {
116	//HLTDebug("component %s (%p) created", fpComponent->GetComponentID(), fpComponent);
117	} else {
118	HLTError("can not find component \"%s\" (%d)", fpConfiguration->GetComponentID(), iResult);
119	}
120	} else {
121	HLTError("can not get argument list for configuration %s (%s)", fpConfiguration->GetName(), fpConfiguration->GetComponentID());
122	iResult=-EINVAL;
123	}
124	} else {
125	HLTError("component handler instance needed for task initialization");
126	iResult=-EINVAL;
127	}
128	} else {
129	HLTError("configuration object instance needed for task initialization");
130	iResult=-EINVAL;
131	}
132	return iResult;
133	}
134
135	int AliHLTTask::Deinit()
136	{
137	// see header file for function documentation
138	int iResult=0;
139	AliHLTComponent* pComponent=GetComponent();
140	fpComponent=NULL;
141	if (pComponent) {
142	//HLTDebug("delete component %s (%p)", pComponent->GetComponentID(), pComponent);
143	pComponent->Deinit();
144	delete pComponent;
145	} else {
146	HLTWarning("task %s (%p) doesn't seem to be in initialized", GetName(), this);
147	}
148	return iResult;
149	}
150
151	const char *AliHLTTask::GetName() const
152	{
153	// see header file for function documentation
154	if (fpConfiguration)
155	return fpConfiguration->GetName();
156	return TObject::GetName();
157	}
158
159	AliHLTConfiguration* AliHLTTask::GetConf() const
160	{
161	// see header file for function documentation
162	return fpConfiguration;
163	}
164
165	AliHLTComponent* AliHLTTask::GetComponent() const
166	{
167	// see header file for function documentation
168	return fpComponent;
169	}
170
171	AliHLTTask* AliHLTTask::FindDependency(const char* id)
172	{
173	// see header file for function documentation
174	AliHLTTask* pTask=NULL;
175	if (id) {
176	pTask=(AliHLTTask*)fListDependencies.FindObject(id);
177	}
178	return pTask;
179	}
180
181	int AliHLTTask::FollowDependency(const char* id, TList* pTgtList)
182	{
183	// see header file for function documentation
184	int iResult=0;
185	if (id) {
186	AliHLTTask* pDep=NULL;
187	if ((pDep=(AliHLTTask*)fListDependencies.FindObject(id))!=NULL) {
188	if (pTgtList) pTgtList->Add(pDep);
189	iResult++;
190	} else {
191	TObjLink* lnk=fListDependencies.FirstLink();
192	while (lnk && iResult==0) {
193	pDep=(AliHLTTask*)lnk->GetObject();
194	if (pDep) {
195	if ((iResult=pDep->FollowDependency(id, pTgtList))>0) {
196	if (pTgtList) pTgtList->AddFirst(pDep);
197	iResult++;
198	}
199	} else {
200	iResult=-EFAULT;
201	}
202	lnk=lnk->Next();
203	}
204	}
205	} else {
206	iResult=-EINVAL;
207	}
208	return iResult;
209	}
210
211	void AliHLTTask::PrintDependencyTree(const char* id, int bFromConfiguration)
212	{
213	// see header file for function documentation
214	HLTLogKeyword("task dependencies");
215	int iResult=0;
216	TList tgtList;
217	if (bFromConfiguration) {
218	if (fpConfiguration)
219	iResult=fpConfiguration->FollowDependency(id, &tgtList);
220	else
221	iResult=-EFAULT;
222	} else
223	iResult=FollowDependency(id, &tgtList);
224	if (iResult>0) {
225	HLTMessage(" task \"%s\": dependency level %d ", GetName(), iResult);
226	TObjLink* lnk=tgtList.FirstLink();
227	int i=iResult;
228	char* pSpace = new char[iResult+1];
229	if (pSpace) {
230	memset(pSpace, 32, iResult);
231	pSpace[i]=0;
232	while (lnk) {
233	TObject* obj=lnk->GetObject();
234	HLTMessage(" %s^-- %s ", &pSpace[i--], obj->GetName());
235	lnk=lnk->Next();
236	}
237	delete [] pSpace;
238	} else {
239	iResult=-ENOMEM;
240	}
241	}
242	}
243
244	int AliHLTTask::SetDependency(AliHLTTask* pDep)
245	{
246	// see header file for function documentation
247	int iResult=0;
248	if (pDep) {
249	if (FindDependency(pDep->GetName())==NULL) {
250	fListDependencies.Add(pDep);
251	} else {
252	iResult=-EEXIST;
253	}
254	} else {
255	iResult=-EINVAL;
256	}
257	return iResult;
258	}
259
260	int AliHLTTask::UnsetDependency(AliHLTTask* pDep)
261	{
262	// see header file for function documentation
263	fListDependencies.Remove(pDep);
264	if (fpConfiguration) {
265	fpConfiguration->InvalidateSources();
266	}
267	return 0;
268	}
269
270	int AliHLTTask::CheckDependencies()
271	{
272	// see header file for function documentation
273	int iResult=0;
274	AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource();
275	while (pSrc) {
276	if (FindDependency(pSrc->GetName())==NULL) {
277	//HLTDebug("dependency \"%s\" unresolved", pSrc->GetName());
278	iResult++;
279	}
280	pSrc=fpConfiguration->GetNextSource();
281	}
282	return iResult;
283	}
284
285
286	int AliHLTTask::Depends(AliHLTTask* pTask)
287	{
288	// see header file for function documentation
289	int iResult=0;
290	if (pTask) {
291	if (fpConfiguration) {
292	iResult=fpConfiguration->GetSource(pTask->GetName())!=NULL;
293	if (iResult>0) {
294	//HLTDebug("task \"%s\" depends on \"%s\"", GetName(), pTask->GetName());
295	} else {
296	//HLTDebug("task \"%s\" independend of \"%s\"", GetName(), pTask->GetName());
297	}
298	} else {
299	iResult=-EFAULT;
300	}
301	} else {
302	iResult=-EINVAL;
303	}
304	return iResult;
305	}
306
307	AliHLTTask* AliHLTTask::FindTarget(const char* id)
308	{
309	// see header file for function documentation
310	AliHLTTask* pTask=NULL;
311	if (id) {
312	pTask=(AliHLTTask*)fListTargets.FindObject(id);
313	}
314	return pTask;
315	}
316
317	int AliHLTTask::SetTarget(AliHLTTask* pTgt)
318	{
319	// see header file for function documentation
320	int iResult=0;
321	if (pTgt) {
322	if (FindTarget(pTgt->GetName())==NULL) {
323	fListTargets.Add(pTgt);
324	} else {
325	iResult=-EEXIST;
326	}
327	} else {
328	iResult=-EINVAL;
329	}
330	return iResult;
331	}
332
333	int AliHLTTask::UnsetTarget(AliHLTTask* pTarget)
334	{
335	// see header file for function documentation
336	fListTargets.Remove(pTarget);
337	return 0;
338	}
339
340	int AliHLTTask::StartRun()
341	{
342	// see header file for function documentation
343	int iResult=0;
344	int iNofInputDataBlocks=0;
345	AliHLTComponent* pComponent=GetComponent();
346	if (pComponent) {
347	// determine the number of input data blocks provided from the source tasks
348	TObjLink* lnk=fListDependencies.FirstLink();
349	while (lnk && iResult>=0) {
350	AliHLTTask* pSrcTask=(AliHLTTask*)lnk->GetObject();
351	if (pSrcTask) {
352	if ((iResult=pSrcTask->GetNofMatchingDataTypes(this))>0) {
353	iNofInputDataBlocks+=iResult;
354	} else if (iResult==0) {
355	HLTWarning("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this);
356	} else {
357	HLTError("task %s (%p): error getting matching data types for source task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask);
358	iResult=-EFAULT;
359	}
360	}
361	lnk=lnk->Next();
362	}
363	if (iResult>=0) {
364	if (fBlockDataArray.size()>0) {
365	HLTWarning("block data array for task %s (%p) was not cleaned", GetName(), this);
366	fBlockDataArray.resize(0);
367	}
368
369	// component init
370	// the initialization of the component is done by the ComponentHandler after creation
371	// of the component.
372	//iResult=Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv );
373
374	// allocate internal task variables for bookkeeping aso.
375	// we allocate the BlockData array with at least one member
376	if (iNofInputDataBlocks==0) iNofInputDataBlocks=1;
377	AliHLTComponentBlockData init;
378	memset(&init, 0, sizeof(AliHLTComponentBlockData));
379	fBlockDataArray.resize(iNofInputDataBlocks, init);
380
381	// allocate the data buffer, which controls the output buffer and subscriptions
382	if (iResult>=0) {
383	fpDataBuffer=new AliHLTDataBuffer;
384	if (fpDataBuffer!=NULL) {
385	HLTDebug("created data buffer %p for task %s (%p)", fpDataBuffer, GetName(), this);
386	TObjLink* lnk=fListTargets.FirstLink();
387	while (lnk && iResult>=0) {
388	AliHLTTask* pTgtTask=(AliHLTTask*)lnk->GetObject();
389	if (pTgtTask) {
390	if ((iResult=fpDataBuffer->SetConsumer(pTgtTask->GetComponent()))>=0) {
391	}
392	} else {
393	break;
394	iResult=-EFAULT;
395	}
396	lnk=lnk->Next();
397	}
398	} else {
399	HLTFatal("can not create data buffer object, memory allocation failed");
400	iResult=-ENOMEM;
401	}
402	}
403	}
404	} else {
405	HLTError("task %s (%p) does not have a component", GetName(), this);
406	iResult=-EFAULT;
407	}
408	return iResult;
409	}
410
411	int AliHLTTask::EndRun()
412	{
413	// see header file for function documentation
414	int iResult=0;
415	if (fBlockDataArray.size()>0) {
416	fBlockDataArray.resize(0);
417	} else {
418	HLTWarning("task %s (%p) doesn't seem to be in running mode", GetName(), this);
419	}
420	if (fpDataBuffer) {
421	AliHLTDataBuffer* pBuffer=fpDataBuffer;
422	fpDataBuffer=NULL;
423	delete pBuffer;
424	}
425	return iResult;
426	}
427
428	int AliHLTTask::ProcessTask(Int_t eventNo)
429	{
430	// see header file for function documentation
431	int iResult=0;
432	AliHLTComponent* pComponent=GetComponent();
433	if (pComponent && fpDataBuffer) {
434	HLTDebug("Processing task %s (%p) fpDataBuffer %p", GetName(), this, fpDataBuffer);
435	fpDataBuffer->Reset();
436	int iSourceDataBlock=0;
437	int iInputDataVolume=0;
438
439	AliHLTTask* pSrcTask=NULL;
440	TList subscribedTaskList;
441	TObjLink* lnk=fListDependencies.FirstLink();
442
443	// subscribe to all source tasks
444	while (lnk && iResult>=0) {
445	pSrcTask=(AliHLTTask*)lnk->GetObject();
446	if (pSrcTask) {
447	int iMatchingDB=pSrcTask->GetNofMatchingDataBlocks(this);
448	if (iMatchingDB>=0 && static_cast<unsigned int>(iMatchingDB)>fBlockDataArray.size()-iSourceDataBlock) {
449	AliHLTComponentBlockData init;
450	memset(&init, 0, sizeof(AliHLTComponentBlockData));
451	fBlockDataArray.resize(iSourceDataBlock+iMatchingDB, init);
452	} else {
453	if (iMatchingDB<0) {
454	HLTError("task %s (%p): error getting no of matching data blocks from task %s (%p), error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iMatchingDB);
455	iResult=iMatchingDB;
456	break;
457	} else if (iMatchingDB==0) {
458	HLTDebug("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this);
459	}
460	}
461	if ((iResult=pSrcTask->Subscribe(this, &fBlockDataArray[iSourceDataBlock],fBlockDataArray.size()-iSourceDataBlock))>=0) {
462	for (int i=0; i<iResult; i++) {
463	iInputDataVolume+=fBlockDataArray[i+iSourceDataBlock].fSize;
464	// put the source task as many times into the list as it provides data blocks
465	// makes the bookkeeping for the data release easier
466	subscribedTaskList.Add(pSrcTask);
467	}
468	HLTDebug("Task %s (%p) successfully subscribed to %d data block(s) of task %s (%p)", GetName(), this, iResult, pSrcTask->GetName(), pSrcTask);
469	iSourceDataBlock+=iResult;
470	iResult=0;
471	} else {
472	HLTError("Task %s (%p): subscription to task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iResult);
473	iResult=-EFAULT;
474	}
475	} else {
476	HLTFatal("fatal internal error in ROOT list handling");
477	iResult=-EFAULT;
478	}
479	lnk=lnk->Next();
480	}
481
482	// process the event
483	int iNofTrial=0; // repeat processing if component returns -ENOSPC
484	AliHLTUInt32_t size=0;
485	if (iResult>=0) {
486	do {
487	long unsigned int iConstBase=0;
488	double fInputMultiplier=0;
489	if (pComponent->GetComponentType()!=AliHLTComponent::kSink)
490	pComponent->GetOutputDataSize(iConstBase, fInputMultiplier);
491	if (fInputMultiplier<0) {
492	HLTWarning("ignoring negative input multiplier");
493	fInputMultiplier=0;
494	}
495	long unsigned int iOutputDataSize=int(fInputMultiplier*iInputDataVolume) + iConstBase;
496	//HLTDebug("task %s: reqired output size %d", GetName(), iOutputDataSize);
497	if (iNofTrial>0) {
498	// dont process again if the buffer size is the same
499	if (size==iOutputDataSize) break;
500	HLTInfo("processing task %s again with buffer size %d", GetName(), iOutputDataSize);
501	}
502	AliHLTUInt8_t* pTgtBuffer=NULL;
503	if (iOutputDataSize>0) pTgtBuffer=fpDataBuffer->GetTargetBuffer(iOutputDataSize);
504	//HLTDebug("provided raw buffer %p", pTgtBuffer);
505	AliHLTComponentEventData evtData;
506	AliHLTComponent::FillEventData(evtData);
507	evtData.fEventID=(AliHLTEventID_t)eventNo;
508	evtData.fBlockCnt=iSourceDataBlock;
509	AliHLTComponentTriggerData trigData;
510	size=iOutputDataSize;
511	AliHLTUInt32_t outputBlockCnt=0;
512	AliHLTComponentBlockData* outputBlocks=NULL;
513	AliHLTComponentEventDoneData* edd;
514	if (pTgtBuffer!=NULL \|\| iOutputDataSize==0) {
515	iResult=pComponent->ProcessEvent(evtData, &fBlockDataArray[0], trigData, pTgtBuffer, size, outputBlockCnt, outputBlocks, edd);
516	HLTDebug("task %s: component %s ProcessEvent finnished (%d): size=%d blocks=%d", GetName(), pComponent->GetComponentID(), iResult, size, outputBlockCnt);
517	if (iResult>=0 && pTgtBuffer && outputBlocks) {
518	iResult=fpDataBuffer->SetSegments(pTgtBuffer, outputBlocks, outputBlockCnt);
519	delete [] outputBlocks; outputBlocks=NULL; outputBlockCnt=0;
520	} else {
521	fpDataBuffer->Reset();
522	}
523	} else {
524	HLTError("task %s: no target buffer available", GetName());
525	iResult=-EFAULT;
526	}
527	} while (iResult==-ENOSPC && iNofTrial++<1);
528	}
529
530	// now release all buffers which we have subscribed to
531	iSourceDataBlock=0;
532	lnk=subscribedTaskList.FirstLink();
533	while (lnk) {
534	pSrcTask=(AliHLTTask*)lnk->GetObject();
535	if (pSrcTask) {
536	int iTempRes=0;
537	if ((iTempRes=pSrcTask->Release(&fBlockDataArray[iSourceDataBlock], this))>=0) {
538	HLTDebug("Task %s (%p) successfully released segment of task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask);
539	} else {
540	HLTError("Task %s (%p): realease of task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iTempRes);
541	}
542	} else {
543	HLTFatal("task %s (%p): internal error in ROOT list handling", GetName(), this);
544	if (iResult>=0) iResult=-EFAULT;
545	}
546	subscribedTaskList.Remove(lnk);
547	lnk=subscribedTaskList.FirstLink();
548	iSourceDataBlock++;
549	}
550	if (subscribedTaskList.GetSize()>0) {
551	HLTError("task %s (%p): could not release all data buffers", GetName(), this);
552	}
553	} else {
554	HLTError("task %s (%p): internal failure (not initialized component %p, data buffer %p)", GetName(), this, fpComponent, fpDataBuffer);
555	iResult=-EFAULT;
556	}
557	return iResult;
558	}
559
560	int AliHLTTask::GetNofMatchingDataBlocks(const AliHLTTask* pConsumerTask) const
561	{
562	// see header file for function documentation
563	int iResult=0;
564	if (pConsumerTask) {
565	if (fpDataBuffer) {
566	iResult=fpDataBuffer->FindMatchingDataBlocks(pConsumerTask->GetComponent(), NULL);
567	} else {
568	HLTFatal("internal data buffer missing");
569	iResult=-EFAULT;
570	}
571	} else {
572	iResult=-EINVAL;
573	}
574	return iResult;
575	}
576
577	int AliHLTTask::GetNofMatchingDataTypes(const AliHLTTask* pConsumerTask) const
578	{
579	// see header file for function documentation
580	int iResult=0;
581	if (pConsumerTask) {
582	AliHLTComponent* pComponent=GetComponent();
583	if (!pComponent) {
584	// init ?
585	HLTError("component not initialized");
586	iResult=-EFAULT;
587	}
588	if (pComponent) {
589	iResult=pComponent->FindMatchingDataTypes(pConsumerTask->GetComponent(), NULL);
590	} else {
591	HLTFatal("task initialization failed");
592	iResult=-EFAULT;
593	}
594	} else {
595	iResult=-EINVAL;
596	}
597	return iResult;
598	}
599
600	int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponentBlockData* pBlockDesc, int iArraySize)
601	{
602	// see header file for function documentation
603	int iResult=0;
604	if (pConsumerTask) {
605	if (fpDataBuffer) {
606	iResult=fpDataBuffer->Subscribe(pConsumerTask->GetComponent(), pBlockDesc, iArraySize);
607	} else {
608	HLTFatal("internal data buffer missing");
609	iResult=-EFAULT;
610	}
611	} else {
612	iResult=-EINVAL;
613	}
614	return iResult;
615	}
616
617	int AliHLTTask::Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTTask* pConsumerTask)
618	{
619	// see header file for function documentation
620	int iResult=0;
621	if (pConsumerTask && pBlockDesc) {
622	if (fpDataBuffer) {
623	iResult=fpDataBuffer->Release(pBlockDesc, pConsumerTask->GetComponent());
624	} else {
625	HLTFatal("internal data buffer missing");
626	iResult=-EFAULT;
627	}
628	} else {
629	iResult=-EINVAL;
630	}
631	return iResult;
632	}
633
634	void AliHLTTask::PrintStatus()
635	{
636	// see header file for function documentation
637	HLTLogKeyword("task properties");
638	AliHLTComponent* pComponent=GetComponent();
639	if (pComponent) {
640	HLTMessage(" component: %s (%p)", pComponent->GetComponentID(), pComponent);
641	} else {
642	HLTMessage(" no component set!");
643	}
644	if (fpConfiguration) {
645	AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource();
646	while (pSrc) {
647	const char* pQualifier="unresolved";
648	if (FindDependency(pSrc->GetName()))
649	pQualifier="resolved";
650	HLTMessage(" source: %s (%s)", pSrc->GetName(), pQualifier);
651	pSrc=fpConfiguration->GetNextSource();
652	}
653	TObjLink* lnk = fListTargets.FirstLink();
654	while (lnk) {
655	TObject *obj = lnk->GetObject();
656	HLTMessage(" target: %s", obj->GetName());
657	lnk = lnk->Next();
658	}
659	} else {
660	HLTMessage(" task \"%s\" not initialized", GetName());
661	}
662	}