[u/mrichter/AliRoot.git] / EVE / EveHLT / AliEveEventBuffer.cxx

#include <iostream>

#include "TObjArray.h"
#include "TTimer.h"
#include "TThread.h"
#include "TMutex.h"
#include "AliEveEventBuffer.h"


//Not needed, only for debug
#include "AliESDEvent.h"

using namespace std;

ClassImp(AliEveEventBuffer)

///_______________________________________________________________________
AliEveEventBuffer::AliEveEventBuffer() :
  fBufferSize(10),
  fPreBuffer(4),
  fBusy(kFALSE),
  fEventBuffer(NULL),
  fCurrentEvent(NULL),
  fBIndex(),
  fTimer(NULL),
  fEventId(),
  fBufferMonStarted(kFALSE),
  fThread(NULL),
  fMutex(NULL)
 {
  // see header file for class documentation
  fEventBuffer = new TObjArray(fBufferSize, 0);
  fEventBuffer->SetOwner(kFALSE);
  
  for(int id = 0; id < kSize; id++) {
    fBIndex[id] = -1;
  }
  
  fTimer = new TTimer();
  fTimer->Connect("Timeout()", "AliEveEventBuffer", this, "CreateBufferThread()");

  fEventId = new ULong64_t[fBufferSize];
  for(Int_t id = 0; id < fBufferSize; id++ ) {
    fEventId[id] = -2;
  }

  fThread = new TThread(AliEveEventBuffer::BufferThread, (void*) this);
  fMutex = new TMutex();
  

}


///_______________________________________________________________________
AliEveEventBuffer::~AliEveEventBuffer() {
  // see header file for class documentation
  
  if ( fEventBuffer ) {
    fEventBuffer->Clear();
    delete fEventBuffer;
  }
  fEventBuffer = NULL;

  if(fCurrentEvent)
    delete fCurrentEvent;
  fCurrentEvent = NULL;

}

///___________________________________________________________________________
void AliEveEventBuffer::CreateBufferThread() {
  
  
  cout << "Threadexists: " << fThread->Exists() << endl;
  if( fMutex->TryLock() ) {
    cout << "Buffer is busy, no thread created"<< endl;
    return;
  } else {
    if ( (CalculateDifference(fBIndex[kTop],fBIndex[kLast]) < fPreBuffer) ) {
      SetBusy(kTRUE);
      cout << "StartBufferThread()"<<endl;
      fThread->Run();
      cout << "Started BufferThread"<<endl;
    } else { 
      cout << "Buffer is full already"<<endl;
      fMutex->UnLock();
    }
  }
}

///___________________________________________________________________________
void * AliEveEventBuffer::BufferThread(void * buffer) {
  cout <<"BufferThread : " <<endl;
  if(buffer) {
      reinterpret_cast<AliEveEventBuffer*>(buffer)->MonitorBuffer();
  } else {
    cout << "no buffer"<<endl;
  }
  return (void*)0;
}

///_____________________________________________________________________________
void AliEveEventBuffer::MonitorBuffer() {
  cout << "Monitorbuffer() ";
  FetchEvent();
  fMutex->UnLock();

  cout << "done " << endl;
}


///_______________________________________________________________________________
TObject * AliEveEventBuffer::NextEvent() {
  //See header file for documentation
  cout << "NextEvent()"<<endl;
  TObject * nextEvent = GetNextUnSeen();
  return nextEvent;
}

///______________________________________________________________________________
TObject * AliEveEventBuffer::Back() {
  cout << "go back"<<endl;
  PrintIndeces();
  Int_t prevId = CalculatePrevious(fBIndex[kCurrent]);
  if(prevId == fBIndex[kTop]) {
    cout << "returning NULL" << endl;
    return NULL;
  } else {
    fBIndex[kCurrent] = prevId;
    PrintIndeces();
    cout <<"returning: "<< fBIndex[kCurrent] << " " << fEventBuffer->At(fBIndex[kCurrent]);
    return fEventBuffer->At(fBIndex[kCurrent]);
  }
}


///______________________________________________________________________________
TObject * AliEveEventBuffer::Fwd() {
  PrintIndeces();
  if (fBIndex[kCurrent] == fBIndex[kLast]) {
    cout<<  "returning NULL"<<endl;
    return NULL;
  }
  
  fBIndex[kCurrent] = CalculateNext(fBIndex[kCurrent]);
  TObject * event = fEventBuffer->At(fBIndex[kCurrent]);
  return event;
}


///________________________________________________________________________________
TObject * AliEveEventBuffer::GetNextUnSeen() {
  //See header file for documentation
  cout << "GetNextUnSeen"<<endl;
  PrintIndeces();
  if(CalculateDifference(fBIndex[kTop], fBIndex[kLast])) {
    fBIndex[kLast] = CalculateNext(fBIndex[kLast]);
    fBIndex[kCurrent] = fBIndex[kLast];
    PrintIndeces();
    return fEventBuffer->At(fBIndex[kCurrent]);      
  } else {
    cout << "No new event available, only events in buffer available!"<<endl;
    return NULL;
  } 
}
///_________________________________________________________________________________
void AliEveEventBuffer::PrintIndeces() {
  for(Int_t i = 0; i < kSize; i++) {
    cout << i << ": " << fBIndex[i] << endl;
  }
}
///_________________________________________________________________________________
void AliEveEventBuffer::PrintBuffer() {
  for(Int_t i = 0; i < 10; i++) {
    AliESDEvent * event = dynamic_cast<AliESDEvent*>(fEventBuffer->At(i));
    if(event) {
      cout << i << ": " <<event << " " << event->GetEventNumberInFile() << endl;;
    }
  }
}

///____________________________________________________________________________________
void AliEveEventBuffer::FetchEvent() {
  cout << "FetchEvent " << endl;
  TObject * event = GetEventFromSource();
  ULong64_t eventId = GetEventIdFromSource();
  if(event) {
    AddToBuffer(event);
    fEventId[fBIndex[kTop]] = eventId;  
  }
  
  PrintIndeces();
  cout << "FetchedEvent " << endl;
  
}

///_________________________________________________________________________________
void AliEveEventBuffer::AddToBuffer(TObject * event) {
  cout << "Add to buffer"<<endl;
  if(!event) return;

  fBIndex[kTop] = CalculateNext(fBIndex[kTop]);
  //Delete the event already there (ok to delete as object, not aliesdevent, TList?)
  //TObject * object = fEventBuffer->At(fBIndex[kTop]);
  fEventBuffer->RemoveAt(fBIndex[kTop]);
  //if (object) delete object;
  fEventBuffer->AddAt(event, fBIndex[kTop]);

}

///_____________________________________________________________________________________
Int_t AliEveEventBuffer::CalculateNext(Int_t current) {
  //See header file for documentation
  current++;
  if(current == fBufferSize) current = 0;
  return current;
}


///_____________________________________________________________________________________
Int_t AliEveEventBuffer::CalculatePrevious(Int_t current) {
  //See header file for documentation
  cout << "CalculatePrev:  " << current; 
  current--;
  if(current == -1) current += fBufferSize;
  cout << "... " << current << endl;
  return current;
}

///__________________________________________________________________________________
Int_t AliEveEventBuffer::CalculateDifference(Int_t top, Int_t low) {
  //See header file for documentation
  if (top > low) {
    //    cout << "top > low"<<endl;
    return (top - low);
  } else if (top < low) {
    // cout << "low < top"<<endl;
    return (fBufferSize - low + top);
  } else {
    //cout << "calculated to 0"<<endl;
    return 0;
  }
}

///___________________________________________________________________________________
void AliEveEventBuffer::StartBufferMonitor() {
  //cout << "NOT !!! starting buffer mon"<<endl;
  cout << "starting buffer mon"<<endl;
  if(!GetBufferMonStarted()) {
    CreateBufferThread();
    SetBufferMonStarted(kTRUE);
    fTimer->Start(15000);
  } else {
    cout << "Stopping buffer monitor"<<endl;
    fTimer->Stop();
    SetBufferMonStarted(kFALSE);
  }
}
///___________________________________________________________________________________
void AliEveEventBuffer::StopBufferMonitor() {
  cout << "Stopping buffer mon"<<endl;
  SetBufferMonStarted(kFALSE);
  fTimer->Stop();
}


// //_________________________________________________________________________________
// Int_t AliEveEventBuffer::NavigateEventBufferBack() { 
//   // see header file for class documentation

//   // -- reached the end of the buffer
//   if ( fNavigateBufferIdx == fBufferLowIdx )
//     return -1;

//   Int_t newIdx = fNavigateBufferIdx - 1;
//   if ( newIdx == -1 )
//     newIdx = BUFFERSIZE-1;

//   fCurrentBufferIdx = fNavigateBufferIdx = newIdx;

//   return newIdx;
// }

// //_______________________________________________________________
// Int_t AliEveEventBuffer::NavigateEventBufferFwd() {
//   // see header file for class documentation

//   // -- reached the top of the buffer
//   if ( fNavigateBufferIdx == fBufferTopIdx )
//     return -1;

//   Int_t newIdx = fNavigateBufferIdx + 1;
//   if ( newIdx == BUFFERSIZE )
//     newIdx = 0;
  
//   fCurrentBufferIdx = fNavigateBufferIdx = newIdx;

//   return newIdx;
// }

// void AliEveEventBuffer::MonitorBuffer() {
//   //See header file for documentation
//   if( GetNAvailableEvents() < 10) {
//     StopBufferChecker();
//     StartLoop();
//   }
// }

// void AliEveEventBuffer::StartLoop() {
//   //See header file for documentation
//   fTimer->Start(2000);
// }
// void AliEveEventBuffer::StopLoop() {
//   //See header file for documentation
//   fTimer->Stop();
// }

// void AliEveEventBuffer::StartBufferChecker() {
//   //See header file for documentation
//   fBufferTimer->Start(2000);
// }
// void AliEveEventBuffer::StopBufferChecker() {
//   //See header file for documentation
//   fBufferTimer->Stop();
// }

// AliESDEvent * GetNextEvent() {
  
//   tree->GetEntry(fEvent++);

//   AliESDEvent * event = new AliESDEvent();
//   event->ReadFromTree(fTree);
//   if (event) {
//     return event;
//   } else {
//     cout << "error getting event" << endl;
//     return NULL;
//   }
// }
Commit	Line	Data
	1	#include <iostream>
	2
	3	#include "TObjArray.h"
	4	#include "TTimer.h"
	5	#include "TThread.h"
	6	#include "TMutex.h"
	7	#include "AliEveEventBuffer.h"
	8
	9
	10	//Not needed, only for debug
	11	#include "AliESDEvent.h"
	12
	13	using namespace std;
	14
	15	ClassImp(AliEveEventBuffer)
	16
	17	///_______________________________________________________________________
	18	AliEveEventBuffer::AliEveEventBuffer() :
	19	fBufferSize(10),
	20	fPreBuffer(4),
	21	fBusy(kFALSE),
	22	fEventBuffer(NULL),
	23	fCurrentEvent(NULL),
	24	fBIndex(),
	25	fTimer(NULL),
	26	fEventId(),
	27	fBufferMonStarted(kFALSE),
	28	fThread(NULL),
	29	fMutex(NULL)
	30	{
	31	// see header file for class documentation
	32	fEventBuffer = new TObjArray(fBufferSize, 0);
	33	fEventBuffer->SetOwner(kFALSE);
	34
	35	for(int id = 0; id < kSize; id++) {
	36	fBIndex[id] = -1;
	37	}
	38
	39	fTimer = new TTimer();
	40	fTimer->Connect("Timeout()", "AliEveEventBuffer", this, "CreateBufferThread()");
	41
	42	fEventId = new ULong64_t[fBufferSize];
	43	for(Int_t id = 0; id < fBufferSize; id++ ) {
	44	fEventId[id] = -2;
	45	}
	46
	47	fThread = new TThread(AliEveEventBuffer::BufferThread, (void*) this);
	48	fMutex = new TMutex();
	49
	50
	51	}
	52
	53
	54
	55	///_______________________________________________________________________
	56	AliEveEventBuffer::~AliEveEventBuffer() {
	57	// see header file for class documentation
	58
	59	if ( fEventBuffer ) {
	60	fEventBuffer->Clear();
	61	delete fEventBuffer;
	62	}
	63	fEventBuffer = NULL;
	64
	65	if(fCurrentEvent)
	66	delete fCurrentEvent;
	67	fCurrentEvent = NULL;
	68
	69	}
	70
	71	///___________________________________________________________________________
	72	void AliEveEventBuffer::CreateBufferThread() {
	73
	74
	75	cout << "Threadexists: " << fThread->Exists() << endl;
	76	if( fMutex->TryLock() ) {
	77	cout << "Buffer is busy, no thread created"<< endl;
	78	return;
	79	} else {
	80	if ( (CalculateDifference(fBIndex[kTop],fBIndex[kLast]) < fPreBuffer) ) {
	81	SetBusy(kTRUE);
	82	cout << "StartBufferThread()"<<endl;
	83	fThread->Run();
	84	cout << "Started BufferThread"<<endl;
	85	} else {
	86	cout << "Buffer is full already"<<endl;
	87	fMutex->UnLock();
	88	}
	89	}
	90	}
	91
	92	///___________________________________________________________________________
	93	void * AliEveEventBuffer::BufferThread(void * buffer) {
	94	cout <<"BufferThread : " <<endl;
	95	if(buffer) {
	96	reinterpret_cast<AliEveEventBuffer*>(buffer)->MonitorBuffer();
	97	} else {
	98	cout << "no buffer"<<endl;
	99	}
	100	return (void*)0;
	101	}
	102
	103	///_____________________________________________________________________________
	104	void AliEveEventBuffer::MonitorBuffer() {
	105	cout << "Monitorbuffer() ";
	106	FetchEvent();
	107	fMutex->UnLock();
	108
	109	cout << "done " << endl;
	110	}
	111
	112
	113	///_______________________________________________________________________________
	114	TObject * AliEveEventBuffer::NextEvent() {
	115	//See header file for documentation
	116	cout << "NextEvent()"<<endl;
	117	TObject * nextEvent = GetNextUnSeen();
	118	return nextEvent;
	119	}
	120
	121	///______________________________________________________________________________
	122	TObject * AliEveEventBuffer::Back() {
	123	cout << "go back"<<endl;
	124	PrintIndeces();
	125	Int_t prevId = CalculatePrevious(fBIndex[kCurrent]);
	126	if(prevId == fBIndex[kTop]) {
	127	cout << "returning NULL" << endl;
	128	return NULL;
	129	} else {
	130	fBIndex[kCurrent] = prevId;
	131	PrintIndeces();
	132	cout <<"returning: "<< fBIndex[kCurrent] << " " << fEventBuffer->At(fBIndex[kCurrent]);
	133	return fEventBuffer->At(fBIndex[kCurrent]);
	134	}
	135	}
	136
	137
	138
	139	///______________________________________________________________________________
	140	TObject * AliEveEventBuffer::Fwd() {
	141	PrintIndeces();
	142	if (fBIndex[kCurrent] == fBIndex[kLast]) {
	143	cout<< "returning NULL"<<endl;
	144	return NULL;
	145	}
	146
	147	fBIndex[kCurrent] = CalculateNext(fBIndex[kCurrent]);
	148	TObject * event = fEventBuffer->At(fBIndex[kCurrent]);
	149	return event;
	150	}
	151
	152
	153
	154	///________________________________________________________________________________
	155	TObject * AliEveEventBuffer::GetNextUnSeen() {
	156	//See header file for documentation
	157	cout << "GetNextUnSeen"<<endl;
	158	PrintIndeces();
	159	if(CalculateDifference(fBIndex[kTop], fBIndex[kLast])) {
	160	fBIndex[kLast] = CalculateNext(fBIndex[kLast]);
	161	fBIndex[kCurrent] = fBIndex[kLast];
	162	PrintIndeces();
	163	return fEventBuffer->At(fBIndex[kCurrent]);
	164	} else {
	165	cout << "No new event available, only events in buffer available!"<<endl;
	166	return NULL;
	167	}
	168	}
	169	///_________________________________________________________________________________
	170	void AliEveEventBuffer::PrintIndeces() {
	171	for(Int_t i = 0; i < kSize; i++) {
	172	cout << i << ": " << fBIndex[i] << endl;
	173	}
	174	}
	175	///_________________________________________________________________________________
	176	void AliEveEventBuffer::PrintBuffer() {
	177	for(Int_t i = 0; i < 10; i++) {
	178	AliESDEvent * event = dynamic_cast<AliESDEvent*>(fEventBuffer->At(i));
	179	if(event) {
	180	cout << i << ": " <<event << " " << event->GetEventNumberInFile() << endl;;
	181	}
	182	}
	183	}
	184
	185	///____________________________________________________________________________________
	186	void AliEveEventBuffer::FetchEvent() {
	187	cout << "FetchEvent " << endl;
	188	TObject * event = GetEventFromSource();
	189	ULong64_t eventId = GetEventIdFromSource();
	190	if(event) {
	191	AddToBuffer(event);
	192	fEventId[fBIndex[kTop]] = eventId;
	193	}
	194
	195	PrintIndeces();
	196	cout << "FetchedEvent " << endl;
	197
	198	}
	199
	200	///_________________________________________________________________________________
	201	void AliEveEventBuffer::AddToBuffer(TObject * event) {
	202	cout << "Add to buffer"<<endl;
	203	if(!event) return;
	204
	205	fBIndex[kTop] = CalculateNext(fBIndex[kTop]);
	206	//Delete the event already there (ok to delete as object, not aliesdevent, TList?)
	207	//TObject * object = fEventBuffer->At(fBIndex[kTop]);
	208	fEventBuffer->RemoveAt(fBIndex[kTop]);
	209	//if (object) delete object;
	210	fEventBuffer->AddAt(event, fBIndex[kTop]);
	211
	212	}
	213
	214	///_____________________________________________________________________________________
	215	Int_t AliEveEventBuffer::CalculateNext(Int_t current) {
	216	//See header file for documentation
	217	current++;
	218	if(current == fBufferSize) current = 0;
	219	return current;
	220	}
	221
	222
	223	///_____________________________________________________________________________________
	224	Int_t AliEveEventBuffer::CalculatePrevious(Int_t current) {
	225	//See header file for documentation
	226	cout << "CalculatePrev: " << current;
	227	current--;
	228	if(current == -1) current += fBufferSize;
	229	cout << "... " << current << endl;
	230	return current;
	231	}
	232
	233	///__________________________________________________________________________________
	234	Int_t AliEveEventBuffer::CalculateDifference(Int_t top, Int_t low) {
	235	//See header file for documentation
	236	if (top > low) {
	237	// cout << "top > low"<<endl;
	238	return (top - low);
	239	} else if (top < low) {
	240	// cout << "low < top"<<endl;
	241	return (fBufferSize - low + top);
	242	} else {
	243	//cout << "calculated to 0"<<endl;
	244	return 0;
	245	}
	246	}
	247
	248	///___________________________________________________________________________________
	249	void AliEveEventBuffer::StartBufferMonitor() {
	250	//cout << "NOT !!! starting buffer mon"<<endl;
	251	cout << "starting buffer mon"<<endl;
	252	if(!GetBufferMonStarted()) {
	253	CreateBufferThread();
	254	SetBufferMonStarted(kTRUE);
	255	fTimer->Start(15000);
	256	} else {
	257	cout << "Stopping buffer monitor"<<endl;
	258	fTimer->Stop();
	259	SetBufferMonStarted(kFALSE);
	260	}
	261	}
	262	///___________________________________________________________________________________
	263	void AliEveEventBuffer::StopBufferMonitor() {
	264	cout << "Stopping buffer mon"<<endl;
	265	SetBufferMonStarted(kFALSE);
	266	fTimer->Stop();
	267	}
	268
	269
	270	// //_________________________________________________________________________________
	271	// Int_t AliEveEventBuffer::NavigateEventBufferBack() {
	272	// // see header file for class documentation
	273
	274	// // -- reached the end of the buffer
	275	// if ( fNavigateBufferIdx == fBufferLowIdx )
	276	// return -1;
	277
	278	// Int_t newIdx = fNavigateBufferIdx - 1;
	279	// if ( newIdx == -1 )
	280	// newIdx = BUFFERSIZE-1;
	281
	282	// fCurrentBufferIdx = fNavigateBufferIdx = newIdx;
	283
	284	// return newIdx;
	285	// }
	286
	287	// //_______________________________________________________________
	288	// Int_t AliEveEventBuffer::NavigateEventBufferFwd() {
	289	// // see header file for class documentation
	290
	291	// // -- reached the top of the buffer
	292	// if ( fNavigateBufferIdx == fBufferTopIdx )
	293	// return -1;
	294
	295	// Int_t newIdx = fNavigateBufferIdx + 1;
	296	// if ( newIdx == BUFFERSIZE )
	297	// newIdx = 0;
	298
	299	// fCurrentBufferIdx = fNavigateBufferIdx = newIdx;
	300
	301	// return newIdx;
	302	// }
	303
	304	// void AliEveEventBuffer::MonitorBuffer() {
	305	// //See header file for documentation
	306	// if( GetNAvailableEvents() < 10) {
	307	// StopBufferChecker();
	308	// StartLoop();
	309	// }
	310	// }
	311
	312	// void AliEveEventBuffer::StartLoop() {
	313	// //See header file for documentation
	314	// fTimer->Start(2000);
	315	// }
	316	// void AliEveEventBuffer::StopLoop() {
	317	// //See header file for documentation
	318	// fTimer->Stop();
	319	// }
	320
	321	// void AliEveEventBuffer::StartBufferChecker() {
	322	// //See header file for documentation
	323	// fBufferTimer->Start(2000);
	324	// }
	325	// void AliEveEventBuffer::StopBufferChecker() {
	326	// //See header file for documentation
	327	// fBufferTimer->Stop();
	328	// }
	329
	330	// AliESDEvent * GetNextEvent() {
	331
	332	// tree->GetEntry(fEvent++);
	333
	334	// AliESDEvent * event = new AliESDEvent();
	335	// event->ReadFromTree(fTree);
	336	// if (event) {
	337	// return event;
	338	// } else {
	339	// cout << "error getting event" << endl;
	340	// return NULL;
	341	// }
	342	// }