detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-22 03:40:04 +02:00
Code Issues Actions Packages Releases Activity

in between

Browse Source
This commit is contained in:
Dhanya Maliakal 2016-08-24 16:23:43 +02:00
parent f17a2ba2b8
commit e9b7a11cf6
2 changed files with 122 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
slsReceiverSoftware/include/UDPStandardImplementation.h
View File

@ -348,12 +348,11 @@ private:
* Also copies carryovers from previous frame in front of buffer (gotthard and moench) * Also copies carryovers from previous frame in front of buffer (gotthard and moench)
* For eiger, it ignores packets less than onePacketSize * For eiger, it ignores packets less than onePacketSize
* @param ithread listening thread index * @param ithread listening thread index
* @param lSize number of bytes to listen to
* @param cSize number of bytes carried on from previous buffer * @param cSize number of bytes carried on from previous buffer
* @param temp temporary storage of previous buffer * @param temp temporary storage of previous buffer
* @return the number of bytes actually received * @return the number of bytes actually received
*/ */
int prepareAndListenBuffer(int ithread, int lSize, int cSize, char* temp); int prepareAndListenBuffer(int ithread, int cSize, char* temp);
/** /**
* Called by startListening * Called by startListening
@ -380,9 +379,10 @@ private:
* @param ithread listening thread index * @param ithread listening thread index
* @param cSize number of bytes carried over to the next buffer to reunite with split frame * @param cSize number of bytes carried over to the next buffer to reunite with split frame
* @param temp temporary buffer to store the split frame * @param temp temporary buffer to store the split frame
* @param rc number of bytes received
* @return packet count * @return packet count
*/ */
uint32_t processListeningBuffer(int ithread, int cSize,char* temp); uint32_t processListeningBuffer(int ithread, int &cSize,char* temp, int rc);
/** /**
* Thread started which writes packets to file. * Thread started which writes packets to file.
@ -415,7 +415,7 @@ private:
* @param ithread writing thread index * @param ithread writing thread index
* @param wbuffer writing buffer popped out from FIFO * @param wbuffer writing buffer popped out from FIFO
*/ */
void stopWriting(int ithread, char* wbuffer[]); void stopWriting(int ithread, char* wbuffer);
/** /**
* Called by processWritingBuffer and processWritingBufferPacketByPacket * Called by processWritingBuffer and processWritingBufferPacketByPacket
@ -425,7 +425,7 @@ private:
* @param wbuffer writing buffer popped out from FIFO * @param wbuffer writing buffer popped out from FIFO
* @param npackets number of packets * @param npackets number of packets
*/ */
void handleWithoutDataCompression(int ithread, char* wbuffer[],uint32_t npackets); void handleWithoutDataCompression(int ithread, char* wbuffer,uint32_t npackets);
/** /**
* Calle by handleWithoutDataCompression * Calle by handleWithoutDataCompression
@ -492,9 +492,6 @@ private:
#endif #endif
//**detector parameters*** //**detector parameters***
/** Size of 1 Frame including headers */
int frameSize;
/** Size of 1 buffer processed at a time */ /** Size of 1 buffer processed at a time */
int bufferSize; int bufferSize;
@ -529,8 +526,8 @@ private:
/** Complete File name */ /** Complete File name */
char completeFileName[MAX_NUMBER_OF_WRITER_THREADS][MAX_STR_LENGTH]; char completeFileName[MAX_NUMBER_OF_WRITER_THREADS][MAX_STR_LENGTH];
/** Maximum Packets Per File **/ /** Maximum Frames Per File **/
int maxPacketsPerFile; int maxFramesPerFile;
/** If file created successfully for all Writer Threads */ /** If file created successfully for all Writer Threads */
bool fileCreateSuccess; bool fileCreateSuccess;
@ -545,7 +542,7 @@ private:
uint64_t startAcquisitionIndex; uint64_t startAcquisitionIndex;
/** Frame index at start of each real time acquisition (eg. for each scan) */ /** Frame index at start of each real time acquisition (eg. for each scan) */
uint64_t startFrameIndex[MAX_NUMBER_OF_WRITER_THREADS]; uint64_t startFrameIndex;
/** Actual current frame index of each time acquisition (eg. for each scan) */ /** Actual current frame index of each time acquisition (eg. for each scan) */
uint64_t frameIndex[MAX_NUMBER_OF_WRITER_THREADS]; uint64_t frameIndex[MAX_NUMBER_OF_WRITER_THREADS];
@ -577,7 +574,7 @@ private:
uint32_t numMissingPackets[MAX_NUMBER_OF_WRITER_THREADS]; uint32_t numMissingPackets[MAX_NUMBER_OF_WRITER_THREADS];
/** Total Number of Missing Packets in acquisition*/ /** Total Number of Missing Packets in acquisition*/
uint32_t numTotMissingPackets[MAX_NUMBER_OF_WRITER_THREADS]; uint32_t numTotMissingPackets;
/** Number of Missing Packets in file */ /** Number of Missing Packets in file */
uint32_t numTotMissingPacketsInFile[MAX_NUMBER_OF_WRITER_THREADS]; uint32_t numTotMissingPacketsInFile[MAX_NUMBER_OF_WRITER_THREADS];

229
slsReceiverSoftware/src/UDPStandardImplementation.cpp
View File

@ -128,7 +128,6 @@ void UDPStandardImplementation::initializeMembers(){
FILE_LOG(logDEBUG) << "Info: Initializing members"; FILE_LOG(logDEBUG) << "Info: Initializing members";
//***detector parameters*** //***detector parameters***
frameSize = 0;
bufferSize = 0; bufferSize = 0;
onePacketSize = 0; onePacketSize = 0;
oneDataSize = 0; oneDataSize = 0;
@ -149,18 +148,18 @@ void UDPStandardImplementation::initializeMembers(){
strcpy(fileHeader[i],""); strcpy(fileHeader[i],"");
sfilefd[i] = NULL; sfilefd[i] = NULL;
} }
maxPacketsPerFile = 0; maxFramesPerFile = 0;
fileCreateSuccess = false; fileCreateSuccess = false;
//***acquisition indices parameters*** //***acquisition indices parameters***
startAcquisitionIndex = 0; startAcquisitionIndex = 0;
acqStarted = false; acqStarted = false;
startFrameIndex = 0;
for(int i = 0; i < MAX_NUMBER_OF_LISTENING_THREADS; ++i){ for(int i = 0; i < MAX_NUMBER_OF_LISTENING_THREADS; ++i){
startFrameIndex[i] = 0;
measurementStarted[i] = false; measurementStarted[i] = false;
totalListeningFrameCount[i] = 0; totalListeningFrameCount[i] = 0;
} }
numTotMissingPackets = 0;
for(int i=0; i<MAX_NUMBER_OF_WRITER_THREADS; i++){ for(int i=0; i<MAX_NUMBER_OF_WRITER_THREADS; i++){
frameIndex[i] = 0; frameIndex[i] = 0;
currentFrameNumber[i] = 0; currentFrameNumber[i] = 0;
@ -168,7 +167,6 @@ void UDPStandardImplementation::initializeMembers(){
lastFrameIndex[i] = 0; lastFrameIndex[i] = 0;
packetsInFile[i] = 0; packetsInFile[i] = 0;
numMissingPackets[i] = 0; numMissingPackets[i] = 0;
numTotMissingPackets[i] = 0;
numTotMissingPacketsInFile[i] = 0; numTotMissingPacketsInFile[i] = 0;
} }
@ -304,9 +302,6 @@ int UDPStandardImplementation::setupFifoStructure(){
// fifo depth // fifo depth
uint32_t oldFifoSize = fifoSize; uint32_t oldFifoSize = fifoSize;
if(myDetectorType == EIGER)
fifoSize = fifoDepth * packetsPerFrame;//listens to 1 packet at a time and size depends on packetsperframe
else
fifoSize = fifoDepth; fifoSize = fifoDepth;
//reduce fifo depth if > 1 numberofJobsPerBuffer //reduce fifo depth if > 1 numberofJobsPerBuffer
@ -338,10 +333,8 @@ int UDPStandardImplementation::setupFifoStructure(){
fifoFree[i]->pop(buffer[i]); fifoFree[i]->pop(buffer[i]);
//cprintf(BLUE,"FifoFree[%d]: value:%d, pop 0x%x\n",i,fifoFree[i]->getSemValue(),(void*)(buffer[i])); //cprintf(BLUE,"FifoFree[%d]: value:%d, pop 0x%x\n",i,fifoFree[i]->getSemValue(),(void*)(buffer[i]));
} }
#ifdef DEBUG5
cprintf(BLUE,"Info: %d fifostructure popped from fifofree %p\n", i, (void*)(buffer[i]));
#endif
delete fifoFree[i]; delete fifoFree[i];
fifoFree[i] = NULL;
} }
if(fifo[i]){ if(fifo[i]){
while(!fifo[i]->isEmpty()){ while(!fifo[i]->isEmpty()){
@ -349,8 +342,12 @@ int UDPStandardImplementation::setupFifoStructure(){
//cprintf(CYAN,"Fifo[%d]: value:%d, pop 0x%x\n",i,fifo[i]->getSemValue(),(void*)(buffer[i])); //cprintf(CYAN,"Fifo[%d]: value:%d, pop 0x%x\n",i,fifo[i]->getSemValue(),(void*)(buffer[i]));
} }
delete fifo[i]; delete fifo[i];
fifo[i] = NULL;
}
if(mem0[i]){
free(mem0[i]);
mem0[i] = NULL;
} }
if(mem0[i]) free(mem0[i]);
//creating //creating
fifoFree[i] = new CircularFifo<char>(fifoSize); fifoFree[i] = new CircularFifo<char>(fifoSize);
@ -469,22 +466,20 @@ void UDPStandardImplementation::setShortFrameEnable(const int i){
shortFrameEnable = i; shortFrameEnable = i;
if(shortFrameEnable!=-1){ if(shortFrameEnable!=-1){
frameSize = GOTTHARD_SHORT_BUFFER_SIZE;
bufferSize = GOTTHARD_SHORT_BUFFER_SIZE; bufferSize = GOTTHARD_SHORT_BUFFER_SIZE;
onePacketSize = GOTTHARD_SHORT_BUFFER_SIZE; onePacketSize = GOTTHARD_SHORT_BUFFER_SIZE;
oneDataSize = GOTTHARD_SHORT_DATABYTES; oneDataSize = GOTTHARD_SHORT_DATABYTES;
maxPacketsPerFile = SHORT_MAX_FRAMES_PER_FILE * GOTTHARD_SHORT_PACKETS_PER_FRAME; maxFramesPerFile = SHORT_MAX_FRAMES_PER_FILE;
packetsPerFrame = GOTTHARD_SHORT_PACKETS_PER_FRAME; packetsPerFrame = GOTTHARD_SHORT_PACKETS_PER_FRAME;
frameIndexMask = GOTTHARD_SHORT_FRAME_INDEX_MASK; frameIndexMask = GOTTHARD_SHORT_FRAME_INDEX_MASK;
frameIndexOffset = GOTTHARD_SHORT_FRAME_INDEX_OFFSET; frameIndexOffset = GOTTHARD_SHORT_FRAME_INDEX_OFFSET;
packetIndexMask = GOTTHARD_SHORT_PACKET_INDEX_MASK; packetIndexMask = GOTTHARD_SHORT_PACKET_INDEX_MASK;
}else{ }else{
frameSize = GOTTHARD_BUFFER_SIZE;
bufferSize = GOTTHARD_BUFFER_SIZE; bufferSize = GOTTHARD_BUFFER_SIZE;
onePacketSize = GOTTHARD_ONE_PACKET_SIZE; onePacketSize = GOTTHARD_ONE_PACKET_SIZE;
oneDataSize = GOTTHARD_ONE_DATA_SIZE; oneDataSize = GOTTHARD_ONE_DATA_SIZE;
maxPacketsPerFile = MAX_FRAMES_PER_FILE * GOTTHARD_PACKETS_PER_FRAME; maxFramesPerFile = MAX_FRAMES_PER_FILE;
packetsPerFrame = GOTTHARD_PACKETS_PER_FRAME; packetsPerFrame = GOTTHARD_PACKETS_PER_FRAME;
frameIndexMask = GOTTHARD_FRAME_INDEX_MASK; frameIndexMask = GOTTHARD_FRAME_INDEX_MASK;
frameIndexOffset = GOTTHARD_FRAME_INDEX_OFFSET; frameIndexOffset = GOTTHARD_FRAME_INDEX_OFFSET;
@ -517,7 +512,6 @@ int UDPStandardImplementation::setAcquisitionPeriod(const uint64_t i){
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG) << __AT__ << " called";
acquisitionPeriod = i; acquisitionPeriod = i;
if((myDetectorType == GOTTHARD) && (myDetectorType == MOENCH))
if(setupFifoStructure() == FAIL) if(setupFifoStructure() == FAIL)
return FAIL; return FAIL;
@ -531,7 +525,6 @@ int UDPStandardImplementation::setNumberOfFrames(const uint64_t i){
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG) << __AT__ << " called";
numberOfFrames = i; numberOfFrames = i;
if((myDetectorType == GOTTHARD) && (myDetectorType == MOENCH))
if(setupFifoStructure() == FAIL) if(setupFifoStructure() == FAIL)
return FAIL; return FAIL;
@ -551,12 +544,11 @@ int UDPStandardImplementation::setDynamicRange(const uint32_t i){
if(myDetectorType == EIGER){ if(myDetectorType == EIGER){
//set parameters depending on new dynamic range. //set parameters depending on new dynamic range.
packetsPerFrame = (tengigaEnable ? EIGER_TEN_GIGA_CONSTANT : EIGER_ONE_GIGA_CONSTANT) packetsPerFrame = (tengigaEnable ? EIGER_TEN_GIGA_CONSTANT : EIGER_ONE_GIGA_CONSTANT) * dynamicRange;
* dynamicRange * EIGER_MAX_PORTS; bufferSize = onePacketSize * packetsPerFrame;
frameSize = onePacketSize * packetsPerFrame;
maxPacketsPerFile = EIGER_MAX_FRAMES_PER_FILE * packetsPerFrame;
updateFileHeader(); for(int i=0; i<MAX_NUMBER_OF_WRITER_THREADS; i++)
updateFileHeader(i);
//new dynamic range, then restart threads and resetup fifo structure //new dynamic range, then restart threads and resetup fifo structure
if(oldDynamicRange != dynamicRange){ if(oldDynamicRange != dynamicRange){
@ -564,7 +556,7 @@ int UDPStandardImplementation::setDynamicRange(const uint32_t i){
//gui buffer //gui buffer
for(int i=0;i<numberofWriterThreads;i++){ for(int i=0;i<numberofWriterThreads;i++){
if(latestData[i]){delete[] latestData[i]; latestData[i] = NULL;} if(latestData[i]){delete[] latestData[i]; latestData[i] = NULL;}
latestData[i] = new char[frameSize]; latestData[i] = new char[bufferSize];
} }
//restructure fifo //restructure fifo
numberofJobsPerBuffer = -1; numberofJobsPerBuffer = -1;
@ -601,20 +593,16 @@ int UDPStandardImplementation::setTenGigaEnable(const bool b){
onePacketSize = EIGER_ONE_GIGA_ONE_PACKET_SIZE; onePacketSize = EIGER_ONE_GIGA_ONE_PACKET_SIZE;
oneDataSize = EIGER_ONE_GIGA_ONE_DATA_SIZE; oneDataSize = EIGER_ONE_GIGA_ONE_DATA_SIZE;
} }
frameSize = onePacketSize * packetsPerFrame; bufferSize = onePacketSize * packetsPerFrame;
bufferSize = onePacketSize;
maxPacketsPerFile = EIGER_MAX_FRAMES_PER_FILE * packetsPerFrame;
footerOffset = EIGER_PACKET_HEADER_SIZE + oneDataSize; footerOffset = EIGER_PACKET_HEADER_SIZE + oneDataSize;
FILE_LOG(logDEBUG) << dec << FILE_LOG(logDEBUG) << dec <<
"packetsPerFrame:" << packetsPerFrame << "packetsPerFrame:" << packetsPerFrame <<
"\nonePacketSize:" << onePacketSize << "\nonePacketSize:" << onePacketSize <<
"\noneDataSize:" << oneDataSize << "\noneDataSize:" << oneDataSize <<
"\nframesize:" << frameSize << "\nbufferSize:" << bufferSize;
"\nbufferSize:" << bufferSize <<
"\nmaxPacketsPerFile:" << maxPacketsPerFile;
for(int i=0; i<MAX_NUMBER_OF_WRITER_THREADS; i++)
updateFileHeader(); updateFileHeader(i);
//new enable, then restart threads and resetup fifo structure //new enable, then restart threads and resetup fifo structure
if(oldTenGigaEnable != tengigaEnable){ if(oldTenGigaEnable != tengigaEnable){
@ -622,7 +610,7 @@ int UDPStandardImplementation::setTenGigaEnable(const bool b){
//gui buffer //gui buffer
for(int i=0;i<numberofWriterThreads;i++){ for(int i=0;i<numberofWriterThreads;i++){
if(latestData[i]){delete[] latestData[i]; latestData[i] = NULL;} if(latestData[i]){delete[] latestData[i]; latestData[i] = NULL;}
latestData[i] = new char[frameSize]; latestData[i] = new char[bufferSize];
} }
//restructure fifo //restructure fifo
@ -690,12 +678,11 @@ int UDPStandardImplementation::setDetectorType(const detectorType d){
packetsPerFrame = GOTTHARD_PACKETS_PER_FRAME; packetsPerFrame = GOTTHARD_PACKETS_PER_FRAME;
onePacketSize = GOTTHARD_ONE_PACKET_SIZE; onePacketSize = GOTTHARD_ONE_PACKET_SIZE;
oneDataSize = GOTTHARD_ONE_DATA_SIZE; oneDataSize = GOTTHARD_ONE_DATA_SIZE;
frameSize = GOTTHARD_BUFFER_SIZE;
bufferSize = GOTTHARD_BUFFER_SIZE; bufferSize = GOTTHARD_BUFFER_SIZE;
frameIndexMask = GOTTHARD_FRAME_INDEX_MASK; frameIndexMask = GOTTHARD_FRAME_INDEX_MASK;
frameIndexOffset = GOTTHARD_FRAME_INDEX_OFFSET; frameIndexOffset = GOTTHARD_FRAME_INDEX_OFFSET;
packetIndexMask = GOTTHARD_PACKET_INDEX_MASK; packetIndexMask = GOTTHARD_PACKET_INDEX_MASK;
maxPacketsPerFile = MAX_FRAMES_PER_FILE * GOTTHARD_PACKETS_PER_FRAME; maxFramesPerFile = MAX_FRAMES_PER_FILE;
fifoSize = GOTTHARD_FIFO_SIZE; fifoSize = GOTTHARD_FIFO_SIZE;
fifoDepth = GOTTHARD_FIFO_SIZE; fifoDepth = GOTTHARD_FIFO_SIZE;
//footerOffset = Not applicable; //footerOffset = Not applicable;
@ -704,12 +691,11 @@ int UDPStandardImplementation::setDetectorType(const detectorType d){
packetsPerFrame = PROPIX_PACKETS_PER_FRAME; packetsPerFrame = PROPIX_PACKETS_PER_FRAME;
onePacketSize = PROPIX_ONE_PACKET_SIZE; onePacketSize = PROPIX_ONE_PACKET_SIZE;
//oneDataSize = Not applicable; //oneDataSize = Not applicable;
frameSize = PROPIX_BUFFER_SIZE;
bufferSize = PROPIX_BUFFER_SIZE; bufferSize = PROPIX_BUFFER_SIZE;
frameIndexMask = PROPIX_FRAME_INDEX_MASK; frameIndexMask = PROPIX_FRAME_INDEX_MASK;
frameIndexOffset = PROPIX_FRAME_INDEX_OFFSET; frameIndexOffset = PROPIX_FRAME_INDEX_OFFSET;
packetIndexMask = PROPIX_PACKET_INDEX_MASK; packetIndexMask = PROPIX_PACKET_INDEX_MASK;
maxPacketsPerFile = MAX_FRAMES_PER_FILE * PROPIX_PACKETS_PER_FRAME; maxFramesPerFile = MAX_FRAMES_PER_FILE;
fifoSize = PROPIX_FIFO_SIZE; fifoSize = PROPIX_FIFO_SIZE;
fifoDepth = PROPIX_FIFO_SIZE; fifoDepth = PROPIX_FIFO_SIZE;
//footerOffset = Not applicable; //footerOffset = Not applicable;
@ -718,27 +704,25 @@ int UDPStandardImplementation::setDetectorType(const detectorType d){
packetsPerFrame = MOENCH_PACKETS_PER_FRAME; packetsPerFrame = MOENCH_PACKETS_PER_FRAME;
onePacketSize = MOENCH_ONE_PACKET_SIZE; onePacketSize = MOENCH_ONE_PACKET_SIZE;
oneDataSize = MOENCH_ONE_DATA_SIZE; oneDataSize = MOENCH_ONE_DATA_SIZE;
frameSize = MOENCH_BUFFER_SIZE;
bufferSize = MOENCH_BUFFER_SIZE; bufferSize = MOENCH_BUFFER_SIZE;
frameIndexMask = MOENCH_FRAME_INDEX_MASK; frameIndexMask = MOENCH_FRAME_INDEX_MASK;
frameIndexOffset = MOENCH_FRAME_INDEX_OFFSET; frameIndexOffset = MOENCH_FRAME_INDEX_OFFSET;
packetIndexMask = MOENCH_PACKET_INDEX_MASK; packetIndexMask = MOENCH_PACKET_INDEX_MASK;
maxPacketsPerFile = MOENCH_MAX_FRAMES_PER_FILE * MOENCH_PACKETS_PER_FRAME; maxFramesPerFile = MOENCH_MAX_FRAMES_PER_FILE;
fifoSize = MOENCH_FIFO_SIZE; fifoSize = MOENCH_FIFO_SIZE;
fifoDepth = MOENCH_FIFO_SIZE; fifoDepth = MOENCH_FIFO_SIZE;
//footerOffset = Not applicable; //footerOffset = Not applicable;
break; break;
case EIGER: case EIGER:
//assuming 1G in the beginning //assuming 1G in the beginning
packetsPerFrame = EIGER_ONE_GIGA_CONSTANT * dynamicRange * EIGER_MAX_PORTS; packetsPerFrame = EIGER_ONE_GIGA_CONSTANT * dynamicRange;
onePacketSize = EIGER_ONE_GIGA_ONE_PACKET_SIZE; onePacketSize = EIGER_ONE_GIGA_ONE_PACKET_SIZE;
oneDataSize = EIGER_ONE_GIGA_ONE_DATA_SIZE; oneDataSize = EIGER_ONE_GIGA_ONE_DATA_SIZE;
frameSize = onePacketSize * packetsPerFrame; bufferSize = onePacketSize * packetsPerFrame;
bufferSize = onePacketSize;
frameIndexMask = EIGER_FRAME_INDEX_MASK; frameIndexMask = EIGER_FRAME_INDEX_MASK;
frameIndexOffset = EIGER_FRAME_INDEX_OFFSET; frameIndexOffset = EIGER_FRAME_INDEX_OFFSET;
packetIndexMask = EIGER_PACKET_INDEX_MASK; packetIndexMask = EIGER_PACKET_INDEX_MASK;
maxPacketsPerFile = EIGER_MAX_FRAMES_PER_FILE * packetsPerFrame; maxFramesPerFile = EIGER_MAX_FRAMES_PER_FILE;
fifoSize = EIGER_FIFO_SIZE; fifoSize = EIGER_FIFO_SIZE;
fifoDepth = EIGER_FIFO_SIZE; fifoDepth = EIGER_FIFO_SIZE;
footerOffset = EIGER_PACKET_HEADER_SIZE + oneDataSize; footerOffset = EIGER_PACKET_HEADER_SIZE + oneDataSize;
@ -747,12 +731,11 @@ int UDPStandardImplementation::setDetectorType(const detectorType d){
packetsPerFrame = JCTB_PACKETS_PER_FRAME; packetsPerFrame = JCTB_PACKETS_PER_FRAME;
onePacketSize = JCTB_ONE_PACKET_SIZE; onePacketSize = JCTB_ONE_PACKET_SIZE;
//oneDataSize = Not applicable; //oneDataSize = Not applicable;
frameSize = JCTB_BUFFER_SIZE;
bufferSize = JCTB_BUFFER_SIZE; bufferSize = JCTB_BUFFER_SIZE;
frameIndexMask = JCTB_FRAME_INDEX_MASK; frameIndexMask = JCTB_FRAME_INDEX_MASK;
frameIndexOffset = JCTB_FRAME_INDEX_OFFSET; frameIndexOffset = JCTB_FRAME_INDEX_OFFSET;
packetIndexMask = JCTB_PACKET_INDEX_MASK; packetIndexMask = JCTB_PACKET_INDEX_MASK;
maxPacketsPerFile = JFCTB_MAX_FRAMES_PER_FILE * JCTB_PACKETS_PER_FRAME; maxFramesPerFile = JFCTB_MAX_FRAMES_PER_FILE;
fifoSize = JCTB_FIFO_SIZE; fifoSize = JCTB_FIFO_SIZE;
fifoDepth = JCTB_FIFO_SIZE; fifoDepth = JCTB_FIFO_SIZE;
//footerOffset = Not applicable; //footerOffset = Not applicable;
@ -761,12 +744,11 @@ int UDPStandardImplementation::setDetectorType(const detectorType d){
packetsPerFrame = JFRAU_PACKETS_PER_FRAME; packetsPerFrame = JFRAU_PACKETS_PER_FRAME;
onePacketSize = JFRAU_ONE_PACKET_SIZE; onePacketSize = JFRAU_ONE_PACKET_SIZE;
oneDataSize = JFRAU_DATA_BYTES; oneDataSize = JFRAU_DATA_BYTES;
frameSize = JFRAU_BUFFER_SIZE;
bufferSize = JFRAU_BUFFER_SIZE; bufferSize = JFRAU_BUFFER_SIZE;
frameIndexMask = JFRAU_FRAME_INDEX_MASK; frameIndexMask = JFRAU_FRAME_INDEX_MASK;
frameIndexOffset = JFRAU_FRAME_INDEX_OFFSET; frameIndexOffset = JFRAU_FRAME_INDEX_OFFSET;
packetIndexMask = JFRAU_PACKET_INDEX_MASK; packetIndexMask = JFRAU_PACKET_INDEX_MASK;
maxPacketsPerFile = JFRAU_MAX_FRAMES_PER_FILE * JFRAU_PACKETS_PER_FRAME; maxFramesPerFile = JFRAU_MAX_FRAMES_PER_FILE;
fifoDepth = JFRAU_FIFO_SIZE; fifoDepth = JFRAU_FIFO_SIZE;
fifoSize = JFRAU_FIFO_SIZE; fifoSize = JFRAU_FIFO_SIZE;
//footerOffset = Not applicable; //footerOffset = Not applicable;
@ -798,7 +780,7 @@ int UDPStandardImplementation::setDetectorType(const detectorType d){
for(int i=0; i<MAX_NUMBER_OF_WRITER_THREADS; i++){ for(int i=0; i<MAX_NUMBER_OF_WRITER_THREADS; i++){
if(latestData[i]) {delete[] latestData; latestData = NULL;} if(latestData[i]) {delete[] latestData; latestData = NULL;}
guiData[i] = NULL; guiData[i] = NULL;
latestData[i] = new char[frameSize]; latestData[i] = new char[bufferSize];
} }
@ -849,16 +831,17 @@ int UDPStandardImplementation::startReceiver(char *c){
} }
//for every measurement //for every measurement
pthread_mutex_lock(&progressMutex);
startFrameIndex = 0;
pthread_mutex_unlock(&progressMutex);
for(int i=0;i<numberofListeningThreads;i++){ for(int i=0;i<numberofListeningThreads;i++){
startFrameIndex[i] = 0;
measurementStarted[i] = false; measurementStarted[i] = false;
totalListeningFrameCount[i] = 0; totalListeningFrameCount[i] = 0;
} }
numTotMissingPackets = 0;
for(int i=0;i<numberofWriterThreads;i++){ for(int i=0;i<numberofWriterThreads;i++){
frameIndex[i] = 0; frameIndex[i] = 0;
numMissingPackets[i] = 0; numMissingPackets[i] = 0;
numTotMissingPackets[i] = 0;
numTotMissingPacketsInFile[i] = 0; numTotMissingPacketsInFile[i] = 0;
//reset file parameters //reset file parameters
packetsInFile[i] = 0; packetsInFile[i] = 0;
@ -886,11 +869,10 @@ int UDPStandardImplementation::startReceiver(char *c){
//Print Receiver Configuration //Print Receiver Configuration
if(myDetectorType != EIGER){ if(myDetectorType != EIGER)
FILE_LOG(logINFO) << "Data Compression has been " << stringEnable(dataCompressionEnable); FILE_LOG(logINFO) << "Data Compression has been " << stringEnable(dataCompressionEnable);
FILE_LOG(logINFO) << "Number of Jobs Per Buffer: " << numberofJobsPerBuffer; FILE_LOG(logINFO) << "Number of Jobs Per Buffer: " << numberofJobsPerBuffer;
FILE_LOG(logINFO) << "Max Packets Per File:" << maxPacketsPerFile; FILE_LOG(logINFO) << "Max Frames Per File:" << maxFramesPerFile;
}
if(FrameToGuiFrequency) if(FrameToGuiFrequency)
FILE_LOG(logINFO) << "Frequency of frames sent to gui: " << FrameToGuiFrequency; FILE_LOG(logINFO) << "Frequency of frames sent to gui: " << FrameToGuiFrequency;
else else
@ -1066,7 +1048,7 @@ void UDPStandardImplementation::readFrame(int ithread, char* c,char** raw, uint6
//copy data and filename //copy data and filename
strcpy(c,guiFileName[ithread]); strcpy(c,guiFileName[ithread]);
startAcq = startAcquisitionIndex; startAcq = startAcquisitionIndex;
startFrame = startFrameIndex[ithread]; startFrame = startFrameIndex;
//gui data not copied yet //gui data not copied yet
@ -1121,7 +1103,7 @@ void UDPStandardImplementation::closeFile(int ithread){
#if (defined(MYROOT1) && defined(ALLFILE_DEBUG)) || !defined(MYROOT1) #if (defined(MYROOT1) && defined(ALLFILE_DEBUG)) || !defined(MYROOT1)
if(sfilefd[0]){ if(sfilefd[0]){
#ifdef DEBUG4 #ifdef DEBUG4
FILE_LOG(logDEBUG4) << "sfield: " << (int)sfilefd[i]; FILE_LOG(logDEBUG4) << "sfilefd: " << (int)sfilefd[i];
#endif #endif
fclose(sfilefd[0]); fclose(sfilefd[0]);
sfilefd[0] = NULL; sfilefd[0] = NULL;
@ -1453,7 +1435,7 @@ int UDPStandardImplementation::createNewFile(int ithread){
}else{ }else{
//Assumption for startFrameindex usign ithread: datacompression never enters here and therefore is always same number of listening and writing threads to use ithread //Assumption for startFrameindex usign ithread: datacompression never enters here and therefore is always same number of listening and writing threads to use ithread
if (previousFrameNumber[ithread] == -1) if (previousFrameNumber[ithread] == -1)
previousFrameNumber[ithread] = startFrameIndex[ithread]-1; previousFrameNumber[ithread] = startFrameIndex-1;
cout << completeFileName[ithread] cout << completeFileName[ithread]
<< "\tPacket Loss: " << setw(4)<<fixed << setprecision(4) << dec << << "\tPacket Loss: " << setw(4)<<fixed << setprecision(4) << dec <<
@ -1545,27 +1527,25 @@ void UDPStandardImplementation::startListening(){
threadStarted = 1; threadStarted = 1;
//variable definitions
int listenSize = 0; //listen to only 1 packet
uint32_t rc; //size of buffer received in bytes uint32_t rc; //size of buffer received in bytes
//split frames //split frames for data compression
int carryonBufferSize; //from previous buffer to keep frames together in a buffer int carryonBufferSize; //from previous buffer to keep frames together in a buffer
char* tempBuffer = NULL; //temporary buffer to store split frames char* tempBuffer = NULL; //temporary buffer to store split frames
/* outer loop - loops once for each acquisition */ /* outer loop - loops once for each acquisition */
//infinite loop, exited only to change dynamic range, 10G parameters etc (then recreated again) //infinite loop, exited only to change dynamic range, 10G parameters etc (then recreated again)
while(true){ while(true){
//reset parameters before acquisition //compression variables reset before acquisition
carryonBufferSize = 0; carryonBufferSize = 0;
if(myDetectorType != EIGER){ if(dataCompressionEnable){
listenSize = bufferSize * numberofJobsPerBuffer; //listen to more than 1 packet
if(tempBuffer!=NULL){delete []tempBuffer;tempBuffer=NULL;} if(tempBuffer!=NULL){delete []tempBuffer;tempBuffer=NULL;}
tempBuffer = new char[onePacketSize * (packetsPerFrame - 1)]; //store maximum of 1 packets less in a frame tempBuffer = new char[onePacketSize * (packetsPerFrame - 1)]; //store maximum of 1 packets less in a frame
} }
/* inner loop - loop for each buffer */ /* inner loop - loop for each buffer */
//until mask unset (udp sockets shut down by client) //until mask reset (udp sockets shut down by client)
while((1 << ithread) & listeningThreadsMask){ while((1 << ithread) & listeningThreadsMask){
@ -1583,14 +1563,20 @@ void UDPStandardImplementation::startListening(){
cprintf(YELLOW,"Listening_Thread %d :Listener popped from fifofree %p\n", ithread, (void*)(buffer[ithread])); cprintf(YELLOW,"Listening_Thread %d :Listener popped from fifofree %p\n", ithread, (void*)(buffer[ithread]));
#endif #endif
pthread_mutex_lock(&udpSocketMutex[ithread]);
//udpsocket doesnt exist //udpsocket doesnt exist
if(udpSocket[ithread] == NULL){ if(udpSocket[ithread] == NULL){
FILE_LOG(logERROR) << "Listening_Thread " << ithread << ": UDP Socket not created or shut down earlier"; FILE_LOG(logERROR) << "Listening_Thread " << ithread << ": UDP Socket not created or shut down earlier";
stopListening(ithread,0); stopListening(ithread,0);
pthread_mutex_unlock(&udpSocketMutex[ithread]);
continue; continue;
} }
rc = prepareAndListenBuffer(ithread, listenSize, carryonBufferSize, tempBuffer); rc = prepareAndListenBuffer(ithread, carryonBufferSize, tempBuffer);
carryonBufferSize = 0;
pthread_mutex_unlock(&udpSocketMutex[ithread]);
//start indices for each start of scan/acquisition //start indices for each start of scan/acquisition
if((!measurementStarted) && (rc > 0)) if((!measurementStarted) && (rc > 0))
@ -1603,10 +1589,10 @@ void UDPStandardImplementation::startListening(){
//write packet count to buffer //write packet count to buffer
if(myDetectorType == EIGER) if(myDetectorType == EIGER)
(*((uint32_t*)(buffer[ithread]))) = 1; (*((uint32_t*)(buffer[ithread]))) = rc/onePacketSize;
//handling split frames and writing packet Count to buffer
else if(dataCompressionEnable)
(*((uint32_t*)(buffer[ithread]))) = processListeningBuffer(ithread, carryonBufferSize, tempBuffer); (*((uint32_t*)(buffer[ithread]))) = processListeningBuffer(ithread, carryonBufferSize, tempBuffer, rc);
//push buffer to FIFO //push buffer to FIFO
@ -1645,24 +1631,17 @@ void UDPStandardImplementation::startListening(){
int UDPStandardImplementation::prepareAndListenBuffer(int ithread, int lSize, int cSize, char* temp){ int UDPStandardImplementation::prepareAndListenBuffer(int ithread, int cSize, char* temp){
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG) << __AT__ << " called";
//listen to UDP packets //carry over from previous buffer
if(cSize) if(cSize) memcpy(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS, temp, cSize);
memcpy(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS, temp, cSize);
pthread_mutex_lock(&udpSocketMutex[ithread]); int receivedSize = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS + cSize, (bufferSize * numberofJobsPerBuffer) - cSize);
int receivedSize = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS + cSize, lSize + cSize);
//throw away packets that is not one packet size //throw away packets that is not one packet size
while(myDetectorType == EIGER && receivedSize != onePacketSize) { while(myDetectorType == EIGER && receivedSize != onePacketSize) {
//need to check status if socket is shut down if(receivedSize != EIGER_HEADER_LENGTH)
if(status == TRANSMITTING)
break;
//print
if(receivedSize != EIGER_HEADER_LENGTH){
cprintf(RED,"Listening_Thread %d: Listened to a weird packet size %d\n",ithread, receivedSize); cprintf(RED,"Listening_Thread %d: Listened to a weird packet size %d\n",ithread, receivedSize);
}
#ifdef DEBUG #ifdef DEBUG
else else
cprintf(BLUE,"Listening_Thread %d: Listened to a header packet\n",ithread); cprintf(BLUE,"Listening_Thread %d: Listened to a header packet\n",ithread);
@ -1670,7 +1649,6 @@ int UDPStandardImplementation::prepareAndListenBuffer(int ithread, int lSize, in
//listen again //listen again
receivedSize = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS); receivedSize = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS);
} }
pthread_mutex_unlock(&udpSocketMutex[ithread]);
totalListeningFrameCount[ithread] += (receivedSize/onePacketSize); totalListeningFrameCount[ithread] += (receivedSize/onePacketSize);
@ -1696,8 +1674,6 @@ int UDPStandardImplementation::prepareAndListenBuffer(int ithread, int lSize, in
} }
} }
#endif #endif
#ifdef DEBUG #ifdef DEBUG
cprintf(BLUE, "Listening_Thread %d : Received bytes: %d. Expected bytes: %d\n", ithread, receivedSize, bufferSize * numberofJobsPerBuffer-cSize); cprintf(BLUE, "Listening_Thread %d : Received bytes: %d. Expected bytes: %d\n", ithread, receivedSize, bufferSize * numberofJobsPerBuffer-cSize);
#endif #endif
@ -1716,18 +1692,18 @@ void UDPStandardImplementation::startFrameIndices(int ithread){
jfrau_packet_header_t* header=0; jfrau_packet_header_t* header=0;
switch(myDetectorType){ switch(myDetectorType){
case EIGER: case EIGER:
startFrameIndex[ithread] = 0; //frame number always resets startFrameIndex = 0; //frame number always resets
break; break;
case JUNGFRAU: case JUNGFRAU:
header = (jfrau_packet_header_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS); header = (jfrau_packet_header_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS);
startFrameIndex[ithread] = (*( (uint32_t*) header->frameNumber))&0xffffff; startFrameIndex = (*( (uint32_t*) header->frameNumber))&0xffffff;
break; break;
default: default:
if(shortFrameEnable < 0){ if(shortFrameEnable < 0){
startFrameIndex[ithread] = (((((uint32_t)(*((uint32_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS))))+1) startFrameIndex = (((((uint32_t)(*((uint32_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS))))+1)
& (frameIndexMask)) >> frameIndexOffset); & (frameIndexMask)) >> frameIndexOffset);
}else{ }else{
startFrameIndex[ithread] = ((((uint32_t)(*((uint32_t*)(buffer[ithread]+HEADER_SIZE_NUM_TOT_PACKETS)))) startFrameIndex = ((((uint32_t)(*((uint32_t*)(buffer[ithread]+HEADER_SIZE_NUM_TOT_PACKETS))))
& (frameIndexMask)) >> frameIndexOffset); & (frameIndexMask)) >> frameIndexOffset);
} }
break; break;
@ -1736,14 +1712,14 @@ void UDPStandardImplementation::startFrameIndices(int ithread){
//start of entire acquisition //start of entire acquisition
if(!acqStarted){ if(!acqStarted){
pthread_mutex_lock(&progressMutex); pthread_mutex_lock(&progressMutex);
startAcquisitionIndex = startFrameIndex[ithread]; startAcquisitionIndex = startFrameIndex;
acqStarted = true; acqStarted = true;
pthread_mutex_unlock(&progressMutex); pthread_mutex_unlock(&progressMutex);
cprintf(BLUE,"Listening_Thread %d: startAcquisitionIndex:%lld\n",ithread,(long long int)startAcquisitionIndex); cprintf(BLUE,"Listening_Thread %d: startAcquisitionIndex:%lld\n",ithread,(long long int)startAcquisitionIndex);
} }
//set start of scan/real time measurement //set start of scan/real time measurement
cprintf(BLUE,"Listening_Thread %d: startFrameIndex: %lld\n", ithread,(long long int)startFrameIndex[ithread]); cprintf(BLUE,"Listening_Thread %d: startFrameIndex: %lld\n", ithread,(long long int)startFrameIndex);
measurementStarted[ithread] = true; measurementStarted[ithread] = true;
} }
@ -1863,13 +1839,13 @@ void UDPStandardImplementation::stopListening(int ithread, int numbytes){
uint32_t UDPStandardImplementation::processListeningBuffer(int ithread, int cSize, char* temp){ uint32_t UDPStandardImplementation::processListeningBuffer(int ithread, int &cSize, char* temp, int rc){
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG) << __AT__ << " called";
int lastPacketOffset; //the offset of the last packet int lastPacketOffset; //the offset of the last packet
uint32_t lastFrameHeader; //frame number of last packet in buffer uint32_t lastFrameHeader; //frame number of last packet in buffer
uint64_t lastFrameHeader64; //frame number of last packet in buffer uint64_t lastFrameHeader64; //frame number of last packet in buffer
uint32_t packetCount = (packetsPerFrame/numberofListeningThreads) * numberofJobsPerBuffer; //packets received uint32_t packetCount = rc;//(packetsPerFrame/numberofListeningThreads) * numberofJobsPerBuffer; //packets received
cSize = 0; //reset size cSize = 0; //reset size
jfrau_packet_header_t* header; jfrau_packet_header_t* header;
@ -2012,9 +1988,10 @@ void UDPStandardImplementation::processWritingBuffer(int ithread){
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG) << __AT__ << " called";
//variable definitions //variable definitions
char* wbuf[numberofListeningThreads]; //buffer popped from FIFO char* wbuf; //buffer popped from FIFO
sfilefd = NULL; //file pointer sfilefd[ithread] = NULL; //file pointer
uint64_t nf; //for compression, number of frames uint64_t nf; //for compression, number of frames
int listenfifoIndex = ithread;
/* outer loop - loops once for each acquisition */ /* outer loop - loops once for each acquisition */
@ -2023,31 +2000,33 @@ void UDPStandardImplementation::processWritingBuffer(int ithread){
//--reset parameters before acquisition //--reset parameters before acquisition
nf = 0; nf = 0;
guiData = latestData; //so that the first frame is always copied guiData[ithread] = latestData[ithread]; //so that the first frame is always copied
if(dataCompressionEnable)
listenfifoIndex = 0; //compression has only one listening thread
/* inner loop - loop for each buffer */ /* inner loop - loop for each buffer */
//until mask unset (udp sockets shut down by client) //until mask unset (udp sockets shut down by client)
while((1 << ithread) & writerThreadsMask){ while((1 << ithread) & writerThreadsMask){
//pop //pop
fifo[0]->pop(wbuf[0]); fifo[listenfifoIndex]->pop(wbuf);
#ifdef EVERYFIFODEBUG #ifdef EVERYFIFODEBUG
if(fifo[0]->getSemValue()>(fifoSize-100)) if(fifo[listenfifoIndex]->getSemValue()>(fifoSize-100))
cprintf(CYAN,"Fifo[%d]: value:%d, pop 0x%x\n",0,fifo[0]->getSemValue(),(void*)(wbuf[0])); cprintf(CYAN,"Fifo[%d]: value:%d, pop 0x%x\n",listenfifoIndex,fifo[listenfifoIndex]->getSemValue(),(void*)(wbuf));
#endif #endif
#ifdef DEBUG5
cprintf(GREEN,"Writing_Thread %d: Popped %p from FIFO %d\n", ithread, (void*)(wbuf[0]),0);
#endif
uint32_t numPackets = (uint32_t)(*((uint32_t*)wbuf[0]));
#ifdef DEBUG4 #ifdef DEBUG4
cprintf(GREEN,"Writing_Thread %d: Number of Packets: %d for FIFO %d\n", ithread, numPackets, 0); cprintf(GREEN,"Writing_Thread %d: Popped %p from FIFO %d\n", ithread, (void*)(wbuf),listenfifoIndex);
#endif
uint32_t numPackets = (uint32_t)(*((uint32_t*)wbuf));
#ifdef DEBUG4
cprintf(GREEN,"Writing_Thread %d: Number of Packets: %d for FIFO %d\n", ithread, numPackets, listenfifoIndex);
#endif #endif
//end of acquisition //end of acquisition
if(numPackets == dummyPacketValue){ if(numPackets == dummyPacketValue){
#ifdef DEBUG3 #ifdef DEBUG4
cprintf(GREEN,"Writing_Thread %d: Dummy frame popped out of FIFO %d",ithread, 0); cprintf(GREEN,"Writing_Thread %d: Dummy frame popped out of FIFO %d",ithread, listenfifoIndex);
#endif #endif
stopWriting(ithread,wbuf); stopWriting(ithread,wbuf);
continue; continue;
@ -2055,9 +2034,11 @@ void UDPStandardImplementation::processWritingBuffer(int ithread){
//process //normal
if(!dataCompressionEnable) if(!dataCompressionEnable)
handleWithoutDataCompression(ithread, wbuf, numPackets); handleWithoutDataCompression(ithread, wbuf, numPackets);
//compression
else{ else{
#if defined(MYROOT1) && defined(ALLFILE_DEBUG) #if defined(MYROOT1) && defined(ALLFILE_DEBUG)
if(npackets > 0) if(npackets > 0)
@ -2145,12 +2126,13 @@ void UDPStandardImplementation::processWritingBufferPacketByPacket(int ithread){
#endif #endif
} }
delete fifoTempFree[i]; delete fifoTempFree[i];
fifoTempFree[i] = NULL;
} }
fifoTempFree[i] = new CircularFifo<char>(MAX_NUM_PACKETS); fifoTempFree[i] = new CircularFifo<char>(MAX_NUM_PACKETS);
} }
for(uint32_t i=0; i<packetsPerFrame; ++i){ for(uint32_t i=0; i<packetsPerFrame; ++i){
if(blankframe[i]){delete [] blankframe[i]; blankframe[i] = 0;} if(blankframe[i]){delete [] blankframe[i]; blankframe[i] = NULL;}
blankframe[i] = new char[onePacketSize]; blankframe[i] = new char[onePacketSize];
//set missing packet to 0xff //set missing packet to 0xff
eiger_packet_header_t* blankframe_header = (eiger_packet_header_t*) blankframe[i]; eiger_packet_header_t* blankframe_header = (eiger_packet_header_t*) blankframe[i];
@ -2223,7 +2205,7 @@ void UDPStandardImplementation::processWritingBufferPacketByPacket(int ithread){
threadFrameNumber[i] = (uint32_t)(*( (uint64_t*) packetBuffer_footer)); threadFrameNumber[i] = (uint32_t)(*( (uint64_t*) packetBuffer_footer));
//last frame read out //last frame read out
lastFrameIndex = threadFrameNumber[i]; lastFrameIndex = threadFrameNumber[i];
threadFrameNumber[i] += (startFrameIndex[ithread] - 1); threadFrameNumber[i] += (startFrameIndex - 1);
//packet number //packet number
currentPacketNumber[i] = *( (uint16_t*) packetBuffer_footer->packetNumber); currentPacketNumber[i] = *( (uint16_t*) packetBuffer_footer->packetNumber);
@ -2338,7 +2320,7 @@ void UDPStandardImplementation::processWritingBufferPacketByPacket(int ithread){
if(fullframe[0] && fullframe[1]){ if(fullframe[0] && fullframe[1]){
currentFrameNumber = presentFrameNumber; currentFrameNumber = presentFrameNumber;
numTotMissingPacketsInFile += numMissingPackets; numTotMissingPacketsInFile += numMissingPackets;
numTotMissingPackets += numMissingPackets; numTotMissingPackets += numMissingPackets;/**requires a lock*/
/* /*
cprintf(CYAN,"**framenum:%lld\n ",(long long int)currentFrameNumber); cprintf(CYAN,"**framenum:%lld\n ",(long long int)currentFrameNumber);
@ -2379,7 +2361,7 @@ void UDPStandardImplementation::processWritingBufferPacketByPacket(int ithread){
//ensuring last packet got is not of some other future frame but of the current one //ensuring last packet got is not of some other future frame but of the current one
eiger_packet_footer_t* wbuf_footer1 = (eiger_packet_footer_t*)(packetBuffer[i] + footerOffset + HEADER_SIZE_NUM_TOT_PACKETS); eiger_packet_footer_t* wbuf_footer1 = (eiger_packet_footer_t*)(packetBuffer[i] + footerOffset + HEADER_SIZE_NUM_TOT_PACKETS);
uint64_t packfnum = (((uint32_t)(*( (uint64_t*) wbuf_footer1)))+(startFrameIndex[ithread] - 1)); uint64_t packfnum = (((uint32_t)(*( (uint64_t*) wbuf_footer1)))+(startFrameIndex - 1));
//to reset to get new frame: not dummy and the last packet //to reset to get new frame: not dummy and the last packet
if((numPackets[i] != dummyPacketValue) && (currentPacketNumber[i] == LAST_PACKET_VALUE) && (packfnum == currentFrameNumber) ) if((numPackets[i] != dummyPacketValue) && (currentPacketNumber[i] == LAST_PACKET_VALUE) && (packfnum == currentFrameNumber) )
@ -2592,25 +2574,24 @@ bool UDPStandardImplementation::popAndCheckEndofAcquisition(int ithread, char* w
void UDPStandardImplementation::stopWriting(int ithread, char* wbuffer[]){ void UDPStandardImplementation::stopWriting(int ithread, char* wbuffer){
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG) << __AT__ << " called";
FILE_LOG(logINFO) << "Writing "<< ithread << ": End of Acquisition"; FILE_LOG(logINFO) << "Writing "<< ithread << ": End of Acquisition";
//free fifo //free fifo
for(int i=0; i<numberofListeningThreads; ++i){ while(!fifoFree[ithread]->push(wbuffer));
while(!fifoFree[i]->push(wbuffer[i]));
#ifdef EVERYFIFODEBUG #ifdef EVERYFIFODEBUG
if(fifoFree[i]->getSemValue()<100) if(fifoFree[ithread]->getSemValue()<100)
cprintf(GREEN,"FifoFree[%d]: value:%d, push 0x%x\n",i,fifoFree[i]->getSemValue(),(void*)(wbuffer[i])); cprintf(GREEN,"FifoFree[%d]: value:%d, push 0x%x\n",ithread,fifoFree[ithread]->getSemValue(),(void*)(wbuffer));
#endif #endif
#ifdef CFIFODEBUG #ifdef CFIFODEBUG
if(i==0) if(ithread==0)
cprintf(CYAN,"Writing_Thread %d: Freeing dummy-end buffer. Pushed into fifofree %p for listener %d\n", ithread,(void*)(wbuffer[i]),i); cprintf(CYAN,"Writing_Thread %d: Freeing dummy-end buffer. Pushed into fifofree %p for listener %d\n", ithread,(void*)(wbuffer),ithread);
else else
cprintf(YELLOW,"Writing_Thread %d: Freeing dummy-end buffer. Pushed into fifofree %p for listener %d\n", ithread,(void*)(wbuffer[i]),i); cprintf(YELLOW,"Writing_Thread %d: Freeing dummy-end buffer. Pushed into fifofree %p for listener %d\n", ithread,(void*)(wbuffer),ithread);
#endif #endif
}
//all threads need to close file, reset mask and exit loop //all threads need to close file, reset mask and exit loop
closeFile(ithread); closeFile(ithread);
@ -2644,7 +2625,7 @@ void UDPStandardImplementation::stopWriting(int ithread, char* wbuffer[]){
//statistics //statistics
FILE_LOG(logINFO) << "Status: Run Finished"; FILE_LOG(logINFO) << "Status: Run Finished";
FILE_LOG(logINFO) << "Last Frame Number Caught:" << lastFrameIndex; FILE_LOG(logINFO) << "Last Frame Number Caught:" << lastFrameIndex[ithread];
if(totalPacketsCaught < ((uint64_t)numberOfFrames*packetsPerFrame)){ if(totalPacketsCaught < ((uint64_t)numberOfFrames*packetsPerFrame)){
cprintf(RED, "Total Missing Packets padded: %d\n",numTotMissingPackets); cprintf(RED, "Total Missing Packets padded: %d\n",numTotMissingPackets);
cprintf(RED, "Total Packets Caught: %lld\n",(long long int)totalPacketsCaught); cprintf(RED, "Total Packets Caught: %lld\n",(long long int)totalPacketsCaught);
@ -2663,7 +2644,7 @@ void UDPStandardImplementation::stopWriting(int ithread, char* wbuffer[]){
void UDPStandardImplementation::handleWithoutDataCompression(int ithread, char* wbuffer[],uint32_t npackets){ void UDPStandardImplementation::handleWithoutDataCompression(int ithread, char* wbuffer,uint32_t npackets){
FILE_LOG(logDEBUG) << __AT__ << " called"; FILE_LOG(logDEBUG) << __AT__ << " called";
@ -2682,7 +2663,7 @@ void UDPStandardImplementation::handleWithoutDataCompression(int ithread, char*
} }
//set indices //set indices
acquisitionIndex = currentFrameNumber - startAcquisitionIndex; acquisitionIndex = currentFrameNumber - startAcquisitionIndex;
frameIndex = currentFrameNumber - startFrameIndex[ithread]; frameIndex = currentFrameNumber - startFrameIndex;
} }
@ -2774,7 +2755,7 @@ void UDPStandardImplementation::writeFileWithoutCompression(int ithread, char* w
//set indices //set indices
acquisitionIndex = currentFrameNumber - startAcquisitionIndex; acquisitionIndex = currentFrameNumber - startAcquisitionIndex;
frameIndex = currentFrameNumber - startFrameIndex[ithread]; frameIndex = currentFrameNumber - startFrameIndex;
} }
#ifdef DEBUG3 #ifdef DEBUG3
cprintf(GREEN,"Writing_Thread: Current Frame Number:%d\n",currentFrameNumber); cprintf(GREEN,"Writing_Thread: Current Frame Number:%d\n",currentFrameNumber);
@ -3065,7 +3046,7 @@ void UDPStandardImplementation::handleDataCompression(int ithread, char* wbuffer
pthread_mutex_unlock(&progressMutex); pthread_mutex_unlock(&progressMutex);
//set indices //set indices
acquisitionIndex = currentFrameNumber - startAcquisitionIndex; acquisitionIndex = currentFrameNumber - startAcquisitionIndex;
frameIndex = currentFrameNumber - startFrameIndex[0]; frameIndex = currentFrameNumber - startFrameIndex;
//variable definitions //variable definitions