vw_slim::model_parser Class Reference

#include <model_parser.h>

Public Member Functions
	model_parser (const char *model, size_t length)
int	read (const char *field_name, size_t field_length, const char **ret)
int	skip (size_t bytes)
const char *	position ()
uint32_t	checksum ()
template<bool compute_checksum>
int	read_string (const char *field_name, std::string &s)
template<typename T , bool compute_checksum>
int	read (const char *field_name, T &val)
template<typename T >
int	read (const char *field_name, T &val)
template<typename T , typename W >
int	read_weights (std::unique_ptr< W > &weights, uint64_t weight_length)
template<typename W >
int	read_weights (std::unique_ptr< W > &weights, uint32_t num_bits, uint32_t stride_shift)

Private Attributes
const char *	_model_begin
const char *	_model
const char *	_model_end
uint32_t	_checksum

Detailed Description

Definition at line 20 of file model_parser.h.

Constructor & Destructor Documentation

model_parser()

vw_slim::model_parser::model_parser	(	const char *	model,
		size_t	length
	)

Definition at line 5 of file model_parser.cc.

References _model_begin, and _model_end.

    : _model_begin(model), _model(model), _model_end(model + length), _checksum(0)
{
#ifdef MODEL_PARSER_DEBUG
  std::cout << "moder_parser("
            << "0x" << std::hex << std::setw(8) << (uint64_t)_model_begin << "-" << std::hex << std::setw(8)
            << (uint64_t)_model_end << ")" << std::dec;
#endif
}

Member Function Documentation

checksum()

uint32_t vw_slim::model_parser::checksum

(

)

Definition at line 17 of file model_parser.cc.

References _checksum.

Referenced by vw_slim::vw_predict< W >::load().

{ return _checksum; }

position()

const char * vw_slim::model_parser::position

(

)

Definition at line 15 of file model_parser.cc.

References _model.

{ return _model; }

read() [1/3]

int vw_slim::model_parser::read	(	const char *	field_name,
		size_t	field_length,
		const char **	ret
	)

Definition at line 19 of file model_parser.cc.

References _model, _model_end, E_VW_PREDICT_ERR_INVALID_MODEL, and S_VW_PREDICT_OK.

Referenced by vw_slim::vw_predict< W >::load(), read(), and read_string().

{  // check if we're inside the buffer
  const char* new_model = _model + field_length;
  if (new_model > _model_end)
    return E_VW_PREDICT_ERR_INVALID_MODEL;

#ifdef MODEL_PARSER_DEBUG
  std::fstream log("vwslim-debug.log", std::fstream::app);
  log << "reading " << field_name << std::endl;
#endif

  *ret = _model;
  // advance begin
  _model = new_model;

  return S_VW_PREDICT_OK;
}

read() [2/3]

template<typename T , bool compute_checksum>

int vw_slim::model_parser::read ( const char *  field_name, T &  val  )

inline

Definition at line 73 of file model_parser.h.

References _checksum, _model_begin, read(), RETURN_ON_FAIL, S_VW_PREDICT_OK, and uniform_hash().

  {
#ifdef MODEL_PARSER_DEBUG
    std::fstream log("vwslim-debug.log", std::fstream::app);
    log << std::setw(18) << field_name << " 0x" << std::hex << std::setw(8) << (uint64_t)_model << "-" << std::hex
        << std::setw(8) << (uint64_t)_model_end << " " << std::setw(4) << (_model - _model_begin)
        << " field: " << std::setw(8) << (uint64_t)&val << std::dec;
#endif

    const char* data;
    RETURN_ON_FAIL(read(field_name, sizeof(T), &data));

    // avoid alignment issues for 32/64bit types on e.g. Android/ARM
    memcpy(&val, data, sizeof(T));

    if (compute_checksum)
      _checksum = (uint32_t)uniform_hash(&val, sizeof(T), _checksum);

#ifdef MODEL_PARSER_DEBUG
    log << " '" << val << '\'' << std::endl;
#endif

    return S_VW_PREDICT_OK;
  }

read() [3/3]

template<typename T >

int vw_slim::model_parser::read ( const char *  field_name, T &  val  )

inline

Definition at line 100 of file model_parser.h.

  {
    return read<T, true>(field_name, val);
  }

read_string()

template<bool compute_checksum>

int vw_slim::model_parser::read_string ( const char *  field_name, std::string &  s  )

inline

Definition at line 39 of file model_parser.h.

References E_VW_PREDICT_ERR_INVALID_MODEL, read(), RETURN_ON_FAIL, S_VW_PREDICT_OK, and uniform_hash().

Referenced by vw_slim::vw_predict< W >::load().

  {
    uint32_t str_len;
    RETURN_ON_FAIL((read<uint32_t, compute_checksum>("string.len", str_len)));
#ifdef MODEL_PARSER_DEBUG
    {
      std::fstream log("vwslim-debug.log", std::fstream::app);
      log << std::setw(18) << field_name << " length " << str_len << std::endl;
    }
#endif

    // 0 length strings are not valid, need to contain at least \0
    if (str_len == 0)
      return E_VW_PREDICT_ERR_INVALID_MODEL;

    const char* data;
    RETURN_ON_FAIL(read(field_name, str_len, &data));

    s = std::string(data, str_len - 1);
#ifdef MODEL_PARSER_DEBUG
    {
      std::fstream log("vwslim-debug.log", std::fstream::app);
      log << std::setw(18) << field_name << " '" << s << '\'' << std::endl;
    }
#endif

    // calculate checksum
    if (compute_checksum && str_len > 0)
      _checksum = (uint32_t)uniform_hash(data, str_len, _checksum);

    return S_VW_PREDICT_OK;
  }

read_weights() [1/2]

template<typename T , typename W >

int vw_slim::model_parser::read_weights ( std::unique_ptr< W > &  weights, uint64_t  weight_length  )

inline

Definition at line 106 of file model_parser.h.

References E_VW_PREDICT_ERR_WEIGHT_INDEX_OUT_OF_RANGE, RETURN_ON_FAIL, and S_VW_PREDICT_OK.

Referenced by vw_slim::vw_predict< W >::load().

  {
    // weights are excluded from checksum calculation
    while (_model < _model_end)
    {
      T idx;
      RETURN_ON_FAIL((read<T, false>("gd.weight.index", idx)));
      if (idx > weight_length)
        return E_VW_PREDICT_ERR_WEIGHT_INDEX_OUT_OF_RANGE;

      float& w = (*weights)[idx];
      RETURN_ON_FAIL((read<float, false>("gd.weight.value", w)));

#ifdef MODEL_PARSER_DEBUG
      std::cout << "weight. idx: " << idx << ":" << (*weights)[idx] << std::endl;
#endif
    }

    return S_VW_PREDICT_OK;
  }

read_weights() [2/2]

template<typename W >

int vw_slim::model_parser::read_weights ( std::unique_ptr< W > &  weights, uint32_t  num_bits, uint32_t  stride_shift  )

inline

Definition at line 128 of file model_parser.h.

References RETURN_ON_FAIL, and S_VW_PREDICT_OK.

  {
    uint64_t weight_length = (uint64_t)1 << num_bits;

    weights = std::unique_ptr<W>(new W(weight_length));
    weights->stride_shift(stride_shift);

    if (num_bits < 31)
    {
      RETURN_ON_FAIL((read_weights<uint32_t, W>(weights, weight_length)));
    }
    else
    {
      RETURN_ON_FAIL((read_weights<uint64_t, W>(weights, weight_length)));
    }

    return S_VW_PREDICT_OK;
  }

skip()

int vw_slim::model_parser::skip

(

size_t

bytes

)

Definition at line 37 of file model_parser.cc.

References _checksum, _model, _model_end, E_VW_PREDICT_ERR_INVALID_MODEL, S_VW_PREDICT_OK, and uniform_hash().

Referenced by vw_slim::vw_predict< W >::load().

{
  const char* new_model = _model + bytes;
  if (new_model > _model_end)
    return E_VW_PREDICT_ERR_INVALID_MODEL;

  if (bytes > 0)
    _checksum = (uint32_t)uniform_hash(_model, bytes, _checksum);

  _model = new_model;

  return S_VW_PREDICT_OK;
}

Member Data Documentation

_checksum

uint32_t vw_slim::model_parser::_checksum

private

Definition at line 25 of file model_parser.h.

Referenced by checksum(), read(), and skip().

_model

const char* vw_slim::model_parser::_model

private

Definition at line 23 of file model_parser.h.

Referenced by position(), read(), and skip().

_model_begin

const char* vw_slim::model_parser::_model_begin

private

Definition at line 22 of file model_parser.h.

Referenced by model_parser(), and read().

_model_end

const char* vw_slim::model_parser::_model_end

private

Definition at line 24 of file model_parser.h.

Referenced by model_parser(), read(), and skip().

---

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

• /mnt/c/w/linux/vowpal_wabbit/vowpalwabbit/slim/include/model_parser.h
• /mnt/c/w/linux/vowpal_wabbit/vowpalwabbit/slim/src/model_parser.cc