WriterLZ4 Class Reference

Inheritance diagram for WriterLZ4:

Collaboration diagram for WriterLZ4:

Public Member Functions
	WriterLZ4 (LOG_CHN *log_chn, WriterInterface *wr)
	~WriterLZ4 ()
int	wr_open (LOG_CHN *log_chn, int run_number)
int	wr_write (LOG_CHN *log_chn, const void *data, const int size)
int	wr_close (LOG_CHN *log_chn, int run_number)
std::string	wr_get_file_ext ()
std::string	wr_get_chain ()
Public Member Functions inherited from WriterInterface
	WriterInterface ()
virtual	~WriterInterface ()

Private Attributes
WriterInterface *	fWr
MLZ4F_compressionContext_t	fContext
MLZ4F_preferences_t	fPrefs
char *	fBuffer
int	fBufferSize
int	fBlockSize

Additional Inherited Members
Public Attributes inherited from WriterInterface
bool	fTrace
double	fBytesIn
double	fBytesOut

Detailed Description

Definition at line 1422 of file mlogger.cxx.

Constructor & Destructor Documentation

WriterLZ4()

WriterLZ4::WriterLZ4 ( LOG_CHN *  log_chn, WriterInterface *  wr  )

inline

Definition at line 1425 of file mlogger.cxx.

   {
      if (fTrace)
         printf("WriterLZ4: path [%s]\n", log_chn->path.c_str());
 
      assert(wr != NULL);
 
      fBuffer = NULL;
      fWr = wr;
      fBufferSize = 0;
      fBlockSize = 0;
   }

Here is the call graph for this function:

~WriterLZ4()

WriterLZ4::~WriterLZ4 ( )

inline

Definition at line 1438 of file mlogger.cxx.

   {
      if (fTrace)
         printf("WriterLZ4: destructor\n");
 
      FREE(fBuffer);
      DELETE(fWr);
   }

Here is the call graph for this function:

Member Function Documentation

wr_close()

int WriterLZ4::wr_close ( LOG_CHN *  log_chn, int  run_number  )

inlinevirtual

Implements WriterInterface.

Definition at line 1545 of file mlogger.cxx.

   {
      int xstatus = SUCCESS;
      MLZ4F_errorCode_t errorCode;
 
      if (fTrace)
         printf("WriterLZ4: close path [%s]\n", log_chn->path.c_str());
 
      log_chn->handle = 0;
 
      /* write End of Stream mark */
      size_t headerSize = MLZ4F_compressEnd(fContext, fBuffer, fBufferSize, NULL);
 
      if (MLZ4F_isError(headerSize)) {
         errorCode = headerSize;
         cm_msg(MERROR, "WriterLZ4::wr_close", "LZ4F_compressEnd() error %d (%s)", (int)errorCode, MLZ4F_getErrorName(errorCode));
         return SS_FILE_ERROR;
      }
 
      int status = fWr->wr_write(log_chn, fBuffer, headerSize);
 
      fBytesIn += 0;
      fBytesOut = fWr->fBytesOut;
 
      if (status != SUCCESS) {
         if (xstatus == SUCCESS)
            xstatus = status;
      }
 
      /* close downstream writer */
 
      status = fWr->wr_close(log_chn, run_number);
 
      if (status != SUCCESS) {
         if (xstatus == SUCCESS)
            xstatus = status;
      }
 
      /* free resources */
 
      free(fBuffer);
      fBuffer = NULL;
      fBufferSize = 0;
 
      errorCode = MLZ4F_freeCompressionContext(fContext);
      if (MLZ4F_isError(errorCode)) {
         cm_msg(MERROR, "WriterLZ4::wr_close", "LZ4F_freeCompressionContext() error %d (%s)", (int)errorCode, MLZ4F_getErrorName(errorCode));
         if (xstatus == SUCCESS)
            xstatus = SS_FILE_ERROR;
      }
 
      return xstatus;
   }

Here is the call graph for this function:

wr_get_chain()

std::string WriterLZ4::wr_get_chain ( )

inlinevirtual

Implements WriterInterface.

Definition at line 1603 of file mlogger.cxx.

                            {
      return "lz4 | " + fWr->wr_get_chain();
   }

Here is the call graph for this function:

wr_get_file_ext()

std::string WriterLZ4::wr_get_file_ext ( )

inlinevirtual

Reimplemented from WriterInterface.

Definition at line 1599 of file mlogger.cxx.

                               {
      return ".lz4" + fWr->wr_get_file_ext();
   }

Here is the call graph for this function:

wr_open()

int WriterLZ4::wr_open ( LOG_CHN *  log_chn, int  run_number  )

inlinevirtual

Implements WriterInterface.

Definition at line 1447 of file mlogger.cxx.

   {
      int status;
      MLZ4F_errorCode_t errorCode;
 
      if (fTrace)
         printf("WriterLZ4: open path [%s]\n", log_chn->path.c_str());
 
      status = fWr->wr_open(log_chn, run_number);
      if (status != SUCCESS) {
         return status;
      }
 
      errorCode = MLZ4F_createCompressionContext(&fContext, MLZ4F_VERSION);
      if (MLZ4F_isError(errorCode)) {
         cm_msg(MERROR, "WriterLZ4::wr_open", "LZ4F_createCompressionContext() error %d (%s)", (int)errorCode, MLZ4F_getErrorName(errorCode));
         return SS_FILE_ERROR;
      }
 
      MLZ4F_blockSizeID_t blockSizeId = MLZ4F_max4MB;
      fBlockSize = 4*1024*1024;
      fBufferSize = MLZ4F_compressFrameBound(fBlockSize, NULL);
      fBufferSize *= 2; // kludge
      fBuffer = (char*)malloc(fBufferSize);
      if (fBuffer == NULL) {
         cm_msg(MERROR, "WriterLZ4::wr_open", "Cannot malloc() %d bytes for an LZ4 compression buffer, block size %d, errno %d (%s)", fBufferSize, fBlockSize, errno, strerror(errno));
         return SS_FILE_ERROR;
      }
 
      MEMZERO(fPrefs);
 
      fPrefs.compressionLevel = 0; // 0=fast, non-zero=???
      fPrefs.autoFlush = 0; // ???
      fPrefs.frameInfo.contentChecksumFlag = MLZ4F_contentChecksumEnabled;
      fPrefs.frameInfo.blockSizeID = blockSizeId;
 
      size_t headerSize = MLZ4F_compressBegin(fContext, fBuffer, fBufferSize, &fPrefs);
      
      if (MLZ4F_isError(headerSize)) {
         errorCode = headerSize;
         cm_msg(MERROR, "WriterLZ4::wr_open", "LZ4F_compressBegin() error %d (%s)", (int)errorCode, MLZ4F_getErrorName(errorCode));
         return SS_FILE_ERROR;
      }
 
      status = fWr->wr_write(log_chn, fBuffer, headerSize);
 
      fBytesIn += 0;
      fBytesOut = fWr->fBytesOut;
 
      if (status != SUCCESS) {
         return SS_FILE_ERROR;
      }
 
      log_chn->handle = 9999;
 
      return SUCCESS;
   }

Here is the call graph for this function:

wr_write()

int WriterLZ4::wr_write ( LOG_CHN *  log_chn, const void *  data, const int  size  )

inlinevirtual

Implements WriterInterface.

Definition at line 1505 of file mlogger.cxx.

   {
      const char* ptr = (const char*)data;
      int remaining = size;
 
      if (fTrace)
         printf("WriterLZ4: write path [%s], size %d\n", log_chn->path.c_str(), size);
 
      while (remaining > 0) {
         int wsize = remaining;
 
         if (wsize > fBlockSize)
            wsize = fBlockSize;
 
         size_t outSize = MLZ4F_compressUpdate(fContext, fBuffer, fBufferSize, ptr, wsize, NULL);
 
         if (MLZ4F_isError(outSize)) {
            int errorCode = outSize;
            cm_msg(MERROR, "WriterLZ4::wr_write", "LZ4F_compressUpdate() with %d bytes, block size %d, buffer size %d, write size %d, remaining %d bytes, error %d (%s)", wsize, fBlockSize, fBufferSize, size, remaining, (int)errorCode, MLZ4F_getErrorName(errorCode));
            return SS_FILE_ERROR;
         }
 
         if (outSize > 0) {
            int status = fWr->wr_write(log_chn, fBuffer, outSize);
 
            fBytesIn += wsize;
            fBytesOut = fWr->fBytesOut;
            
            if (status != SUCCESS) {
               return SS_FILE_ERROR;
            }
         }
 
         ptr += wsize;
         remaining -= wsize;
      }
 
      return SUCCESS;
   }

Here is the call graph for this function:

Member Data Documentation

fBlockSize

int WriterLZ4::fBlockSize

private

Definition at line 1613 of file mlogger.cxx.

fBuffer

char* WriterLZ4::fBuffer

private

Definition at line 1611 of file mlogger.cxx.

fBufferSize

int WriterLZ4::fBufferSize

private

Definition at line 1612 of file mlogger.cxx.

fContext

MLZ4F_compressionContext_t WriterLZ4::fContext

private

Definition at line 1609 of file mlogger.cxx.

fPrefs

MLZ4F_preferences_t WriterLZ4::fPrefs

private

Definition at line 1610 of file mlogger.cxx.

fWr

WriterInterface* WriterLZ4::fWr

private

Definition at line 1608 of file mlogger.cxx.

---

The documentation for this class was generated from the following file:

• progs/mlogger.cxx