[u/mrichter/AliRoot.git] / MUON / MUONTimeRawStreamTrigger.C

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        *
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors:                                                       *
 *   Artur Szostak <artursz@iafrica.com>                                  *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

/// \ingroup macros
/// \file MUONTimeRawStreamTrigger.C
/// \brief Macro for checking the timing (speed) performace of the two different trigger decoders.
///
/// \author Artur Szostak <artursz@iafrica.com>
///
/// This macro is used to check the timing (speed) performance of the existing
/// offline decoder for the trigger DDLs and also for the new high performance
/// decoder. It can be invoked as follows:
/// 
///  $ aliroot
/// .L $ALICE_ROOT/MUON/MUONTimeRawStreamTrigger.C+
///  MUONTimeRawStreamTrigger(filename, maxEvent);
///
/// where \em filename is the name of a file containing the raw data, or alternatively
/// the directory containing rawX (X being an integer) paths with the raw DDL
/// data. The \em maxEvent value is the maximum event to process (default set to
/// 1000). Thus the macro will time the algorithm for all events in the range
/// [0 .. maxEvent-1].
///

#if !defined(__CINT__) || defined(__MAKECINT__)

#include "AliCodeTimer.h"

// MUON includes
#include "AliMUONRawStreamTrigger.h"
#include "AliMUONRawStreamTriggerHP.h"
#include "AliMUONDarcHeader.h"
#include "AliMUONRegHeader.h"
#include "AliMUONLocalStruct.h"
#include "AliMUONDDLTrigger.h"

// RAW includes
#include "AliRawReader.h"
#include "AliRawReaderMemory.h"
#include "AliRawDataHeader.h"

#include "TStopwatch.h"
#include "TMath.h"
#include "Riostream.h"

#endif


// Linked list node for buffer structures.
struct AliBufferInfo
{
	AliBufferInfo* fNext;
	Int_t fEquipId;
	UInt_t fBufferSize;
	UChar_t* fBuffer;
};


// local structure information to store
struct AliLocalStructInfo
{
	UChar_t fId;
	UChar_t fDec;
	Bool_t fTrigY;
	UChar_t fYPos;
	UChar_t fSXDev;
	UChar_t fXDev;
	UChar_t fXPos;
	Bool_t fTriggerY;
	Bool_t fTriggerX;
};


UInt_t LoadFiles(AliBufferInfo*& list, TString fileName = "./", Int_t maxEvent = 1000)
{
	/// Reads in the DDL files into memory buffers as a linked list.

	AliRawReader* rawReader = AliRawReader::Create(fileName.Data()); 

	if (rawReader == NULL)
	{
		cerr << "ERROR: Could not create AliRawReader." << endl;
		delete rawReader;
		return 0;
	}

	UInt_t count = 0;
	Int_t iEvent = 0;
	list = NULL;
	while (rawReader->NextEvent())
	{
		if (iEvent++ >= maxEvent) break;

		rawReader->Select("MUONTRG", 0, 1);
		while (rawReader->ReadHeader())
		{
			AliBufferInfo* info = new AliBufferInfo;
			if (info == NULL)
			{
				cerr << "ERROR: Out of memory, sorry. You should limit the number of events read in." << endl;
				delete rawReader;
				return count;
			}
			info->fNext = list;
			info->fEquipId = rawReader->GetEquipmentId();
			info->fBufferSize = rawReader->GetDataSize() + sizeof(AliRawDataHeader);
			info->fBuffer = new UChar_t[info->fBufferSize];
			if (info->fBuffer == NULL)
			{
				cerr << "ERROR: Out of memory, sorry. You should limit the number of events read in." << endl;
				delete rawReader;
				return count;
			}
			list = info;
			
			// Copy the header.
			memcpy(info->fBuffer, rawReader->GetDataHeader(), sizeof(AliRawDataHeader));

			// Now copy the payload.
			if (! rawReader->ReadNext(
						info->fBuffer + sizeof(AliRawDataHeader),
						info->fBufferSize - sizeof(AliRawDataHeader)
					)
			   )
			{
				cerr << "ERROR: Failed to read from AliRawReader." << endl;
			}
			count++;
		}
	}

	delete rawReader;
	return count;
}


UInt_t CountMaxStructs(AliBufferInfo* list)
{
	/// Counts the maximum number of local structures possible

	UInt_t total = 0;
	AliBufferInfo* current = list;
	while (current != NULL)
	{
		total += current->fBufferSize / 5;
		current = current->fNext;
	}
	return total;
}


void ReleaseBuffers(AliBufferInfo* list)
{
	/// Deletes the memory allocated for the linked list of buffers.

	AliBufferInfo* current = list;
	while (current != NULL)
	{
		AliBufferInfo* tmp = current;
		current = current->fNext;
		delete [] tmp->fBuffer;
		delete tmp;
	}
}


Double_t TimeUsingOldDecoder(AliBufferInfo* list, AliLocalStructInfo* buffer, UInt_t maxBufferSize)
{
	/// Perform a timing using the old decoder.

	AliRawReaderMemory rawReader;
	AliMUONRawStreamTrigger rawStream(&rawReader);
	rawReader.NextEvent();

	TStopwatch timer;
	timer.Start(kTRUE);

	UInt_t i = 0;
	AliBufferInfo* current = list;
	while (current != NULL)
	{
		rawReader.SetMemory(current->fBuffer, current->fBufferSize);
		rawReader.SetEquipmentID(current->fEquipId);
		rawReader.Reset();

		rawStream.First();
		
		TArrayS fXPattern;
		TArrayS fYPattern;

		while ( rawStream.Next(buffer[i].fId, buffer[i].fDec, buffer[i].fTrigY,
		                       buffer[i].fYPos, buffer[i].fSXDev, buffer[i].fXDev,
		                       buffer[i].fXPos, buffer[i].fTriggerY, buffer[i].fTriggerX,
		                       fXPattern, fYPattern)
		      )
		{
			if (i < maxBufferSize-1) i++;
		}

		current = current->fNext;
	}

	return timer.RealTime();
}


Double_t TimeUsingNewDecoder(AliBufferInfo* list, AliLocalStructInfo* buffer, UInt_t maxBufferSize)
{
	/// Perform a timing using the new decoder.

	AliRawReaderMemory rawReader;
	AliMUONRawStreamTriggerHP rawStream(&rawReader);
	rawReader.NextEvent();

	TStopwatch timer;
	timer.Start(kTRUE);

	UInt_t i = 0;
	AliBufferInfo* current = list;
	while (current != NULL)
	{
		rawReader.SetMemory(current->fBuffer, current->fBufferSize);
		rawReader.SetEquipmentID(current->fEquipId);
		rawReader.Reset();

		rawStream.First();

		const AliMUONRawStreamTriggerHP::AliLocalStruct* local = NULL;
		while ( (local = rawStream.Next()) != NULL )
		{
			if (i < maxBufferSize)
			{
				buffer[i].fId = local->GetId();
				buffer[i].fDec = local->GetDec();
				buffer[i].fTrigY = local->GetTrigY();
				buffer[i].fYPos = local->GetYPos();
				buffer[i].fSXDev = local->GetSXDev();
				buffer[i].fXDev = local->GetXDev();
				buffer[i].fXPos = local->GetXPos();
				buffer[i].fTriggerY = local->GetTriggerY();
				buffer[i].fTriggerX = local->GetTriggerX();
				i++;
			}
		}

		current = current->fNext;
	}

	return timer.RealTime();
}


Double_t TimeUsingNewDecoderOldInterface(AliBufferInfo* list, AliLocalStructInfo* buffer, UInt_t maxBufferSize)
{
	/// Perform a timing using the new decoder but the old Next() method
	/// as the interface.

	AliRawReaderMemory rawReader;
	AliMUONRawStreamTriggerHP rawStream(&rawReader);
	rawReader.NextEvent();

	TStopwatch timer;
	timer.Start(kTRUE);

	UInt_t i = 0;
	AliBufferInfo* current = list;
	while (current != NULL)
	{
		rawReader.SetMemory(current->fBuffer, current->fBufferSize);
		rawReader.SetEquipmentID(current->fEquipId);
		rawReader.Reset();

		rawStream.First();
		
		TArrayS fXPattern;
		TArrayS fYPattern;

		while ( rawStream.Next(buffer[i].fId, buffer[i].fDec, buffer[i].fTrigY,
		                       buffer[i].fYPos, buffer[i].fSXDev, buffer[i].fXDev,
		                       buffer[i].fXPos, buffer[i].fTriggerY, buffer[i].fTriggerX,
		                       fXPattern, fYPattern)
		      )
		{
			if (i < maxBufferSize-1) i++;
		}

		current = current->fNext;
	}

	return timer.RealTime();
}


void Loop(const char* filename, Bool_t newDecoder)
{
  AliCodeTimerAutoGeneral(Form("Loop %s",(newDecoder ? "NEW":"OLD")),);
  
  AliRawReader* reader = AliRawReader::Create(filename);
  
  AliMUONVRawStreamTrigger* stream;
  
  if ( newDecoder ) 
  {
    stream = new AliMUONRawStreamTriggerHP(reader);
  }
  else
  {
    stream = new AliMUONRawStreamTrigger(reader);
  }

  UChar_t id;
  UChar_t dec;
  Bool_t trigY;
  UChar_t yPos;
  UChar_t sXDev;
  UChar_t xDev;
  UChar_t xPos;
  Bool_t triggerY;
  Bool_t triggerX;
  TArrayS xPattern;
  TArrayS yPattern;
  
  while ( reader->NextEvent() )
  {
    stream->First();
    
    while ( stream->Next(id, dec, trigY, yPos, sXDev, xDev, xPos,
		         triggerY, triggerX, xPattern, yPattern) )
    {
      id *= 2;
    }
  }
  
  delete stream;
  delete reader;
}


void MUONTimeRawStreamTriggerDumb(TString fileName)
{
  AliCodeTimer::Instance()->Reset();
  
  // first check we can open the stream
  AliRawReader* reader = AliRawReader::Create(fileName.Data());
  if (!reader)
  {
    cerr << "Cannot create reader from " << fileName.Data() << endl;
    return;
  }
  delete reader;
  
  // now start the timing per se
  
  Loop(fileName,kFALSE);
  
  Loop(fileName,kTRUE);
  
  AliCodeTimer::Instance()->Print();
}


void MUONTimeRawStreamTrigger(TString fileName = "./", Int_t maxEvent = 1000)
{
	/// Performs a timing of old and new decoders and reports this.

	AliBufferInfo* list = NULL;
	UInt_t bufferCount = LoadFiles(list, fileName, maxEvent);
	if (bufferCount == 0)
	{
		cerr << "ERROR: No DDL files found or read in." << endl;
		return;
	}

	UInt_t maxBufferSize = CountMaxStructs(list);
	AliLocalStructInfo* buffer = new AliLocalStructInfo[maxBufferSize];
	if (buffer == NULL)
	{
		ReleaseBuffers(list);
		cerr << "ERROR: Out of memory, sorry. You should limit the number of events read in." << endl;
		return;
	}
	Double_t oldTimes[100];
	for (Int_t i = 0; i < 100; i++)
	{
		cout << "Timing old decoder: timing iteration " << i+1 << " of 100" << endl;
		oldTimes[i] = TimeUsingOldDecoder(list, buffer, maxBufferSize);
	}
	Double_t newTimes[100];
	for (Int_t i = 0; i < 100; i++)
	{
		cout << "Timing new decoder: timing iteration " << i+1 << " of 100" << endl;
		newTimes[i] = TimeUsingNewDecoder(list, buffer, maxBufferSize);
	}
	Double_t newTimes2[100];
	for (Int_t i = 0; i < 100; i++)
	{
		cout << "Timing new decoder with old interface: timing iteration " << i+1 << " of 100" << endl;
		newTimes2[i] = TimeUsingNewDecoderOldInterface(list, buffer, maxBufferSize);
	}

	ReleaseBuffers(list);
	delete buffer;

	Double_t oldTime = TMath::Mean(100, oldTimes) / Double_t(bufferCount);
	Double_t oldTimeErr = TMath::RMS(100, oldTimes) / Double_t(bufferCount);
	Double_t newTime = TMath::Mean(100, newTimes) / Double_t(bufferCount);
	Double_t newTimeErr = TMath::RMS(100, newTimes) / Double_t(bufferCount);
	Double_t newTime2 = TMath::Mean(100, newTimes2) / Double_t(bufferCount);
	Double_t newTime2Err = TMath::RMS(100, newTimes2) / Double_t(bufferCount);

	cout << "Average processing time per DDL for:" << endl;
	cout << "                   Old decoder = " << oldTime*1e6 << " +/- " << oldTimeErr*1e6/TMath::Sqrt(100) << " micro seconds" << endl;
	cout << "                   New decoder = " << newTime*1e6 << " +/- " << newTimeErr*1e6/TMath::Sqrt(100) << " micro seconds" << endl;
	cout << "New decoder with old interface = " << newTime2*1e6 << " +/- " << newTime2Err*1e6/TMath::Sqrt(100) << " micro seconds" << endl;
}
Commit	Line	Data
1788245f	1	/**************************************************************************
	2	* This file is property of and copyright by the ALICE HLT Project *
	3	* All rights reserved. *
	4	* *
	5	* Primary Authors: *
	6	* Artur Szostak <artursz@iafrica.com> *
	7	* *
	8	* Permission to use, copy, modify and distribute this software and its *
	9	* documentation strictly for non-commercial purposes is hereby granted *
	10	* without fee, provided that the above copyright notice appears in all *
	11	* copies and that both the copyright notice and this permission notice *
	12	* appear in the supporting documentation. The authors make no claims *
	13	* about the suitability of this software for any purpose. It is *
	14	* provided "as is" without express or implied warranty. *
	15	**************************************************************************/
	16
	17	/// \ingroup macros
	18	/// \file MUONTimeRawStreamTrigger.C
	19	/// \brief Macro for checking the timing (speed) performace of the two different trigger decoders.
	20	///
	21	/// \author Artur Szostak <artursz@iafrica.com>
	22	///
	23	/// This macro is used to check the timing (speed) performance of the existing
	24	/// offline decoder for the trigger DDLs and also for the new high performance
	25	/// decoder. It can be invoked as follows:
	26	///
	27	/// $ aliroot
	28	/// .L $ALICE_ROOT/MUON/MUONTimeRawStreamTrigger.C+
	29	/// MUONTimeRawStreamTrigger(filename, maxEvent);
	30	///
	31	/// where \em filename is the name of a file containing the raw data, or alternatively
	32	/// the directory containing rawX (X being an integer) paths with the raw DDL
	33	/// data. The \em maxEvent value is the maximum event to process (default set to
	34	/// 1000). Thus the macro will time the algorithm for all events in the range
	35	/// [0 .. maxEvent-1].
	36	///
	37
	38	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	39
	40	#include "AliCodeTimer.h"
	41
	42	// MUON includes
	43	#include "AliMUONRawStreamTrigger.h"
	44	#include "AliMUONRawStreamTriggerHP.h"
	45	#include "AliMUONDarcHeader.h"
	46	#include "AliMUONRegHeader.h"
	47	#include "AliMUONLocalStruct.h"
	48	#include "AliMUONDDLTrigger.h"
	49
	50	// RAW includes
	51	#include "AliRawReader.h"
	52	#include "AliRawReaderMemory.h"
	53	#include "AliRawDataHeader.h"
	54
	55	#include "TStopwatch.h"
	56	#include "TMath.h"
	57	#include "Riostream.h"
	58
	59	#endif
	60
	61
	62	// Linked list node for buffer structures.
	63	struct AliBufferInfo
	64	{
65	AliBufferInfo* fNext;
66	Int_t fEquipId;
67	UInt_t fBufferSize;
68	UChar_t* fBuffer;
69	};
70
71
72	// local structure information to store
73	struct AliLocalStructInfo
74	{
75	UChar_t fId;
76	UChar_t fDec;
77	Bool_t fTrigY;
78	UChar_t fYPos;
79	UChar_t fSXDev;
80	UChar_t fXDev;
81	UChar_t fXPos;
82	Bool_t fTriggerY;
83	Bool_t fTriggerX;
84	};
85
86
87	UInt_t LoadFiles(AliBufferInfo*& list, TString fileName = "./", Int_t maxEvent = 1000)
88	{
89	/// Reads in the DDL files into memory buffers as a linked list.
90
91	AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
92
93	if (rawReader == NULL)
94	{
95	cerr << "ERROR: Could not create AliRawReader." << endl;
96	delete rawReader;
97	return 0;
98	}
99
100	UInt_t count = 0;
101	Int_t iEvent = 0;
102	list = NULL;
103	while (rawReader->NextEvent())
104	{
105	if (iEvent++ >= maxEvent) break;
106
107	rawReader->Select("MUONTRG", 0, 1);
108	while (rawReader->ReadHeader())
109	{
110	AliBufferInfo* info = new AliBufferInfo;
111	if (info == NULL)
112	{
113	cerr << "ERROR: Out of memory, sorry. You should limit the number of events read in." << endl;
114	delete rawReader;
115	return count;
116	}
117	info->fNext = list;
118	info->fEquipId = rawReader->GetEquipmentId();
119	info->fBufferSize = rawReader->GetDataSize() + sizeof(AliRawDataHeader);
120	info->fBuffer = new UChar_t[info->fBufferSize];
121	if (info->fBuffer == NULL)
122	{
123	cerr << "ERROR: Out of memory, sorry. You should limit the number of events read in." << endl;
124	delete rawReader;
125	return count;
126	}
127	list = info;
128
129	// Copy the header.
130	memcpy(info->fBuffer, rawReader->GetDataHeader(), sizeof(AliRawDataHeader));
131
132	// Now copy the payload.
133	if (! rawReader->ReadNext(
134	info->fBuffer + sizeof(AliRawDataHeader),
135	info->fBufferSize - sizeof(AliRawDataHeader)
136	)
137	)
138	{
139	cerr << "ERROR: Failed to read from AliRawReader." << endl;
140	}
141	count++;
142	}
143	}
144
145	delete rawReader;
146	return count;
147	}
148
149
150	UInt_t CountMaxStructs(AliBufferInfo* list)
151	{
152	/// Counts the maximum number of local structures possible
153
154	UInt_t total = 0;
155	AliBufferInfo* current = list;
156	while (current != NULL)
157	{
158	total += current->fBufferSize / 5;
159	current = current->fNext;
160	}
161	return total;
162	}
163
164
165	void ReleaseBuffers(AliBufferInfo* list)
166	{
167	/// Deletes the memory allocated for the linked list of buffers.
168
169	AliBufferInfo* current = list;
170	while (current != NULL)
171	{
172	AliBufferInfo* tmp = current;
173	current = current->fNext;
174	delete [] tmp->fBuffer;
175	delete tmp;
176	}
177	}
178
179
180	Double_t TimeUsingOldDecoder(AliBufferInfo* list, AliLocalStructInfo* buffer, UInt_t maxBufferSize)
181	{
182	/// Perform a timing using the old decoder.
183
184	AliRawReaderMemory rawReader;
185	AliMUONRawStreamTrigger rawStream(&rawReader);
186	rawReader.NextEvent();
187
188	TStopwatch timer;
189	timer.Start(kTRUE);
190
191	UInt_t i = 0;
192	AliBufferInfo* current = list;
193	while (current != NULL)
194	{
195	rawReader.SetMemory(current->fBuffer, current->fBufferSize);
196	rawReader.SetEquipmentID(current->fEquipId);
197	rawReader.Reset();
198
199	rawStream.First();
200
201	TArrayS fXPattern;
202	TArrayS fYPattern;
203
204	while ( rawStream.Next(buffer[i].fId, buffer[i].fDec, buffer[i].fTrigY,
205	buffer[i].fYPos, buffer[i].fSXDev, buffer[i].fXDev,
206	buffer[i].fXPos, buffer[i].fTriggerY, buffer[i].fTriggerX,
207	fXPattern, fYPattern)
208	)
209	{
210	if (i < maxBufferSize-1) i++;
211	}
212
213	current = current->fNext;
214	}
215
216	return timer.RealTime();
217	}
218
219
220	Double_t TimeUsingNewDecoder(AliBufferInfo* list, AliLocalStructInfo* buffer, UInt_t maxBufferSize)
221	{
222	/// Perform a timing using the new decoder.
223
224	AliRawReaderMemory rawReader;
225	AliMUONRawStreamTriggerHP rawStream(&rawReader);
226	rawReader.NextEvent();
227
228	TStopwatch timer;
229	timer.Start(kTRUE);
230
231	UInt_t i = 0;
232	AliBufferInfo* current = list;
233	while (current != NULL)
234	{
235	rawReader.SetMemory(current->fBuffer, current->fBufferSize);
236	rawReader.SetEquipmentID(current->fEquipId);
237	rawReader.Reset();
238
239	rawStream.First();
240
241	const AliMUONRawStreamTriggerHP::AliLocalStruct* local = NULL;
242	while ( (local = rawStream.Next()) != NULL )
243	{
244	if (i < maxBufferSize)
245	{
246	buffer[i].fId = local->GetId();
247	buffer[i].fDec = local->GetDec();
248	buffer[i].fTrigY = local->GetTrigY();
249	buffer[i].fYPos = local->GetYPos();
250	buffer[i].fSXDev = local->GetSXDev();
251	buffer[i].fXDev = local->GetXDev();
252	buffer[i].fXPos = local->GetXPos();
253	buffer[i].fTriggerY = local->GetTriggerY();
254	buffer[i].fTriggerX = local->GetTriggerX();
255	i++;
256	}
257	}
258
259	current = current->fNext;
260	}
261
262	return timer.RealTime();
263	}
264
265
266	Double_t TimeUsingNewDecoderOldInterface(AliBufferInfo* list, AliLocalStructInfo* buffer, UInt_t maxBufferSize)
267	{
268	/// Perform a timing using the new decoder but the old Next() method
269	/// as the interface.
270
271	AliRawReaderMemory rawReader;
272	AliMUONRawStreamTriggerHP rawStream(&rawReader);
273	rawReader.NextEvent();
274
275	TStopwatch timer;
276	timer.Start(kTRUE);
277
278	UInt_t i = 0;
279	AliBufferInfo* current = list;
280	while (current != NULL)
281	{
282	rawReader.SetMemory(current->fBuffer, current->fBufferSize);
283	rawReader.SetEquipmentID(current->fEquipId);
284	rawReader.Reset();
285
286	rawStream.First();
287
288	TArrayS fXPattern;
289	TArrayS fYPattern;
290
291	while ( rawStream.Next(buffer[i].fId, buffer[i].fDec, buffer[i].fTrigY,
292	buffer[i].fYPos, buffer[i].fSXDev, buffer[i].fXDev,
293	buffer[i].fXPos, buffer[i].fTriggerY, buffer[i].fTriggerX,
294	fXPattern, fYPattern)
295	)
296	{
297	if (i < maxBufferSize-1) i++;
298	}
299
300	current = current->fNext;
301	}
302
303	return timer.RealTime();
304	}
305
306
307	void Loop(const char* filename, Bool_t newDecoder)
308	{
70d92702	309	AliCodeTimerAutoGeneral(Form("Loop %s",(newDecoder ? "NEW":"OLD")),);
1788245f	310
	311	AliRawReader* reader = AliRawReader::Create(filename);
	312
	313	AliMUONVRawStreamTrigger* stream;
	314
	315	if ( newDecoder )
	316	{
	317	stream = new AliMUONRawStreamTriggerHP(reader);
	318	}
	319	else
	320	{
	321	stream = new AliMUONRawStreamTrigger(reader);
	322	}
	323
	324	UChar_t id;
	325	UChar_t dec;
	326	Bool_t trigY;
	327	UChar_t yPos;
	328	UChar_t sXDev;
	329	UChar_t xDev;
	330	UChar_t xPos;
	331	Bool_t triggerY;
	332	Bool_t triggerX;
	333	TArrayS xPattern;
	334	TArrayS yPattern;
	335
	336	while ( reader->NextEvent() )
	337	{
	338	stream->First();
	339
	340	while ( stream->Next(id, dec, trigY, yPos, sXDev, xDev, xPos,
	341	triggerY, triggerX, xPattern, yPattern) )
	342	{
	343	id *= 2;
	344	}
	345	}
	346
	347	delete stream;
	348	delete reader;
	349	}
	350
	351
	352	void MUONTimeRawStreamTriggerDumb(TString fileName)
	353	{
	354	AliCodeTimer::Instance()->Reset();
	355
	356	// first check we can open the stream
	357	AliRawReader* reader = AliRawReader::Create(fileName.Data());
	358	if (!reader)
	359	{
	360	cerr << "Cannot create reader from " << fileName.Data() << endl;
	361	return;
	362	}
	363	delete reader;
	364
	365	// now start the timing per se
	366
	367	Loop(fileName,kFALSE);
	368
	369	Loop(fileName,kTRUE);
	370
	371	AliCodeTimer::Instance()->Print();
	372	}
	373
374
375	void MUONTimeRawStreamTrigger(TString fileName = "./", Int_t maxEvent = 1000)
376	{
377	/// Performs a timing of old and new decoders and reports this.
378
379	AliBufferInfo* list = NULL;
380	UInt_t bufferCount = LoadFiles(list, fileName, maxEvent);
381	if (bufferCount == 0)
382	{
383	cerr << "ERROR: No DDL files found or read in." << endl;
384	return;
385	}
386
387	UInt_t maxBufferSize = CountMaxStructs(list);
388	AliLocalStructInfo* buffer = new AliLocalStructInfo[maxBufferSize];
389	if (buffer == NULL)
390	{
391	ReleaseBuffers(list);
392	cerr << "ERROR: Out of memory, sorry. You should limit the number of events read in." << endl;
393	return;
394	}
395	Double_t oldTimes[100];
396	for (Int_t i = 0; i < 100; i++)
397	{
398	cout << "Timing old decoder: timing iteration " << i+1 << " of 100" << endl;
399	oldTimes[i] = TimeUsingOldDecoder(list, buffer, maxBufferSize);
400	}
401	Double_t newTimes[100];
402	for (Int_t i = 0; i < 100; i++)
403	{
404	cout << "Timing new decoder: timing iteration " << i+1 << " of 100" << endl;
405	newTimes[i] = TimeUsingNewDecoder(list, buffer, maxBufferSize);
406	}
407	Double_t newTimes2[100];
408	for (Int_t i = 0; i < 100; i++)
409	{
410	cout << "Timing new decoder with old interface: timing iteration " << i+1 << " of 100" << endl;
411	newTimes2[i] = TimeUsingNewDecoderOldInterface(list, buffer, maxBufferSize);
412	}
413
414	ReleaseBuffers(list);
415	delete buffer;
416
417	Double_t oldTime = TMath::Mean(100, oldTimes) / Double_t(bufferCount);
418	Double_t oldTimeErr = TMath::RMS(100, oldTimes) / Double_t(bufferCount);
419	Double_t newTime = TMath::Mean(100, newTimes) / Double_t(bufferCount);
420	Double_t newTimeErr = TMath::RMS(100, newTimes) / Double_t(bufferCount);
421	Double_t newTime2 = TMath::Mean(100, newTimes2) / Double_t(bufferCount);
422	Double_t newTime2Err = TMath::RMS(100, newTimes2) / Double_t(bufferCount);
423
424	cout << "Average processing time per DDL for:" << endl;
425	cout << " Old decoder = " << oldTime1e6 << " +/- " << oldTimeErr1e6/TMath::Sqrt(100) << " micro seconds" << endl;
426	cout << " New decoder = " << newTime1e6 << " +/- " << newTimeErr1e6/TMath::Sqrt(100) << " micro seconds" << endl;
427	cout << "New decoder with old interface = " << newTime21e6 << " +/- " << newTime2Err1e6/TMath::Sqrt(100) << " micro seconds" << endl;
428	}
429