memory_dump.h

Go to the documentation of this file.

 
 
#ifndef HERMES_LOG_MEMORY_DUMP_H
#define HERMES_LOG_MEMORY_DUMP_H
 
#include <hermes/common/debug.h>
#include <hermes/common/defs.h>
#include <hermes/common/str.h>
#include <hermes/numeric/numeric.h>
#include <hermes/common/bitmask_operators.h>
#include <hermes/logging/console_colors.h>
#include <iostream>
#include <iomanip>
#include <cstdlib> // system
 
namespace hermes {
 
enum class memory_dumper_options {
  none = 0x0,                    
  binary = 0x1,                  
  decimal = 0x2,                 
  hexadecimal = 0x4,             
  hexii = 0x8,                   
  hide_header = 0x10,            
  cache_align = 0x20,            
  hide_zeros = 0x40,             
  show_ascii = 0x80,             
  save_to_string = 0x100,        
  write_to_console = 0x200,      
  colored_output = 0x400,        
  type_values = 0x800            
};
enum class memory_dumper_options {…};
HERMES_ENABLE_BITMASK_OPERATORS(memory_dumper_options);
 
// *********************************************************************************************************************
//                                                                                                       MemoryDumper
// *********************************************************************************************************************
class MemoryDumper {
public:
  struct RegionLayout {
    RegionLayout() = default;
    RegionLayout &withOffset(std::size_t offset_in_bytes) {
      offset = offset_in_bytes;
      return *this;
    }
    RegionLayout &withOffset(std::size_t offset_in_bytes) {…}
    RegionLayout &withColor(const std::string &console_color) {
      color = console_color;
      return *this;
    }
    RegionLayout &withColor(const std::string &console_color) {…}
    RegionLayout &withCount(std::size_t region_count) {
      count = region_count;
      return *this;
    }
    RegionLayout &withCount(std::size_t region_count) {…}
    RegionLayout &withType(DataType t) {
      type = t;
      return *this;
    }
    RegionLayout &withType(DataType t) {…}
    RegionLayout &withSubRegion(const RegionLayout &sub_region, bool increment_to_parent_size = false) {
      std::size_t new_offset = 0;
      if (!sub_regions.empty())
        new_offset = sub_regions.back().offset + sub_regions.back().field_size_in_bytes * sub_regions.back().count;
      sub_regions.push_back(sub_region);
      sub_regions.back().offset = new_offset;
      if (increment_to_parent_size)
        field_size_in_bytes += sub_region.field_size_in_bytes * sub_region.count;
      return *this;
    }
    RegionLayout &withSubRegion(const RegionLayout &sub_region, bool increment_to_parent_size = false) {…}
    void pushSubRegion(const RegionLayout &sub_region, bool increment_to_parent_size = false) {
      std::size_t new_offset = 0;
      if (!sub_regions.empty())
        new_offset = sub_regions.back().offset + sub_regions.back().field_size_in_bytes * sub_regions.back().count;
      sub_regions.push_back(sub_region);
      sub_regions.back().offset = new_offset;
      if (increment_to_parent_size)
        field_size_in_bytes += sub_region.field_size_in_bytes * sub_region.count;
    }
    void pushSubRegion(const RegionLayout &sub_region, bool increment_to_parent_size = false) {…}
    template<typename T>
    RegionLayout &withTypeFrom() {
      type = DataTypes::typeFrom<T>();
      return *this;
    }
    RegionLayout &withTypeFrom() {…}
    template<typename T>
    RegionLayout &withSizeOf(std::size_t element_count = 1) {
      count = element_count;
      field_size_in_bytes = sizeof(T);
      return *this;
    }
    RegionLayout &withSizeOf(std::size_t element_count = 1) {…}
    RegionLayout &withSize(std::size_t size_in_bytes, std::size_t element_count = 1) {
      count = element_count;
      field_size_in_bytes = size_in_bytes;
      return *this;
    }
    RegionLayout &withSize(std::size_t size_in_bytes, std::size_t element_count = 1) {…}
    [[nodiscard]] std::size_t sizeInBytes() const { return field_size_in_bytes * count; }
    void resizeSubRegions(size_t sub_regions_count) {
      sub_regions.resize(sub_regions_count);
      field_size_in_bytes = 0;
      for (auto &s : sub_regions)
        field_size_in_bytes += s.field_size_in_bytes * s.count;
    }
    void resizeSubRegions(size_t sub_regions_count) {…}
    void clear() {
      *this = RegionLayout();
    }
    void clear() {…}
 
    std::size_t offset{0};                               
    std::size_t field_size_in_bytes{0};                  
    std::size_t count{1};                                
    std::string color = ConsoleColors::default_color;    
    std::vector<RegionLayout> sub_regions{};               
    DataType type{DataType::CUSTOM};                     
  };
  struct RegionLayout {…};
 
  // *******************************************************************************************************************
  //                                                                                                   STATIC METHODS
  // *******************************************************************************************************************
  template<typename T>
  static std::string dumpInfo(const T *data, std::size_t size) {
    auto alignment = alignof(T);
    auto ptr = reinterpret_cast<const u8 * >(data);
    ptrdiff_t down_shift = reinterpret_cast<uintptr_t >(ptr) & (64 - 1);
    uintptr_t aligned_base_address = reinterpret_cast<uintptr_t >(ptr) - down_shift;
    auto size_in_bytes = sizeof(T) * size + down_shift;
    Str s = "Memory Block Information\n";
    s.appendLine("    Address:\t", Str::addressOf(reinterpret_cast<uintptr_t>(data)));
    s.appendLine("    Block Size:\t", sizeof(T) * size, " bytes");
    s.appendLine("  Left Alignment");
    s.appendLine("    Type Alignment:\t", alignment);
    s.appendLine("    Shift:\t", down_shift);
    s.appendLine("    Address:\t", Str::addressOf(reinterpret_cast<uintptr_t>(aligned_base_address)));
    s.appendLine("    Total Block Size:\t", size_in_bytes, " bytes");
    return s.str();
  }
  static std::string dumpInfo(const T *data, std::size_t size) {…}
  template<typename T>
  static std::string dump(const T *data, std::size_t size, u32 bytes_per_row = 8,
                          const RegionLayout &region = RegionLayout(),
                          memory_dumper_options options = memory_dumper_options::none) {
    // check options_
    auto hide_zeros = HERMES_MASK_BIT(options, memory_dumper_options::hide_zeros);
    auto include_header = !HERMES_MASK_BIT(options, memory_dumper_options::hide_header);
    auto align_data = HERMES_MASK_BIT(options, memory_dumper_options::cache_align);
    auto show_ascii = HERMES_MASK_BIT(options, memory_dumper_options::show_ascii);
    auto write_to_console = HERMES_MASK_BIT(options, memory_dumper_options::write_to_console);
    auto save_string = HERMES_MASK_BIT(options, memory_dumper_options::save_to_string);
    auto colored_output = HERMES_MASK_BIT(options, memory_dumper_options::colored_output);
    auto show_type_values = HERMES_MASK_BIT(options, memory_dumper_options::type_values);
    if (!write_to_console && !save_string)
      write_to_console = true;
    // output string
    Str output_string;
    // address size
    u32 address_digit_count = 8;
    // compute column size for text alignment
    u8 data_digit_count = 2;
    if (HERMES_MASK_BIT(options, memory_dumper_options::decimal))
      data_digit_count = 3;
    else if (HERMES_MASK_BIT(options, memory_dumper_options::binary))
      data_digit_count = 8;
    u8 header_digit_count = Numbers::countHexDigits(bytes_per_row);
    u8 column_size = std::max(header_digit_count, data_digit_count);
    u8 address_column_size = address_digit_count + 2 + 2; // 0x + \t
    if (include_header) {
      Str s = std::string(address_column_size, ' ');
      for (u32 i = 0; i < bytes_per_row; ++i) {
        auto bs = Str::binaryToHex(i, true, true);
        if (i % 8 == 0)
          s.append(" ");
        s.append(std::setw(column_size), !bs.empty() ? bs : "0", " ");
      }
      if (save_string)
        output_string += s;
      if (write_to_console)
        std::cout << s;
    }
    auto alignment = (align_data) ? 64 : 1;
    auto ptr = reinterpret_cast<const u8 * >(data);
    ptrdiff_t shift = reinterpret_cast<uintptr_t >(ptr) & (alignment - 1);
    uintptr_t aligned_base_address = reinterpret_cast<uintptr_t >(ptr) - shift;
    ptrdiff_t byte_offset = 0;
    ptrdiff_t size_in_bytes = sizeof(T) * size + shift;
    auto line_count = 0;
    while (byte_offset < size_in_bytes) {
      { // ADDRESS
        Str s;
        s.appendLine();
        s.append(Str::addressOf(reinterpret_cast<uintptr_t >((void *) (aligned_base_address + byte_offset))).c_str(),
                 "  ");
        if (save_string)
          output_string += s;
        if (write_to_console) {
          if (colored_output && line_count % 2)
            std::cout << ConsoleColors::dim << s << ConsoleColors::reset_dim;
          else
            std::cout << s;
        }
        line_count++;
      }
      std::string ascii_data;
      std::string type_values;
      for (ptrdiff_t i = 0; i < bytes_per_row; i++, byte_offset++) {
        if (i % 8 == 0) {
          if (write_to_console)
            std::cout << " ";
          if (save_string)
            output_string.append(" ");
        }
        if (aligned_base_address + byte_offset < reinterpret_cast<uintptr_t >(ptr) || byte_offset >= size_in_bytes) {
          if (write_to_console)
            std::cout << std::string(column_size, ' ') + " ";
          if (save_string)
            output_string += std::string(column_size, ' ') + " ";
          ascii_data += '.';
          continue;
        }
        u8 byte = *(reinterpret_cast<u8 *>(aligned_base_address + byte_offset));
        Str s;
        if (!hide_zeros || byte) {
          if (HERMES_MASK_BIT(options, memory_dumper_options::hexadecimal))
            s.append(Str::binaryToHex(byte), " ");
          else if (HERMES_MASK_BIT(options, memory_dumper_options::decimal))
            s.append(std::setfill('0'), std::setw(column_size), static_cast<u32>(byte), ' ');
          else if (HERMES_MASK_BIT(options, memory_dumper_options::binary))
            s.append(Str::byteToBinary(byte), " ");
          else if (HERMES_MASK_BIT(options, memory_dumper_options::hexii))
            s.append(std::string(column_size, ' '), " ");
          else
            s.append(Str::binaryToHex(byte), " ");
        } else
          s.append(std::string(column_size, ' '), " ");
 
        if (save_string)
          output_string += s;
        std::string current_byte_color = byteColor(byte_offset - shift, region);
        if (write_to_console) {
          if (colored_output)
            std::cout << current_byte_color << s.str() << ConsoleColors::default_color << ConsoleColors::reset;
          else
            std::cout << s.str();
        }
        if (colored_output)
          ascii_data += current_byte_color;
        if (std::isalnum(byte))
          ascii_data += byte;
        else
          ascii_data += '.';
        if (colored_output) {
          ascii_data += ConsoleColors::default_color;
          ascii_data += ConsoleColors::reset;
        }
        // compute type value (if any)
        if (show_type_values) {
          if (colored_output)
            type_values += current_byte_color;
          type_values +=
              typeValue(byte_offset - shift, reinterpret_cast<u8 *>(aligned_base_address + byte_offset), region);
          if (colored_output) {
            type_values += ConsoleColors::default_color;
            type_values += ConsoleColors::reset;
          }
          type_values += " ";
        }
      }
      if (show_ascii) {
        if (write_to_console)
          std::cout << "\t|" << ascii_data << "|";
        if (save_string)
          output_string.append("\t|", ascii_data, "|");
      }
      if (show_type_values) {
        if (write_to_console)
          std::cout << "\t<" << type_values << ">";
        if (save_string)
          output_string.append("\t<", type_values, ">");
      }
    }
    if (save_string)
      output_string += '\n';
    if (write_to_console)
      std::cout << "\n";
    return output_string.str();
  }
  static std::string dump(const T *data, std::size_t size, u32 bytes_per_row = 8, {…}
 
private:
  static std::string byteColor(std::size_t byte_index, const RegionLayout &region) {
    std::function<std::string(const std::vector<RegionLayout> &, std::size_t, const std::string &)> f;
    f = [&](const std::vector<RegionLayout> &subregions, std::size_t byte_offset,
            const std::string &parent_color) -> std::string {
      for (const auto &sub_region : subregions) {
        auto region_start = sub_region.offset;
        auto region_end = region_start + sub_region.field_size_in_bytes * sub_region.count;
        if (byte_offset >= region_start && byte_offset < region_end) {
          if (sub_region.sub_regions.empty()) {
            // in the case of an array of elements, lets alternate between dimmed
            // colors to make it easy to visually identify elements
            if (((byte_offset - region_start) / sub_region.field_size_in_bytes) % 2)
              return ConsoleColors::combine(ConsoleColors::bold, sub_region.color);
            return sub_region.color;
          }
          return f(sub_region.sub_regions,
                   (byte_offset - region_start) % sub_region.field_size_in_bytes,
                   sub_region.color);
        }
      }
      return parent_color;
    };
    return f({region}, byte_index, ConsoleColors::default_color);
  }
 
  static std::string typeValue(std::size_t byte_index, u8 *data, const RegionLayout &region) {
    std::function<std::string(const std::vector<RegionLayout> &, std::size_t, const std::string &)> f;
    f = [&](const std::vector<RegionLayout> &subregions, std::size_t byte_offset,
            const std::string &parent_color) -> std::string {
      HERMES_UNUSED_VARIABLE(parent_color);
      for (const auto &sub_region : subregions) {
        auto region_start = sub_region.offset;
        auto region_end = region_start + sub_region.field_size_in_bytes * sub_region.count;
        if (byte_offset >= region_start && byte_offset < region_end) {
          if (sub_region.sub_regions.empty() && sub_region.type != DataType::CUSTOM) {
            if ((byte_offset - region_start) % DataTypes::typeSize(sub_region.type) == 0) {
              std::stringstream ss;
#define RETURN_TYPE(T) if(sub_region.type == DataTypes::typeFrom<T>())           {                            \
           ss << std::setw(10) << std::right << std::setprecision(3) <<  *reinterpret_cast<T*>(data);     \
              return ss.str(); }
              RETURN_TYPE(i8)
              RETURN_TYPE(i16)
              RETURN_TYPE(i32)
              RETURN_TYPE(i64)
              RETURN_TYPE(u8)
              RETURN_TYPE(u16)
              RETURN_TYPE(u32)
              RETURN_TYPE(u64)
              RETURN_TYPE(f32)
              RETURN_TYPE(f64)
#undef RETURN_TYPE
              return "ERROR";
            }
            return "";
          }
          return f(sub_region.sub_regions,
                   (byte_offset - region_start) % sub_region.field_size_in_bytes,
                   sub_region.color);
        }
      }
      return "";
    };
    return f({region}, byte_index, ConsoleColors::default_color);
  }
 
};
class MemoryDumper {…};
 
inline std::ostream &operator<<(std::ostream &os, const MemoryDumper::RegionLayout &layout) {
  os << layout.color << "MemoryRegionLayout [offset = " << layout.offset;
  os << " field size (bytes) = " << layout.field_size_in_bytes;
  os << " count = " << layout.count;
  os << " type = " << DataTypes::typeName(layout.type) << "]\n";
  os << "\tsub regions [" << layout.sub_regions.size() << "]\n";
  if (!layout.sub_regions.empty())
    for (const auto &s : layout.sub_regions) {
      os << s;
      os << "\n";
    }
  os << "\n";
  return os;
}
inline std::ostream &operator<<(std::ostream &os, const MemoryDumper::RegionLayout &layout) {…}
 
}
 
#endif //HERMES_HERMES_HERMES_LOG_MEMORY_DUMP_H