Hex and Binary of Primitive Types

admin — Sun, 14 Jun 2009 20:27:00 +0000

The following C++ program takes values of primitive C++ types (e.g. int, double and so on) and converts them into hex and binary representations. This is a simple and useful tool for examining how actual low-level data is represented by the compiler and CPU.

Once compiled, simply provide as arguments the name of the type following by a list of values.

Example:

$ ./cval unsigned int 1 2 4294967295

On an Intel Core 2 Duo CPU running Ubuntu 9.04 (g++ version 4.3.3) an unsigned int has the following representation:

unsigned int, sizeof 4, non-sign-bits 32, digits10 9, min 0, max 4294967295
         1 | 00 00 00 01 | 00000000 00000000 00000000 00000001
         2 | 00 00 00 02 | 00000000 00000000 00000000 00000010
4294967295 | FF FF FF FF | 11111111 11111111 11111111 11111111

The source code is below. Save as cval.cc and compile with g++ cval.cc -o cval :

/* Darren Smith, 2009  (www.xxdev.com) */
 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
/*
List of types extracted from system header file include/c++/limits :
 
    bool
    char
    double
    float
    int
    long
    long double
    long long
    short
    signed char
    unsigned char
    unsigned int
    unsigned long
    unsigned long long
    unsigned short
    wchar_t
*/
 
/*
 * Template function for getting the name of a type
 */
template <typename T> std::string name_of_type();
 
/* Specialisations */
#define SPECIALSE_name_of_type( X ) \
template <> std::string name_of_type< X >() { return #X; }
SPECIALSE_name_of_type( bool );
SPECIALSE_name_of_type( char );
SPECIALSE_name_of_type( double );
SPECIALSE_name_of_type( float );
SPECIALSE_name_of_type( int );
SPECIALSE_name_of_type( long );
SPECIALSE_name_of_type( long double );
SPECIALSE_name_of_type( long long );
SPECIALSE_name_of_type( short );
SPECIALSE_name_of_type( signed char );
SPECIALSE_name_of_type( unsigned char );
SPECIALSE_name_of_type( unsigned int );
SPECIALSE_name_of_type( unsigned long );
SPECIALSE_name_of_type( unsigned long long );
SPECIALSE_name_of_type( unsigned short );
SPECIALSE_name_of_type( wchar_t );
 
/*
 * Get hex representation of a value
 */
template<typename T>
void to_hex(T _v , std::ostream& s)
{
  union
  {
      T value;
      unsigned char bytes[sizeof(T)];
  };
  memset(&bytes, 0, sizeof(T));
  value = _v;
 
  s << std::setfill('0');
  s << std::hex;
  s << std::uppercase;
  s << std::right;
 
#if BYTE_ORDER == BIG_ENDIAN
  size_t i = 0;
  size_t const e = sizeof(T)-1;
#else
  size_t i = sizeof(T)-1;
  size_t const e = 0;
#endif
 
  for (;;)
  {
    s << std::setw(2) << (unsigned int) bytes[i];
    if (i == e) break;
    s << " ";
 
#if BYTE_ORDER == BIG_ENDIAN
    ++i;
#else
    --i;
#endif
  }
}
 
/*
 * Get binary representation of a value.  We use std::bitset to generate
 * the actual binary for each byte.
 */
template <typename T>
void to_bin(T _v, std::ostream& os)
{
  std::bitset< std::numeric_limits<unsigned char>::digits > bs;
  union
  {
      T value;
      unsigned char bytes[sizeof(T)];
  };
  memset(&bytes, 0, sizeof(T));
  value = _v;
 
#if BYTE_ORDER == BIG_ENDIAN
  size_t i = 0;
  size_t const e = sizeof(T)-1;
#else
  size_t i = sizeof(T)-1;
  size_t const e = 0;
#endif
  for (;;)
  {
    bs = bytes[i]; os << bs;
    if (i == e) break;
    os << " ";
 
#if BYTE_ORDER == BIG_ENDIAN
        ++i;
#else
        --i;
#endif
  }
}
 
/*
 * Utility methods for a primitive type.
 */
template <typename T>
class typeutil
{
  public:
 
    typedef T io_type;
 
    static std::string name() { return ::name_of_type<T>; }
 
    static T from_string(const char* s,
                         std::ios_base& (*base)(std::ios_base&))
    {
      T retval;
 
      std::istringstream iss(s);
 
      if ((iss >> base >> retval).fail())
      {
        std::ostringstream oss;
        oss << "failed to convert \"" << s << "\" to "
            << ::name_of_type<T>() << " at "
          __FILE__ << ":" << __LINE__;
        throw std::ios_base::failure(oss.str());
      }
 
      return retval;
    }
};
 
/*
 * Generic method to use when the conversion from a string to a type
 * needs to go via an intermediate ordinal type.
 */
template <typename S, typename I>
S convert_via_int(const char* s,
                     std::ios_base& (*base)(std::ios_base&))
{
  std::istringstream iss(s);
 
  I intermediate;
 
  if ((iss >> base >> intermediate).fail())
  {
    std::ostringstream oss;
    oss << "failed to convert \"" << s << "\" to "
        << ::name_of_type<S>() << " at "
      __FILE__ << ":" << __LINE__;
    throw std::ios_base::failure(oss.str());
  }
 
  return intermediate;
}
 
/* Specialisation for char types */
 
template <>
class typeutil<char>
{
  public:
    typedef int io_type;
    static std::string name() { return ::name_of_type<char>(); }
    static char from_string(const char* s,
                            std::ios_base& (*base)(std::ios_base&)) {
      return ::convert_via_int<char, io_type>(s, base);
    }
};
template <>
class typeutil<unsigned char>
{
  public:
    typedef unsigned int io_type;
    static std::string name() { return ::name_of_type<unsigned char>(); }
    static unsigned char from_string(const char* s,
                                     std::ios_base& (*base)(std::ios_base&)) {
      return ::convert_via_int<unsigned char, io_type>(s, base);
    }
};
template <>
class typeutil<signed char>
{
  public:
    typedef signed int io_type;
    static std::string name() { return ::name_of_type<signed char>(); }
    static signed char from_string(const char* s,
                                   std::ios_base& (*base)(std::ios_base&)) {
      return ::convert_via_int<signed char, io_type>(s, base);
    }
};
 
/* Formatted output of a floating point type value */
template <typename T>
void pr_float(T v, std::ostream& os, int p, int e, bool pad)
{
  os << std::dec;
  if (pad) os << std::setw(2+p+2+e);
  os << std::right
     << std::setfill(' ')
     << std::setprecision(p)
     << v;
}
 
/* Formatted output of a value.  This function is specialised (below)
 * for floating point types. */
template <typename T>
void pr_raw(T v, std::ostream& os, bool pad)
{
  typename typeutil<T>::io_type o = v;
 
  if (pad)
  {
    // add 1 for most-sig. position, and add 1 for minus sign
    os << std::setw( 1+std::numeric_limits<T>::digits10 +
                    std::numeric_limits<T>::is_signed);
  }
  os << std::dec << std::right << std::setfill(' ') << o;
}
template<> void pr_raw(float v, std::ostream& os, bool pad) { pr_float(v, os,
20, 5, pad); }
template<> void pr_raw(double v, std::ostream& os, bool pad){ pr_float(v, os,
20, 5, pad); }
template<> void pr_raw(long double v, std::ostream& os, bool pad){ pr_float(v,
os, 25, 6, pad); }
 
 
/* For a type T, and a set of values starting at argv[argoffset],
 * display a summary of the type and the hex and binary
 * representations of the set of values. */
template <typename T>
void dump(int argc, const char** argv, int argoffset, std::ostream& os)
{
  // summary line
  os << name_of_type<T>()
     << ", sizeof " << sizeof(T)
     << ", non-sign-bits " << std::numeric_limits<T>::digits
     << ", digits10 " << std::numeric_limits<T>::digits10
     << ", min "; pr_raw<T>(std::numeric_limits<T>::min(), os, false);
  os << ", max "; pr_raw<T>(std::numeric_limits<T>::max(), os, false);
  os << std::endl;
 
  // display the bin & hex representations of the values
  for (int i = argoffset; i < argc; ++i)
  {
    T f = typeutil<T>::from_string(argv[i], std::dec);
    pr_raw<T>(f, os, true);
    os << " | ";
    ::to_hex<T>(f, os);
    os << " | ";
    to_bin<T>(f, os);
    os << std::endl;
  }
}
 
 
#define LOAD_DUMP_FUNC( X ) dump_funs[ ::name_of_type< X >() ] = dump< X >;
 
int main(int argc, const char** argv)
{
  // Build a map of dump functions, one for each type
  typedef void (*dump_funptr)(int, const char**, int, std::ostream&);
  std::map<std::string, dump_funptr> dump_funs;
  LOAD_DUMP_FUNC( bool );
  LOAD_DUMP_FUNC( char );
  LOAD_DUMP_FUNC( double );
  LOAD_DUMP_FUNC( float );
  LOAD_DUMP_FUNC( int );
  LOAD_DUMP_FUNC( long );
  LOAD_DUMP_FUNC( long double );
  LOAD_DUMP_FUNC( long long );
  LOAD_DUMP_FUNC( short );
  LOAD_DUMP_FUNC( signed char );
  LOAD_DUMP_FUNC( unsigned char );
  LOAD_DUMP_FUNC( unsigned int );
  LOAD_DUMP_FUNC( unsigned long );
  LOAD_DUMP_FUNC( unsigned long long );
  LOAD_DUMP_FUNC( unsigned short );
//  LOAD_DUMP_FUNC( wchar_t );
 
  if (argc > 1)
  {
    dump_funptr fptr = NULL;
    int argoffset;
 
    if (not fptr and argc > 3)
    {
      // eg "unsigned long long" in separate argv[] cells
      std::ostringstream concat;
      concat <<  argv[1] << " " << argv[2] << " " << argv[3];
      fptr = dump_funs[ concat.str() ];
      argoffset = 4;
    }
 
    if (not fptr and argc > 2)
    {
      // eg "unsigned long" in separate argv[] cells
      std::ostringstream concat;
      concat <<  argv[1] << " " << argv[2];
      fptr = dump_funs[ concat.str() ];
      argoffset = 3;
    }
 
    if (not fptr and argc > 1)
    {
      // eg "long" in separate argv[] cells
      fptr = dump_funs[ argv[1] ];
      argoffset = 2;
    }
 
    if (fptr)
    {
      try
      {
        fptr(argc, argv, argoffset, std::cout);
      }
      catch (std::ios_base::failure& ex)
      {
        std::cerr << "caught exception: " << ex.what() << "\n";
        return 1;
      }
    }
    else
    {
      std::cerr << "not a supported type\n";
      return 1;
    }
  }
  else
  {
    // if no args, display all supported types
    for (std::map<std::string, dump_funptr>::iterator i = dump_funs.begin();
         i != dump_funs.end(); ++i)
    {
      std::cout << i->first << "\n";
    }
  }
 
  return 0;
}

Cost of gettimeofday

admin — Fri, 13 Mar 2009 03:06:08 +0000

What is the cost of calling the Linux/Unix system function gettimeofday?

Typically this is considered an expensive operation. However it doesn’t appear to be so, as demonstrated by running the simple test code below:

#include 
#include  
 
#define LOOP 10000000LL
 
/* Save as test.cc, and compile with: g++ -O test.cc
 
   To satisfy ourself that the gettimeofday call is actually being
   invoked, just run the program through strace:
 
   Example:
             $ strace ./a.out
*/
int main(int, const char**)
{
    timeval t0;
    timeval t1;
    timeval* ptr = &t1;
 
    // Time at start
    gettimeofday(&t0, NULL);  // use of the timezone structure is obsolete
 
    unsigned long long int i;
    for (i = 0; i < LOOP; ++i)
    {
        gettimeofday(ptr, NULL);
    }
 
    double t = 1000000.0 * (t1.tv_sec - t0.tv_sec) + t1.tv_usec - t0.tv_usec;
 
    std::cout << "Total elapsed time : " << t/1000000.0 << " sec\n";
    std::cout << "Number of calls    : " << i << "\n";
    std::cout << "Time per call      : " << t / i << " msec\n";
 
    return 0;
}

When compiled with gcc version 4.2.4 on an Intel(R) Core(TM) 2 Duo CPU T7500 2.20GHz Lenovo T61, running Ubuntu 8.04, the quickest observed result is:

Total elapsed time : 12.3674 seconds
Number of calls    : 10000000
Time per call      : 1.23674 microseconds

So that is just over 1 millionth of a second! Considered on its own, this is no time at all. However, whether this is “expensive” or not depends on how frequently gettimeofday is called. For instance, a market data application might receive 5000 price updates each second that each need to be time-stamped; the cumulative cost will exceed 5 milliseconds, and will accrue as latency onto immediately arriving later price ticks.

Convert memory regions to strings

admin — Fri, 13 Mar 2009 01:53:24 +0000

We often need to display the exact bytes stored within a region of memory, or we might be interested in the byte representation of a variable. Typically we want such things during debugging, or trying to understand binary based protocols.

Bytes are best displayed in hexadecimal notation (hex). So we require a function that takes a memory region (described by a pointer and size) and builds a string of the hex values for all bytes within the region.

The C++ function below does this. It is called hexdump because it is similar in spirit to the UNIX utility of the same name.

#include 
#include 
 
/**
 * Represent a memory region in hex.
 * Darren Smith, www.xxdev.com
 */
void hexdump(const unsigned char * p, size_t size, std::ostream& os,
             const char* prefix = NULL,
             bool brackets = false)
{
  std::ios_base::fmtflags flags = os.flags(); // save state
 
  if (brackets) os << "[";
 
  // set up our stream for hex output
  os << std::setfill('0');
  os << std::hex;
  os << std::uppercase;
  os << std::right;
 
  for (size_t i = 0; i < size; ++i)
    {
      if (prefix) os << prefix;
      os << std::setw(2) << static_cast<int>(p[i]) ;
    }
 
  os.flags(flags);   // reset stream state
 
  if (brackets) os << "]";
}

Note that it builds the hex string by inserting the hex values onto an output stream. For instant debugging we can use the C++ stream object cout to write the hex to stdout:

int main(int argc, const char* argv[])
{
  if (argc > 1)
    {
      const char* buf = argv[1];
      size_t bufSize = strlen(argv[1]);
 
      hexdump((const unsigned char*) buf, bufSize, std::cout, " ");
      std::cout << "n";
    }
}