gmMemoryDump.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/

#ifndef _GEMA_MEMORY_DUMP_H_
#define _GEMA_MEMORY_DUMP_H_

#include "gmCoreConfig.h"
#include "gmLog.h"

#include <QString>
#include <QVector>
#include <QByteArray>

class QFile;

enum GmMemoryDumpMode
{
  GM_DUMP_AUTO,    
  GM_DUMP_MEMORY,  
  GM_DUMP_FILE,    
  GM_DUMP_RESTORE, 
};

#define GM_MEMORY_DUMP_ITEM_NAME_SIZE 80

#define GM_MEMORY_DUMP_ITEM_DATA_SIZE 16

#define GM_MEMORY_DUMP_MIN_COMPRESSION (4 * 1024)

class GMC_API_EXPORT GmMemoryBufferList
{
public:
  GmMemoryBufferList();

  void addBuffer(char* buffer, qint64 size);

  qint64 size() const { return _totalSize; }

private:
  Q_DISABLE_COPY(GmMemoryBufferList)

  friend class GmMemoryDump;  // Our private members are for the benefit of GmMemoryDump only :)

  bool isDone() const { return _bufIndex == _bufferList.size() && _bufOffset == 0; }

  bool writeDataToFile (QFile* file, qint64 size);
  bool readDataFromFile(QFile* file, qint64 size);
  void writeDataToMem  (char*  ptr,  qint64 size);
  void readDataFromMem (char*  ptr,  qint64 size);

  QVarLengthArray<QPair<char*, qint64>, 5> _bufferList; 
  qint64                                   _totalSize;  
  int                                      _bufIndex;   
  qint64                                   _bufOffset;  
};

class GMC_API_EXPORT GmMemoryDumpItem
{
public:
  virtual ~GmMemoryDumpItem() {}

  virtual QString itemName() const = 0;

  virtual int itemType() const = 0;

  virtual bool canCompress() const = 0;

  virtual bool partialOp() const = 0;

  virtual bool fixedSize() const = 0;

  virtual bool opStart(int op) { Q_UNUSED(op); return true; }

  virtual bool opEnd(int op) { Q_UNUSED(op); return true; }

  virtual qint64 size() const = 0;

  virtual bool fillDataHeader(char* header) = 0;

  virtual void getDataBuffer(GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0) = 0;

  virtual bool setDataBuffer(GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0) = 0;

  virtual void bufferReleased(int op, bool ok) { Q_UNUSED(op); Q_UNUSED(ok); }
};

class GMC_API_EXPORT GmMemoryDump
{
public:
  GmMemoryDump(GmMemoryDumpMode mode, const GmLogCategory& logger, int compression = 0, 
               int compressionMinSize = GM_MEMORY_DUMP_MIN_COMPRESSION,
               double dumpSizeA = 1.0, unsigned dumpSizeB = 0);
  
  virtual ~GmMemoryDump();

  void setPrintStructure(bool mode) { _printStructure = mode; }

  int addDumpItem(GmMemoryDumpItem* item, int groupId = -1);

  GmMemoryDumpItem* item(int itemId) const 
  { 
    assert(itemId >= 0 && itemId < _dumpItems.size()); 
    return _dumpItems[itemId]->_item;
  }

  int findItem(QString name, int typeMask = 0, int typeValue = 0, int groupId = -1, int start = 0);

  int itemGroup(int itemId) const
  {
    assert(itemId >= 0 && itemId < _dumpItems.size());
    assert(_dumpItems[itemId]->_data);
    return _dumpItems[itemId]->_data->_groupId;
  }

  int numItems() const { return _dumpItems.size(); }

  void setItemActive (int itemId,  bool active);
  void setGroupActive(int groupId, bool active);

  bool isItemActive(int itemId)
  {
    assert(itemId >= 0 && itemId < _dumpItems.size());
    return _dumpItems[itemId]->_active;
  }

  bool init(QString dumpFile, bool overwrite, bool keep);
  bool init();

  bool save();
  bool load();

  bool saveItem(int itemId, qint64 size = 0, qint64 offset = 0);
  bool loadItem(int itemId, qint64 size = 0, qint64 offset = 0);

  bool saveActiveItems();
  bool loadActiveItems();

  void flush();
  void clear();

  int adjustGroupId(int id) const { assert(id >= -2); return id == -1 ? _nextGroupId : (id == -2 ? _currentGroupId : id); }

  static const char* modeToStr(GmMemoryDumpMode mode);
  static int         strToMode(const QString& str);

private:
  Q_DISABLE_COPY(GmMemoryDump)

  
  struct FileControlHeader
  {
    char   _magic[4];         
    qint32 _version;          
    qint64 _infoBlockPos;     
  };

  struct FileDataChunkHeader
  {
    FileDataChunkHeader() { _dummy = 0; }

    qint32 _blockId;      
    qint32 _chunkId;      
    qint64 _chunkSize;    
    qint64 _nextChunkPos; 
    qint64 _dummy;        
  };

  struct FileInfoBlockHeader
  {
    FileInfoBlockHeader() { memset(_dummy, 0, sizeof(_dummy)); }

    qint32 _numItems;         
    qint32 _lastChunkBlockId; 
    char   _dummy[8];         
  };

  struct FileItemHeader
  {
    char   _itemName[GM_MEMORY_DUMP_ITEM_NAME_SIZE];   
    char   _itemData[GM_MEMORY_DUMP_ITEM_DATA_SIZE];   
    qint32 _itemType;       
    qint16 _groupId;        
    qint16 _compressed;     
    qint64 _dataSize;       
    qint64 _dumpSize;       
    qint64 _dataBlockPos;   
  };

  // Ensure that structures have a size that is a multiple of 16 bytes.
  static_assert(sizeof(FileControlHeader)   % 16 == 0, "Unexpected structure size");
  static_assert(sizeof(FileDataChunkHeader) % 16 == 0, "Unexpected structure size");
  static_assert(sizeof(FileInfoBlockHeader) % 16 == 0, "Unexpected structure size");
  static_assert(sizeof(FileItemHeader)      % 16 == 0, "Unexpected structure size");

  struct ItemHeader
  {
    ItemHeader(qint32 id, qint16 groupId) 
    {
      _blockId       = id; 
      _groupId       = groupId;
      _compressed    = 0;
      _dataSize      = 0;
      _dumpSize      = 0;
      _dataHeaderPos = 0; 
      _dataBlockPos  = 0; 
      memset(_itemData, 0, GM_MEMORY_DUMP_ITEM_DATA_SIZE);
    }

    qint32 _blockId;       
    qint16 _groupId;       
    qint16 _compressed;    
    qint64 _dataSize;      
    qint64 _dumpSize;      
    qint64 _dataHeaderPos; 
    qint64 _dataBlockPos;  
    char   _itemData[GM_MEMORY_DUMP_ITEM_DATA_SIZE];  
    QByteArray _memData;   
  };

  struct DumpItem
  {
    DumpItem(GmMemoryDumpItem* item, qint32 id, qint16 groupId) { _item = item; _data = new ItemHeader(id, groupId); _active = true; }

    ~DumpItem() { delete _item; delete _data; }

    GmMemoryDumpItem* _item;   
    ItemHeader*       _data;   
    bool              _active; 
  };

  bool fileInit(QString dumpFile, bool overwrite, bool keep);
  bool fileInitNew();
  bool fileInitExisting();
  bool memoryInit();

  void fileClose();

  bool fileSaveItem  (DumpItem* item, bool update, qint64 size = 0, qint64 offset = 0);
  bool memorySaveItem(DumpItem* item, qint64 size = 0, qint64 offset = 0);

  bool fileLoadItem  (DumpItem* item, qint64 size = 0, qint64 offset = 0);
  bool memoryLoadItem(DumpItem* item, qint64 size = 0, qint64 offset = 0);

  bool writeOrCheckControlHeader(bool write, qint64* infoBlockPos);
  bool saveDataBlock (qint32 blockId, qint64 blockSize, const char* buffer, qint64 size);
  bool saveDataChunck(const FileDataChunkHeader* h, const char* buffer, qint64 size);

  bool saveChunkHeader (const FileDataChunkHeader* h);
  bool saveChunkPadding(const FileDataChunkHeader* h, qint64 dataSize);

  bool loadChunkHeader(FileDataChunkHeader* h);
  bool loadChunkData  (char* buffer, qint64 offset, qint64 size);

  bool updateFileInfoHeader();
  bool updateFileItemHeader(const ItemHeader* h, const GmMemoryDumpItem* item);

  bool readData (char*               buffer, qint64 size);
  bool readData (GmMemoryBufferList& blist,  qint64 size);
  bool writeData(const char*         buffer, qint64 size);
  bool writeData(GmMemoryBufferList& blist,  qint64 size);

  qint64 blockSize(qint64 dataSize, bool grow);

#if defined ENABLE_TESTS
  // Allows test function to call checkAndPrintFileStructure()
  friend Q_DECL_EXPORT void TEST_GmMemoryDumpCheck(GmMemoryDump*, bool);
  void checkAndPrintFileStructure(bool print, bool saved);
#endif

  GmMemoryDumpMode _mode;        
  int              _compression; 
  int              _minCompressionSize; 
  double           _dumpSizeA;   
  unsigned         _dumpSizeB;   
  QString          _fileName;    
  bool             _keepFile;    
  bool             _printStructure; 
                       
  QFile*             _file;      
  bool               _init;      
  qint64             _fileInfoPos;      
  qint64             _firstChunkPos;    
  qint32             _lastChunkBlockId; 
  QVector<DumpItem*> _dumpItems;        
  int                _currentGroupId;   
  int                _nextGroupId;      

  const GmLogCategory& _logger;  
};

#endif