/data/refman/pasoursint/CMSSW_5_3_0/src/EventFilter/ResourceBroker/src/FUResource.cc

Go to the documentation of this file.

//
// FUResource
// ----------
//
//            12/10/2006 Philipp Schieferdecker <philipp.schieferdecker@cern.ch>
//            20/01/2012 Andrei Spataru <aspataru@cern.ch>

#include "EventFilter/ResourceBroker/interface/FUResource.h"
#include "EventFilter/ResourceBroker/interface/ResourceChecker.h"

#include "DataFormats/FEDRawData/interface/FEDNumbering.h"
#include "interface/shared/i2oXFunctionCodes.h"
#include "interface/evb/i2oEVBMsgs.h"
#include "EvffedFillerRB.h"
#include "toolbox/mem/Reference.h"
#include "xcept/tools.h"

#include <sstream>
#include <sys/shm.h>

using namespace std;
using namespace evf;

//#define DEBUG_FU_RES


// initialize static members

//______________________________________________________________________________
bool FUResource::doFedIdCheck_ = true;
bool FUResource::useEvmBoard_ = true;
unsigned int FUResource::gtpEvmId_ = FEDNumbering::MINTriggerGTPFEDID;
unsigned int FUResource::gtpDaqId_ = FEDNumbering::MAXTriggerGTPFEDID;
unsigned int FUResource::gtpeId_ = FEDNumbering::MINTriggerEGTPFEDID;

// construction/destruction

//______________________________________________________________________________
FUResource::FUResource(UInt_t fuResourceId, log4cplus::Logger logger,
                EvffedFillerRB *frb, xdaq::Application *app) :
        log_(logger), fuResourceId_(fuResourceId), superFragHead_(0),
                        superFragTail_(0), nbBytes_(0), superFragSize_(0), shmCell_(0),
                        frb_(frb), app_(app), nextEventWillHaveCRCError_(false) {
        //release();
}

//______________________________________________________________________________
FUResource::~FUResource() {

}

// implementation of member functions

//______________________________________________________________________________
void FUResource::allocate(FUShmRawCell* shmCell) {
        //release();
        shmCell_ = shmCell;
        shmCell_->clear();
        shmCell_->setFuResourceId(fuResourceId_);
        //UPDATED
        shmCell_->setEventTypeData();
        eventPayloadSize_ = shmCell_->payloadSize();
        nFedMax_ = shmCell_->nFed();
        nSuperFragMax_ = shmCell_->nSuperFrag();
        /*
         cout << "shmCell = " << shmCell_ << " shm cell furesourceId = "
         << fuResourceId_ << " payload size = " << shmCell_->payloadSize()
         << " nFed max = " << shmCell_->nFed() << " nSuperFragMax_ = "
         << shmCell_->nSuperFrag() << endl;
         */
}

//______________________________________________________________________________
void FUResource::release(bool detachResource) {
        doCrcCheck_ = false;
        fatalError_ = false;

        buResourceId_ = 0xffffffff;
        evtNumber_ = 0xffffffff;

        if (0 != superFragHead_) {
                try {
                        superFragHead_->release();
                } catch (xcept::Exception& e) {
                        LOG4CPLUS_ERROR(
                                        log_,
                                        "Failed to release superFragHead: "
                                                        << xcept::stdformat_exception_history(e));
                }
        }

        superFragHead_ = 0;
        superFragTail_ = 0;

        iBlock_ = 0;
        nBlock_ = 0xffffffff;
        iSuperFrag_ = 0;
        nSuperFrag_ = 0xffffffff;

        nbSent_ = 0;

        nbErrors_ = 0;
        nbCrcErrors_ = 0;

        for (UInt_t i = 0; i < 1024; i++)
                fedSize_[i] = 0;
        eventSize_ = 0;

        if (0 != shmCell_) {
                shmCell_ = 0;
                if (detachResource)
                        shmdt(shmCell_);
        }

}

//______________________________________________________________________________
void FUResource::process(MemRef_t* bufRef) {
        if (fatalError()) {
                LOG4CPLUS_ERROR(log_, "THIS SHOULD *NEVER* HAPPEN!."); // DEBUG
                bufRef->release();
                return;
        }
#ifdef DEBUG_FU_RES
        std::cout << "Started process() for bufRef: " << bufRef<< std::endl;
#endif
        MemRef_t* itBufRef = bufRef;
        while (0 != itBufRef && !fatalError()) {
                MemRef_t* next = itBufRef->getNextReference();
                itBufRef->setNextReference(0);
                try {

                        ResourceChecker resCheck(this);
                        resCheck.processDataBlock(itBufRef);

                } catch (xcept::Exception& e) {
                        LOG4CPLUS_ERROR(log_,
                                        "EVENT LOST:" << xcept::stdformat_exception_history(e));
                        fatalError_ = true;
                        itBufRef->setNextReference(next);
                }

                itBufRef = next;
        }
        if (isComplete()) {
                frb_->putHeader(evtNumber_, 0);
                frb_->putTrailer();
                fedSize_[frb_->fedId()] = frb_->size();
                UChar_t *startPos = shmCell_->writeData(frb_->getPayload(),
                                frb_->size());
                superFragSize_ = frb_->size();
                if (!shmCell_->markSuperFrag(iSuperFrag_, superFragSize_, startPos)) {
                        nbErrors_++;
                        stringstream oss;
                        oss << "Failed to mark super fragment in shared mem buffer."
                                        << " fuResourceId:" << fuResourceId_ << " evtNumber:"
                                        << evtNumber_ << " iSuperFrag:" << iSuperFrag_;
                        XCEPT_RAISE(evf::Exception, oss.str());
                }

                if (!shmCell_->markFed(frb_->fedId(), frb_->size(), startPos)) {
                        nbErrors_++;
                        stringstream oss;
                        oss << "Failed to mark fed in buffer." << " evtNumber:"
                                        << evtNumber_ << " fedId:" << frb_->fedId() << " fedSize:"
                                        << frb_->size() << " fedAddr:0x" << hex
                                        << (unsigned long) frb_->getPayload() << dec;
                        XCEPT_RAISE(evf::Exception, oss.str());
                }

        }
        return;
}

//______________________________________________________________________________
void FUResource::appendBlockToSuperFrag(MemRef_t* bufRef) {
        if (0 == superFragHead_) {
                superFragHead_ = bufRef;
                superFragTail_ = bufRef;
        } else {
                superFragTail_->setNextReference(bufRef);
                superFragTail_ = bufRef;
        }
        return;
}

//______________________________________________________________________________
void FUResource::removeLastAppendedBlockFromSuperFrag() {
        if (0 == superFragHead_) {
                //nothing to do... why did we get here then ???
        } else if (superFragHead_ == superFragTail_) {
                superFragHead_ = 0;
                superFragTail_ = 0;
        } else {
                MemRef_t *next = 0;
                MemRef_t *current = superFragHead_;
                while ((next = current->getNextReference()) != superFragTail_) {
                        current = next;
                        //get to the next-to-last block
                }
                superFragTail_ = current;
                current->setNextReference(0);
        }
        return;
}

//______________________________________________________________________________
void FUResource::superFragSize() throw (evf::Exception) {
        UChar_t *blockAddr = 0;
        UChar_t *frlHeaderAddr = 0;
        frlh_t *frlHeader = 0;

        superFragSize_ = 0;

        UInt_t frameSize = sizeof(I2O_EVENT_DATA_BLOCK_MESSAGE_FRAME);
        MemRef_t* bufRef = superFragHead_;

        while (0 != bufRef) {
                blockAddr = (UChar_t*) bufRef->getDataLocation();
                frlHeaderAddr = blockAddr + frameSize;
                frlHeader = (frlh_t*) frlHeaderAddr;
                superFragSize_ += frlHeader->segsize & FRL_SEGSIZE_MASK;
                bufRef = bufRef->getNextReference();
        }

        eventSize_ += superFragSize_;

        if (eventSize_ > eventPayloadSize_) {
                nbErrors_++;
                stringstream oss;
                oss << "Event size exceeds maximum size." << " fuResourceId:"
                                << fuResourceId_ << " evtNumber:" << evtNumber_
                                << " iSuperFrag:" << iSuperFrag_ << " eventSize:" << eventSize_
                                << " eventPayloadSize:" << eventPayloadSize_;
                XCEPT_RAISE(evf::Exception, oss.str());
        }
}

//______________________________________________________________________________
void FUResource::fillSuperFragPayload() throw (evf::Exception) {
        UChar_t *blockAddr = 0;
        UChar_t *frlHeaderAddr = 0;
        UChar_t *fedAddr = 0;
        UInt_t nbBytes = 0;
        UInt_t nbBytesTot = 0;
        frlh_t *frlHeader = 0;
        UChar_t *bufferPos = 0;
        UChar_t *startPos = 0;

        MemRef_t* bufRef = superFragHead_;
        while (bufRef != 0) {
                blockAddr = (UChar_t*) bufRef->getDataLocation();
                frlHeaderAddr = blockAddr + sizeof(I2O_EVENT_DATA_BLOCK_MESSAGE_FRAME);
                fedAddr = frlHeaderAddr + sizeof(frlh_t);
                frlHeader = (frlh_t*) frlHeaderAddr;
                nbBytes = frlHeader->segsize & FRL_SEGSIZE_MASK;
                nbBytesTot += nbBytes;

                // check if still within limits
                if (nbBytesTot > superFragSize_) {
                        nbErrors_++;
                        stringstream oss;
                        oss << "Reached end of buffer." << " fuResourceId:"
                                        << fuResourceId_ << " evtNumber:" << evtNumber_
                                        << " iSuperFrag:" << iSuperFrag_;
                        XCEPT_RAISE(evf::Exception, oss.str());
                }

                bufferPos = shmCell_->writeData(fedAddr, nbBytes);
                if (0 == startPos)
                        startPos = bufferPos;

                nbBytes_ += nbBytes;
                bufRef = bufRef->getNextReference();
        }

        if (!shmCell_->markSuperFrag(iSuperFrag_, superFragSize_, startPos)) {
                nbErrors_++;
                stringstream oss;
                oss << "Failed to mark super fragment in shared mem buffer."
                                << " fuResourceId:" << fuResourceId_ << " evtNumber:"
                                << evtNumber_ << " iSuperFrag:" << iSuperFrag_;
                XCEPT_RAISE(evf::Exception, oss.str());
        }

        return;
}

//______________________________________________________________________________
void FUResource::releaseSuperFrag() {
        if (0 == superFragHead_)
                return;
        superFragHead_->release(); // throws xcept::Exception
        superFragHead_ = 0;
        superFragTail_ = 0;
        return;
}

//______________________________________________________________________________
UInt_t FUResource::nbErrors(bool reset) {
        UInt_t result = nbErrors_;
        if (reset)
                nbErrors_ = 0;
        return result;
}

//______________________________________________________________________________
UInt_t FUResource::nbCrcErrors(bool reset) {
        UInt_t result = nbCrcErrors_;
        if (reset)
                nbCrcErrors_ = 0;
        return result;
}

//______________________________________________________________________________
UInt_t FUResource::nbBytes(bool reset) {
        UInt_t result = nbBytes_;
        if (reset)
                nbBytes_ = 0;
        return result;
}