ember_ir::rec::Recurrence Class Reference

#include <graph_ir_recurrence.h>

Collaboration diagram for ember_ir::rec::Recurrence:

Classes
struct	StateTensor
struct	WeightDecl

Public Member Functions
const std::vector< StateTensor > &	state () const
const std::vector< WeightDecl > &	weights () const
const std::vector< size_t > &	input_widths () const
size_t	out_width () const
bool	exact () const
std::string	slot_errors (const nlohmann::json &slot) const
void	init (const std::vector< const float * > &weights, const std::vector< float * > &state) const
void	step (const std::vector< const float * > &in, const std::vector< const float * > &weights, const std::vector< float * > &state, float *out) const
	Recurrence ()
	~Recurrence ()
	Recurrence (Recurrence &&) noexcept
Recurrence &	operator= (Recurrence &&) noexcept

Static Public Member Functions
static Recurrence	compile (const nlohmann::json &node)

Private Attributes
std::unique_ptr< Program >	p_

Detailed Description

Definition at line 35 of file graph_ir_recurrence.h.

Constructor & Destructor Documentation

Recurrence() [1/2]

ember_ir::rec::Recurrence::Recurrence ( )

default

~Recurrence()

ember_ir::rec::Recurrence::~Recurrence ( )

default

Recurrence() [2/2]

ember_ir::rec::Recurrence::Recurrence ( Recurrence &&  )

defaultnoexcept

Member Function Documentation

compile()

Recurrence ember_ir::rec::Recurrence::compile ( const nlohmann::json &  node )

static

Definition at line 547 of file graph_ir_recurrence.cpp.

                                               {
  auto P = std::make_unique<Program>();
  Program& p = *P;
  std::set<std::string> names;  // every declared name, distinct across all kinds
  auto declare = [&](const std::string& name, const std::string& what) {
    if (!is_identifier(name)) fail(31, what + " name '" + name + "' is not an identifier");
    if (is_reserved(name)) fail(31, what + " name '" + name + "' is reserved");
    if (!names.insert(name).second) fail(31, "the name '" + name + "' is declared twice");
  };
  // index
  if (!node.contains("index") || !node.at("index").is_object() || node.at("index").empty())
    fail(31, "'index' is not a map of names to positive integers");
  for (const auto& kv : node.at("index").items()) {
    if (!kv.value().is_number_integer() || kv.value().get<int64_t>() <= 0)
      fail(31, "index '" + kv.key() + "' has size " + kv.value().dump() + ", not a positive integer");
    if (kv.value().get<int64_t>() > (1 << 24))  // a capability limit (section 10.3), not a validation rule
      throw std::runtime_error("IR recurrence: index '" + kv.key() + "' of size " + kv.value().dump() +
                               " is larger than ember's interpreter takes (2^24)");
    declare(kv.key(), "index");
    p.index_of[kv.key()] = static_cast<int>(p.index_names.size());
    p.index_names.push_back(kv.key());
    p.index_sizes.push_back(static_cast<int>(kv.value().get<int64_t>()));
  }
  p.iv.assign(p.index_names.size(), 0);
  auto add_tensor = [&](const std::string& name, TKind kind, const std::vector<int>& ids, std::vector<int>& list) {
    Tensor t;
    t.name = name;
    t.kind = kind;
    for (int id : ids) t.sizes.push_back(p.index_sizes[id]);
    t.strides.assign(t.sizes.size(), 1);
    for (size_t d = t.sizes.size(); d-- > 1;) t.strides[d - 1] = t.strides[d] * static_cast<size_t>(t.sizes[d]);
    for (int s : t.sizes) {
      t.numel *= static_cast<size_t>(s);
      if (t.numel > (size_t(1) << 28))  // a capability limit (section 10.3)
        throw std::runtime_error("IR recurrence: tensor '" + name + "' holds more than 2^28 elements, more than ember's interpreter takes");
    }
    t.pos = static_cast<int>(list.size());
    const int id = static_cast<int>(p.tensors.size());
    p.tensor_of[name] = id;
    p.tensors.push_back(std::move(t));
    list.push_back(id);
    return id;
  };
  // inputs: one declaration per value of in
  size_t n_in = 0;
  if (node.contains("in")) n_in = node.at("in").is_array() ? node.at("in").size() : 1;
  const std::vector<std::string> inputs = strings(node, "inputs", true, true);
  if (inputs.size() != n_in)
    fail(31, "'inputs' declares " + std::to_string(inputs.size()) + " value(s) for the " + std::to_string(n_in) +
                 " of 'in'");
  for (size_t v = 0; v < inputs.size(); ++v) {
    const std::string where = "inputs[" + std::to_string(v) + "]";
    const auto toks = lex(inputs[v], where);
    size_t pos = 0;
    const auto [name, ids] = head(p, toks, pos, where, false);
    if (toks[pos].kind != Tok::End)
      fail(31, where + " does not parse: unexpected '" + toks[pos].text + "' at column " + std::to_string(toks[pos].column));
    declare(name, "input");
    const int id = add_tensor(name, TKind::Input, ids, p.inputs);
    p.in_widths.push_back(p.tensors[id].numel);
  }
  // weights: declarations to tensor names
  if (node.contains("weights") && !node.at("weights").is_null()) {
    if (!node.at("weights").is_object()) fail(31, "'weights' is not a map of declarations to tensor names");
    for (const auto& kv : node.at("weights").items()) {
      if (!kv.value().is_string() || kv.value().get<std::string>().empty())
        fail(31, "weight '" + kv.key() + "' does not name a tensor");
      const std::string where = "weights '" + kv.key() + "'";
      const auto toks = lex(kv.key(), where);
      size_t pos = 0;
      const auto [name, ids] = head(p, toks, pos, where, false);
      if (toks[pos].kind != Tok::End)
        fail(31, where + " does not parse: unexpected '" + toks[pos].text + "' at column " + std::to_string(toks[pos].column));
      declare(name, "weight");
      const int id = add_tensor(name, TKind::Weight, ids, p.weights);
      p.weight_info.push_back({name, kv.value().get<std::string>(), p.tensors[id].numel});
    }
  }
  // The assignments' heads first (the names every body may read), then the bodies.
  auto parse_heads = [&](const std::vector<std::string>& src, const char* section, std::vector<Assign>& dst,
                         std::vector<std::string>& names_out) {
    for (size_t k = 0; k < src.size(); ++k) {
      Assign a;
      a.where = std::string(section) + "[" + std::to_string(k) + "]";
      a.toks = lex(src[k], a.where);
      size_t pos = 0;
      auto h = head(p, a.toks, pos, a.where, true);
      if (a.toks[pos].kind != Tok::Eq)
        fail(31, a.where + " does not parse: expected '=' at column " + std::to_string(a.toks[pos].column));
      a.body_tok = pos + 1;
      a.lhs = h.second;
      names_out.push_back(h.first);
      dst.push_back(std::move(a));
    }
  };
  std::vector<std::string> init_names, let_names, update_names, readout_names;
  const std::vector<std::string> init_src = strings(node, "init", false, false);
  const std::vector<std::string> let_src = strings(node, "let", false, false);
  const std::vector<std::string> update_src = strings(node, "update", true, true);
  if (!node.contains("readout") || !node.at("readout").is_string()) fail(31, "'readout' is not one assignment");
  parse_heads(update_src, "update", p.update, update_names);
  parse_heads(let_src, "let", p.let, let_names);
  parse_heads(init_src, "init", p.init, init_names);
  {
    std::vector<Assign> ro;
    parse_heads({node.at("readout").get<std::string>()}, "readout", ro, readout_names);
    ro[0].where = "readout";
    p.readout = std::move(ro[0]);
  }
  for (size_t k = 0; k < p.update.size(); ++k) {
    declare(update_names[k], "state");
    p.update[k].tensor = add_tensor(update_names[k], TKind::State, p.update[k].lhs, p.states);
  }
  for (size_t k = 0; k < p.let.size(); ++k) {
    declare(let_names[k], "let");
    p.let[k].tensor = add_tensor(let_names[k], TKind::Let, p.let[k].lhs, p.lets);
  }
  {
    declare(readout_names[0], "readout");
    std::vector<int> outs;
    p.readout.tensor = add_tensor(readout_names[0], TKind::Out, p.readout.lhs, outs);
    p.out = p.readout.tensor;
    p.out_width = p.tensors[p.out].numel;
  }
  p.init_of_state.assign(p.states.size(), -1);
  for (size_t k = 0; k < p.init.size(); ++k) {
    const auto it = p.tensor_of.find(init_names[k]);
    if (it == p.tensor_of.end() || p.tensors[it->second].kind != TKind::State)
      fail(33, p.init[k].where + " assigns '" + init_names[k] + "', which is not a state tensor (an update's)");
    const Tensor& st = p.tensors[it->second];
    if (p.init_of_state[st.pos] >= 0) fail(33, p.init[k].where + " assigns '" + init_names[k] + "' a second time");
    std::vector<int> sizes;
    for (int id : p.init[k].lhs) sizes.push_back(p.index_sizes[id]);
    if (sizes != st.sizes) fail(33, p.init[k].where + " assigns '" + init_names[k] + "' with other sizes than its update");
    p.init_of_state[st.pos] = static_cast<int>(k);
    p.init[k].tensor = it->second;
  }
  // Bodies, with what each section reads (section 6.10.2).
  auto body = [&](Assign& a, const ReadRules& r) { a.body = BodyParser(p, a.toks, a.body_tok, a.where, r, a.lhs).parse(); };
  for (auto& a : p.init) body(a, ReadRules{false, true, false, 0});
  for (size_t k = 0; k < p.let.size(); ++k) body(p.let[k], ReadRules{true, true, true, static_cast<int>(k)});
  for (auto& a : p.update) body(a, ReadRules{true, true, true, static_cast<int>(p.let.size())});
  body(p.readout, ReadRules{true, true, true, static_cast<int>(p.let.size())});
  for (auto* v : {&p.init, &p.let, &p.update})
    for (auto& a : *v) std::vector<Token>().swap(a.toks);
  std::vector<Token>().swap(p.readout.toks);
  // The public description and the scratch.
  for (size_t s = 0; s < p.states.size(); ++s) {
    const Tensor& t = p.tensors[p.states[s]];
    StateTensor st;
    st.name = t.name;
    for (int x : t.sizes) st.shape.push_back(x);
    st.numel = t.numel;
    st.init_body = p.init_of_state[s] >= 0;
    p.state_info.push_back(std::move(st));
    p.new_state.emplace_back(t.numel);
  }
  for (int id : p.lets) p.let_buf.emplace_back(p.tensors[id].numel);
  p.data.assign(p.tensors.size(), nullptr);
  Recurrence r;
  r.p_ = std::move(P);
  return r;
}

References a, body, column, id, inputs, j, k, kind, list, name, p, pos, sizes, text, toks, v, and where.

Referenced by ember_ir::Interpreter::init().

exact()

bool ember_ir::rec::Recurrence::exact

(

)

const

Definition at line 545 of file graph_ir_recurrence.cpp.

{ return p_->exact; }

References p_.

init()

void ember_ir::rec::Recurrence::init	(	const std::vector< const float * > &	weights,
		const std::vector< float * > &	state
	)		const

Definition at line 745 of file graph_ir_recurrence.cpp.

                                                                                                  {
  const Program& p = *p_;
  for (size_t w = 0; w < p.weights.size(); ++w) p.data[p.weights[w]] = weights[w];
  for (size_t s = 0; s < p.states.size(); ++s) {
    const int k = p.init_of_state[s];
    if (k < 0)
      std::fill(state[s], state[s] + p.state_info[s].numel, 0.0f);
    else
      p.assign(p.init[k], state[s]);
  }
}

References ember_ir::rec::Program::data, j, k, p, p_, state, and weights.

input_widths()

const std::vector< size_t > & ember_ir::rec::Recurrence::input_widths

(

)

const

Definition at line 543 of file graph_ir_recurrence.cpp.

{ return p_->in_widths; }

References p_.

operator=()

Recurrence & ember_ir::rec::Recurrence::operator= ( Recurrence &&  )

defaultnoexcept

out_width()

size_t ember_ir::rec::Recurrence::out_width

(

)

const

Definition at line 544 of file graph_ir_recurrence.cpp.

{ return p_->out_width; }

References p_.

slot_errors()

std::string ember_ir::rec::Recurrence::slot_errors

(

const nlohmann::json &

slot

)

const

Definition at line 711 of file graph_ir_recurrence.cpp.

                                                        {
  const std::string name = slot.contains("name") ? slot.at("name").dump() : "?";
  if (slot.value("op", json()) != "recurrence") return "the slot " + name + " of a recurrence is not of op recurrence";
  if (!slot.contains("tensors") || !slot.at("tensors").is_array()) return "the slot " + name + " declares no tensors";
  std::map<std::string, const json*> declared;
  for (const auto& t : slot.at("tensors")) {
    if (!t.is_object() || !t.contains("name") || !t.at("name").is_string())
      return "the slot " + name + " holds a tensor without a name";
    if (!declared.emplace(t.at("name").get<std::string>(), &t).second)
      return "the slot " + name + " declares tensor '" + t.at("name").get<std::string>() + "' twice";
  }
  for (const auto& st : p_->state_info) {
    const auto it = declared.find(st.name);
    if (it == declared.end()) return "the slot " + name + " has no tensor '" + st.name + "' (the update assigns it)";
    const json& t = *it->second;
    const json want_shape = st.shape;
    if (t.value("shape", json()) != want_shape)
      return "the slot " + name + "'s tensor '" + st.name + "' has shape " + t.value("shape", json()).dump() +
             ", the update's is " + want_shape.dump();
    const json init = t.value("init", json());
    if (st.init_body ? init != "body" : init != json(0))
      return "the slot " + name + "'s tensor '" + st.name + "' has init " + init.dump() + ", not " +
             (st.init_body ? "\"body\" (the node's init assigns it)" : "0 (the node's init does not assign it)");
  }
  if (declared.size() != p_->state_info.size()) {
    for (const auto& kv : declared) {
      bool found = false;
      for (const auto& st : p_->state_info) found = found || st.name == kv.first;
      if (!found) return "the slot " + name + "'s tensor '" + kv.first + "' is not one the update assigns";
    }
  }
  return {};
}

References j, name, and p_.

state()

const std::vector< Recurrence::StateTensor > & ember_ir::rec::Recurrence::state

(

)

const

Definition at line 541 of file graph_ir_recurrence.cpp.

{ return p_->state_info; }

References p_, and ember_ir::rec::Program::state_info.

step()

void ember_ir::rec::Recurrence::step	(	const std::vector< const float * > &	in,
		const std::vector< const float * > &	weights,
		const std::vector< float * > &	state,
		float *	out
	)		const

Definition at line 757 of file graph_ir_recurrence.cpp.

                                                                        {
  const Program& p = *p_;
  for (size_t v = 0; v < p.inputs.size(); ++v) p.data[p.inputs[v]] = in[v];
  for (size_t w = 0; w < p.weights.size(); ++w) p.data[p.weights[w]] = weights[w];
  for (size_t s = 0; s < p.states.size(); ++s) p.data[p.states[s]] = state[s];
  for (size_t l = 0; l < p.lets.size(); ++l) {
    p.assign(p.let[l], p.let_buf[l].data());
    p.data[p.lets[l]] = p.let_buf[l].data();
  }
  // The whole new state from the state before the token, then it replaces the old.
  for (size_t s = 0; s < p.states.size(); ++s) p.assign(p.update[s], p.new_state[s].data());
  for (size_t s = 0; s < p.states.size(); ++s) std::copy(p.new_state[s].begin(), p.new_state[s].end(), state[s]);
  p.assign(p.readout, out);
}

References ember_ir::rec::Program::data, in, j, out, p, p_, state, v, and weights.

weights()

const std::vector< Recurrence::WeightDecl > & ember_ir::rec::Recurrence::weights

(

)

const

Definition at line 542 of file graph_ir_recurrence.cpp.

{ return p_->weight_info; }

References p_.

Member Data Documentation

p_

std::unique_ptr<Program> ember_ir::rec::Recurrence::p_

private

Definition at line 76 of file graph_ir_recurrence.h.

Referenced by exact(), input_widths(), out_width(), and weights().

---

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

• graph_ir_recurrence.h
• graph_ir_recurrence.cpp