enco Namespace Reference

Data Structures
class	AsmCode
struct	AvgPoolLoweringPass
struct	Backend
struct	BagDuplicationPass
class	Bundle
struct	BypassGenerationPass
struct	Code
struct	ConcatLoweringPass
struct	ConstantFoldingPass
struct	CopyLoweringPass
class	CppCode
struct	DataLayoutConversionPass
struct	DeadBagEliminationPass
struct	DeadObjectEliminationPass
struct	DuplicatedObjectReductionPass
struct	FeatureUnificationPass
struct	FreeInstrEliminationPass
struct	FreeOpEliminationPass
struct	Frontend
struct	GlobalData
class	HostBlockCompiler
struct	IdenticalObjectReductionPass
struct	IndirectCopyEliminationPass
struct	IntrinsicSelectionPass
class	MemoryContext
	Record C/C++ expression that denotes the base and size of memory region dedicated to each bag. More...
class	Pass
struct	PhaseConstructionPass
class	Pipeline
class	SubnetBlockCompiler
	Generate C++ code that invokes Android NN subnet. More...
struct	SubnetManager
struct	SubnetStruct
	A C++ struct that provides Android NN model & compilation. More...
class	SubnetStructBuilder

Typedefs
using	SessionID = uint32_t
using	GlobalOffset = uint32_t

Functions
void	subst (coco::Object *from, coco::Object *into)
	Substitute all the USE occurrences of an object with another object.
std::vector< coco::Instr * >	instr_sequence (coco::Module *m)
	Return instructions in execution order.
coco::FeatureShape	output_shape (coco::Conv2D *conv2D)
bool	validate_output_shape (Code *code)
bool	validate (Code *code)
SessionID	make_session (coco::Module *m, coco::Data *d)
SessionID	session (const coco::Module *m)
SessionID	session (const coco::Data *d)
coco::Module *	module (const SessionID &sess)
coco::Data *	data (const SessionID &sess)
Code *	code (const SessionID &sess)
template<typename It >
void	concat (std::ostream &os, const std::string &sep, It beg, It end)
template<typename It >
std::string	concat (const std::string &sep, It beg, It end)
void	lower_avgpool (enco::Code *)
	Rewrite NN API-incompatible average pooling.
void	lower_concat (enco::Code *code)
	Lower eval(Concat(...)) as a sequence of shuffle instructions.
void	fold_constants (enco::Code *)
	Evaluate "constant" expressions at compile time.
void	lower_copy (enco::Code *code)
	Lower copy(...) instruction into shuffle(...)
void	convert_data_layout (enco::Code *code)
	Insert data reordering if necessary.
void	eliminate_dead_bag (enco::Code *code)
	Eliminate dead bags.
void	eliminate_dead_object (enco::Code *code)
	Eliminate dead objects in IR.
void	duplicate_inout_bag (enco::Code *code)
	Eliminate in/out bags by duplication.
void	reduce_duplicated_object (enco::Code *code)
	Reduce duplicated feature objects as its dominating feature object.
void	eliminate_free_instr (coco::Module *mod)
	Eliminate free instructions.
void	eliminate_free_op (coco::Module *mod)
	Eliminate free op.
void	generate_global_data (std::ostream &, enco::Code *)
	Generate 'Global' weight array.
void	reduce_identical_object (enco::Code *code)
	Reduce identically copied objects as its original object.
void	eliminate_indirect_copy (enco::Code *code)
	Convert all the indirect copies as a direct copy.
void	select_intrinsic (enco::Code *)
	Select Intricsic (API) to be used.
void	generate_bypass_shuffle (enco::Code *code)
	Add a bypass Shuffle if two continued Shuffles map same from-into.
void	hoist_object (enco::Code *code)
	Update the base bag of each object if possible.
void	split_into_phases (enco::Code *code)
	Split instructions into a set of phases.
std::set< coco::Block * >	readers (const coco::Bag *bag)
	Returns the set of blocks that reads a given bag.
std::set< coco::Block * >	updaters (const coco::Bag *bag)
	Return the set of blocks that updates a given bag.

Typedef Documentation

GlobalOffset

using enco::GlobalOffset = typedef uint32_t

Definition at line 27 of file GlobalDataGeneration.h.

SessionID

using enco::SessionID = typedef uint32_t

Definition at line 26 of file Session.h.

Function Documentation

code()

Code * enco::code

(

const SessionID &

sess

)

Definition at line 54 of file Session.cpp.

{ return sess_to_code.at(sess).get(); }

Referenced by convert_data_layout(), duplicate_inout_bag(), eliminate_dead_bag(), eliminate_dead_object(), eliminate_indirect_copy(), fold_constants(), generate_bypass_shuffle(), generate_global_data(), hoist_object(), lower_avgpool(), lower_concat(), lower_copy(), reduce_duplicated_object(), reduce_identical_object(), enco::AvgPoolLoweringPass::run(), enco::ConcatLoweringPass::run(), enco::ConstantFoldingPass::run(), enco::CopyLoweringPass::run(), enco::DataLayoutConversionPass::run(), enco::DeadBagEliminationPass::run(), enco::DeadObjectEliminationPass::run(), enco::BagDuplicationPass::run(), enco::DuplicatedObjectReductionPass::run(), enco::FeatureUnificationPass::run(), enco::FreeInstrEliminationPass::run(), enco::FreeOpEliminationPass::run(), enco::IdenticalObjectReductionPass::run(), enco::IndirectCopyEliminationPass::run(), enco::IntrinsicSelectionPass::run(), enco::BypassGenerationPass::run(), enco::PhaseConstructionPass::run(), select_intrinsic(), split_into_phases(), and validate().

concat() [1/2]

template<typename It >

std::string enco::concat	(	const std::string &	sep,
		It	beg,
		It	end
	)

Definition at line 48 of file String.h.

{
  std::stringstream ss;
  concat(ss, sep, beg, end);
  return ss.str();
}

References concat().

concat() [2/2]

template<typename It >

void enco::concat	(	std::ostream &	os,
		const std::string &	sep,
		It	beg,
		It	end
	)

Definition at line 31 of file String.h.

{
  uint32_t count = 0;
 
  for (auto it = beg; it != end; ++it, ++count)
  {
    if (count == 0)
    {
      os << *it;
    }
    else
    {
      os << sep << *it;
    }
  }
}

References concat().

Referenced by concat(), and concat().

convert_data_layout()

void enco::convert_data_layout

(

enco::Code *

code

)

Insert data reordering if necessary.

Definition at line 377 of file DataLayoutConversion.cpp.

{
  NormalizePass pass;
  pass.runOnCode(code);
}

References code().

Referenced by enco::DataLayoutConversionPass::run().

data()

coco::Data * enco::data

(

const SessionID &

sess

)

Definition at line 52 of file Session.cpp.

{ return sess_to_code.at(sess)->data(); }

duplicate_inout_bag()

void enco::duplicate_inout_bag

(

enco::Code *

code

)

Eliminate in/out bags by duplication.

Definition at line 129 of file Duplicate.cpp.

{
  DuplicatePass duplicate;
  duplicate.runOnCode(code);
}

References code().

Referenced by enco::BagDuplicationPass::run().

eliminate_dead_bag()

void enco::eliminate_dead_bag

(

enco::Code *

code

)

Eliminate dead bags.

A bag is referred to as dead if it is neither input nor output, and has no read. If a bag is dead, it is unnecessary to updates its values as these values are never used.

"eliminate_dead_bag" removes all the dead bags and its updaters from IR.

Definition at line 50 of file DeadBagElimination.cpp.

{
  auto m = code->module();
 
  // Destroy a dead bag and its updaters
  for (auto bag : dead_bags(m))
  {
    for (auto updater : coco::updaters(bag))
    {
      auto ins = updater->loc();
 
      assert(ins != nullptr);
 
      ins->detach();
      m->entity()->instr()->destroy(ins);
    }
 
    bag->replaceWith(nullptr);
    m->entity()->bag()->destroy(bag);
  }
}

References code(), m, enco::Code::module(), and coco::updaters().

Referenced by enco::DeadBagEliminationPass::run().

eliminate_dead_object()

void enco::eliminate_dead_object

(

enco::Code *

code

)

Eliminate dead objects in IR.

An object whose backing bag is unused is referred to as a dead object.

Dead Object Elimination (DOE) eliminates such dead objects along with their producer.

Definition at line 57 of file DeadObjectElimination.cpp.

{
  auto m = code->module();
 
  // Destroy a dead object and its producer
  for (auto obj : dead_objects(m))
  {
    if (auto producer = coco::producer(obj))
    {
      auto ins = producer->loc();
      assert(ins != nullptr);
 
      ins->detach();
      m->entity()->instr()->destroy(ins);
    }
 
    m->entity()->object()->destroy(obj);
  }
}

References code(), m, enco::Code::module(), and coco::producer().

Referenced by enco::DeadObjectEliminationPass::run().

eliminate_free_instr()

void enco::eliminate_free_instr

(

coco::Module *

mod

)

Eliminate free instructions.

An instruction is referred to as "free" if it is not bound to any "block"

Definition at line 57 of file FreeInstrElimination.cpp.

{
  for (auto ins : free_instrs(m))
  {
    destroy(ins);
  }
}

References m.

Referenced by enco::FreeInstrEliminationPass::run().

eliminate_free_op()

void enco::eliminate_free_op

(

coco::Module *

mod

)

Eliminate free op.

An op is referred to as "free" if it is not bound to any "instruction"

Definition at line 51 of file FreeOpElimination.cpp.

{
  for (auto op : candidates(m))
  {
    m->entity()->op()->destroy_all(op);
  }
}

References m.

Referenced by enco::FreeOpEliminationPass::run().

eliminate_indirect_copy()

void enco::eliminate_indirect_copy

(

enco::Code *

code

)

Convert all the indirect copies as a direct copy.

‍BEFORE <<<

obj_0 = ... obj_1 = ... obj_2 = ...

copy(from: obj_0, into: obj_1) copy(from: obj_1, into: obj_2)

‍AFTER <<<

obj_0 = ... obj_1 = ... obj_2 = ...

copy(from: obj_0, into: obj_1) copy(from: obj_0, into: obj_2)

Definition at line 55 of file IndirectCopyElimination.cpp.

{
  auto m = code->module();
 
  for (auto child : linked_copy_instrs(m))
  {
    auto from = child->from();
    assert(from != nullptr);
 
    // Find the irreducible origin
    while (true)
    {
      if (auto producer = coco::producer(from))
      {
        if (auto parent = as_copy(producer->loc()))
        {
          assert(parent->from() != nullptr);
          from = parent->from();
          continue;
        }
      }
 
      break;
    }
 
    child->from(from);
  }
}

References code(), m, enco::Code::module(), and coco::producer().

Referenced by enco::IndirectCopyEliminationPass::run().

fold_constants()

void enco::fold_constants

(

enco::Code *

code

)

Evaluate "constant" expressions at compile time.

Definition at line 419 of file ConstantFolding.cpp.

{
  std::queue<coco::Bag *> q;
 
  // Collect the initial set of "constant" bag
  constant_bag_enumerator(code) << [&q](coco::Bag *bag) { q.push(bag); };
 
  while (!q.empty())
  {
    auto candidate_bag = take(q);
 
    // Scan the readers of each candidate bag
    for (auto reader : coco::readers(candidate_bag))
    {
      // TODO Decide how to handle the reader with unknown instruction
      if (auto ins = reader->loc())
      {
        fold_constant(q, ins);
      }
    }
  }
}

References code(), and coco::readers().

Referenced by enco::ConstantFoldingPass::run().

generate_bypass_shuffle()

void enco::generate_bypass_shuffle

(

enco::Code *

code

)

Add a bypass Shuffle if two continued Shuffles map same from-into.

bag_1 = Bag(size: N) bag_2 = Bag(size: N) bag_3 = Bag(size: N)

‍BEFORE <<<

Shuffle(from: bag_1, into: bag_2, [0 -> 0]) Shuffle(from: bag_2, into: bag_3, [0 -> 0])

Let's refer to the former shuffle as Shuffle 1 and the latter one as Shuffle 2. We can replace Shuffle 2 with new Shuffle 3 as follows when Shuffle 1 and Shuffle 2 map to the same position.

‍AFTER <<<

Shuffle(from: bag_1, into: bag_2, [0 -> 0]) <- Shuffle 1 Shuffle(from: bag_1, into: bag_3, [0 -> 0]) <- Shuffle 3

Note that Shuffle 1 can be eliminated when bag_2 is not used

Definition at line 25 of file Optimizations.cpp.

{
  auto m = code->module();
 
  for (uint32_t n = 0; n < m->entity()->bag()->size(); ++n)
  {
    auto bag = m->entity()->bag()->at(n);
 
    // NOTE The current implementation assumes that all the updates occurs before the first read
    // TODO Remove this assumption
    for (auto u : coco::updaters(bag))
    {
      if ((u->loc() == nullptr) || (u->loc()->asShuffle() == nullptr))
      {
        // Skip if updater is not a Shuffle instruction
        continue;
      }
 
      for (auto r : coco::readers(bag))
      {
        if ((r->loc() == nullptr) || (r->loc()->asShuffle() == nullptr))
        {
          // Skip if reader is not a Shuffle instruction
          continue;
        }
 
        auto shuffle_1 = u->loc()->asShuffle();
        auto shuffle_2 = r->loc()->asShuffle();
 
        // Construct a shuffle instruction
        auto shuffle_3 = m->entity()->instr()->create<coco::Shuffle>();
 
        shuffle_3->from(shuffle_1->from());
        shuffle_3->into(shuffle_2->into());
 
        // Attempt to construct a valid bypass shuffle instruction
        bool valid = true;
 
        for (const auto &C : shuffle_2->range())
        {
          auto B = shuffle_2->at(C);
 
          if (!shuffle_1->defined(B))
          {
            valid = false;
            break;
          }
 
          auto A = shuffle_1->at(B);
 
          shuffle_3->insert(A, C);
        }
 
        if (valid)
        {
          // Insert shuffle_3 before shuffle_2 if shuffle_3 is a valid bypass of shuffle_2
          shuffle_3->insertBefore(shuffle_2);
 
          // NOTE shuffle_2 SHOULD BE detached and destroyed after shuffle_3 is inserted
          shuffle_2->detach();
          m->entity()->instr()->destroy(shuffle_2);
        }
        else
        {
          // Destroy shuffle_3 (bypass shuffle) if it is invalid
          m->entity()->instr()->destroy(shuffle_3);
        }
      }
    }
  }
}

References coco::PtrManager< T >::at(), coco::EntityManager::bag(), code(), coco::Module::entity(), coco::Shuffle::from(), m, enco::Code::module(), coco::readers(), size, and coco::updaters().

Referenced by enco::BypassGenerationPass::run().

generate_global_data()

void enco::generate_global_data	(	std::ostream &	,
		enco::Code *
	)

Generate 'Global' weight array.

NOTE Succeeding passes can access offsets via "GlobalData"

Definition at line 109 of file GlobalDataGeneration.cpp.

{
  auto m = code->module();
  auto d = code->data();
 
  auto ann_ctx = enco::SubnetManager::context(m);
 
  auto global = make_unique<Global>(os);
 
  //
  // Emit Bag's weight
  //
  for (uint32_t n = 0; n < m->entity()->bag()->size(); ++n)
  {
    auto bag = m->entity()->bag()->at(n);
 
    if (!d->allocated(bag))
    {
      // Skip if the weight value does not exist for a given bag
      continue;
    }
 
    // NOTE The current implementation assumes that all the values are of float(fp32) type
    // TODO Support non-float values
    auto span = d->f32()->weight(bag);
 
    assert(span.data() != nullptr);
    assert(span.size() > 0);
 
    auto const base = reinterpret_cast<const uint8_t *>(span.data());
    uint32_t const size = span.size() * sizeof(float);
 
    assert(bag_data_offset_ctx.find(bag) == bag_data_offset_ctx.end());
    bag_data_offset_ctx[bag] = global->constant(base, size);
  }
 
  for (uint32_t n = 0; n < ann_ctx->count(); ++n)
  {
    auto binder = ann_ctx->nth(n);
 
    auto emit = [&](const ann::OperandID & /*id*/, const ann::Operand *info) {
      if (info->weight())
      {
        auto base = info->weight()->base();
        auto size = info->weight()->size();
 
        data_offset_ctx[info] = global->constant(base, size);
      }
    };
    binder->module()->operand()->each(emit);
  }
 
  for (uint32_t n = 0; n < m->input()->size(); ++n)
  {
    auto input = m->input()->at(n);
    auto dims = as_dims(input->shape());
 
    name_offset_ctx[input] = global->constant(input->name());
    dims_offset_ctx[input] = global->constant<uint32_t>(dims);
  }
 
  for (uint32_t n = 0; n < m->output()->size(); ++n)
  {
    auto output = m->output()->at(n);
    auto dims = as_dims(output->shape());
 
    name_offset_ctx[output] = global->constant(output->name());
    dims_offset_ctx[output] = global->constant<uint32_t>(dims);
  }
}

References code(), enco::SubnetManager::context(), enco::Code::data(), info, m, enco::Code::module(), and size.

hoist_object()

void enco::hoist_object

(

enco::Code *

code

)

Update the base bag of each object if possible.

— Case 1 — Let us consider the following code:

bag_1 = Bag(size: 4) bag_2 = Bag(size: 1)

obj_1 = ... at bag_1 obj_2 = ... at bag_2

... Shuffle(from: bag_1, into: bag_2, [0 -> 0]) <- shuffle ...

Note that the content of bag_2 after shuffle is identical to a part of bag_1, so the following code is identical to the above code

bag_1 = Bag(size: 4) bag_2 = Bag(size: 1)

obj_1 = ... at bag_1 obj_2 = ... at bag_1

... Shuffle(from: bag_1, into: bag_2, [0 -> 0]) ...

— Case 2 — Let us consider the following code:

bag_1 = Bag(size: 4) bag_2 = Bag(size: 1) bag_3 = Bag(size: 1)

obj_1 = ... at bag_2 obj_2 = ... at bag_3

Shuffle(from: bag_1, into: bag_2, [0 -> 0]) <- shuffle_1 Shuffle(from: bag_1, into: bag_3, [0 -> 0]) <- shuffle_2

Note that the content of bag_3 after shuffle_2 is identical to that of bag_2 after shuffle_1, so the following code is identical to the above one:

bag_1 = Bag(size: 4) bag_2 = Bag(size: 1) bag_3 = Bag(size: 1)

obj_1 = ... at bag_2 obj_2 = ... at bag_2 <- HERE

Shuffle(from: bag_1, into: bag_2, [0 -> 0]) <- shuffle_1 Shuffle(from: bag_1, into: bag_3, [0 -> 0]) <- shuffle_2

"hoist_object" optimization rewrites the former code as the latter one.

NOTE "hoist_object" DOES NOT change any instruction. It just updates the base bag of objects of interest.

Definition at line 175 of file Optimizations.cpp.

{
  auto m = code->module();
 
  //
  // Case 1
  //
  for (uint32_t n = 0; n < m->entity()->instr()->size(); ++n)
  {
    if (auto shuffle = m->entity()->instr()->at(n)->asShuffle())
    {
      if (shuffle->parent() == nullptr)
      {
        continue;
      }
 
      if (hoistable(shuffle))
      {
        auto from = shuffle->from();
        auto into = shuffle->into();
 
        into->replaceAllDepsWith(from);
      }
    }
  }
 
  //
  // Case 2
  //
  for (uint32_t n = 0; n < m->entity()->bag()->size(); ++n)
  {
    auto bag = m->entity()->bag()->at(n);
 
    std::map<CodeIndex, coco::Shuffle *> collected;
 
    for (auto reader : coco::readers(bag))
    {
      if (auto ins = reader->loc())
      {
        if (auto shuffle = ins->asShuffle())
        {
          collected[code_index(shuffle)] = shuffle;
        }
      }
    }
 
    std::vector<coco::Shuffle *> sorted;
 
    for (auto it = collected.begin(); it != collected.end(); ++it)
    {
      sorted.emplace_back(it->second);
    }
 
    for (uint32_t curr = 0; curr < sorted.size(); ++curr)
    {
      auto const curr_ins = sorted.at(curr);
      auto const curr_bag = curr_ins->into();
 
      if (!complete(curr_ins))
      {
        continue;
      }
 
      for (uint32_t next = curr + 1; next < sorted.size(); ++next)
      {
        auto const next_ins = sorted.at(next);
        auto const next_bag = next_ins->into();
 
        if (!complete(next_ins))
        {
          continue;
        }
 
        if (compatible(curr_ins, next_ins))
        {
          next_bag->replaceAllDepsWith(curr_bag);
        }
      }
    }
  }
}

References coco::Shuffle::asShuffle(), coco::Shuffle::at(), code(), coco::Shuffle::from(), coco::Shuffle::into(), m, enco::Code::module(), coco::DLinkedList< Child, Parent >::Node::parent(), coco::readers(), coco::Bag::replaceAllDepsWith(), and size.

instr_sequence()

std::vector< coco::Instr * > enco::instr_sequence

(

coco::Module *

m

)

Return instructions in execution order.

Definition at line 50 of file IRUtils.cpp.

{
  std::vector<coco::Instr *> res;
 
  for (auto B = m->block()->head(); B; B = B->next())
  {
    for (auto I = B->instr()->head(); I; I = I->next())
    {
      res.emplace_back(I);
    }
  }
 
  return res;
}

References m.

Referenced by reduce_identical_object().

lower_avgpool()

void enco::lower_avgpool

(

enco::Code *

code

)

Rewrite NN API-incompatible average pooling.

Definition at line 223 of file AvgPoolLowering.cpp.

{
  AvgPoolRewritePass pass;
  pass.runOnCode(code);
}

References code().

Referenced by enco::AvgPoolLoweringPass::run().

lower_concat()

void enco::lower_concat

(

enco::Code *

code

)

Lower eval(Concat(...)) as a sequence of shuffle instructions.

Definition at line 101 of file ConcatLowering.cpp.

{
  auto m = code->module();
 
  for (auto eval : candidates(m))
  {
    auto concat_f = eval->op()->asConcatF();
    assert(concat_f != nullptr);
 
    auto left_feature = concat_f->left()->asLoad()->object()->asFeature();
    assert(left_feature != nullptr);
    auto left_shape = as_tensor_shape(left_feature->layout());
 
    auto right_feature = concat_f->right()->asLoad()->object()->asFeature();
    assert(right_feature != nullptr);
    auto right_shape = as_tensor_shape(right_feature->layout());
 
    auto out_feature = eval->out()->asFeature();
    assert(out_feature != nullptr);
    auto out_shape = as_tensor_shape(out_feature->layout());
 
    auto concat_axe = as_tensor_axis(concat_f->axis());
 
    // Lower: Left -> Output
    {
      auto src_feature = left_feature;
      auto src_shape = left_shape;
 
      auto ins = m->entity()->instr()->create<coco::Shuffle>();
 
      assert(src_feature->bag() != nullptr);
      assert(out_feature->bag() != nullptr);
 
      ins->from(src_feature->bag());
      ins->into(out_feature->bag());
 
      for (tensor::IndexEnumerator e{src_shape}; e.valid(); e.advance())
      {
        tensor::Index src_index = e.current();
        tensor::Index out_index = e.current();
 
        auto from = as_element_index(src_feature->layout(), src_index);
        auto into = as_element_index(out_feature->layout(), out_index);
 
        ins->insert(from, into);
      }
 
      ins->insertAfter(eval);
    }
 
    // Lower: Right -> Output
    {
      auto src_feature = right_feature;
      auto src_shape = right_shape;
 
      auto ins = m->entity()->instr()->create<coco::Shuffle>();
 
      assert(src_feature->bag() != nullptr);
      assert(out_feature->bag() != nullptr);
 
      ins->from(src_feature->bag());
      ins->into(out_feature->bag());
 
      for (tensor::IndexEnumerator e{src_shape}; e.valid(); e.advance())
      {
        tensor::Index src_index = e.current();
        tensor::Index out_index = e.current();
 
        out_index.at(concat_axe) = out_index.at(concat_axe) + left_shape.dim(concat_axe);
 
        auto from = as_element_index(src_feature->layout(), src_index);
        auto into = as_element_index(out_feature->layout(), out_index);
 
        ins->insert(from, into);
      }
 
      ins->insertAfter(eval);
    }
 
    // Unlink "Eval" and "ConcatF" op tree
    eval->op(nullptr);
 
    // Delete "Concat" op tree
    m->entity()->op()->destroy(concat_f->left());
    m->entity()->op()->destroy(concat_f->right());
    m->entity()->op()->destroy(concat_f);
 
    // Deatch "Eval" instruction from the block
    eval->detach();
 
    // Delete "Eval" instruction
    m->entity()->instr()->destroy(eval);
  }
}

References nncc::core::ADT::tensor::Index::at(), code(), m, enco::Code::module(), and nncc::core::ADT::tensor::IndexEnumerator::valid().

Referenced by enco::ConcatLoweringPass::run().

lower_copy()

void enco::lower_copy

(

enco::Code *

code

)

Lower copy(...) instruction into shuffle(...)

Definition at line 28 of file CopyLowering.cpp.

{
  auto m = code->module();
 
  std::set<coco::Copy *> lowered_copies;
 
  for (uint32_t n = 0; n < m->entity()->instr()->size(); ++n)
  {
    auto ins = m->entity()->instr()->at(n);
 
    assert(ins != nullptr);
 
    if (ins->parent() == nullptr)
    {
      // Skip if instruction does not belong to a list
      continue;
    }
 
    auto copy = ins->asCopy();
 
    if (copy == nullptr)
    {
      // Skip if instruction is not a copy
      continue;
    }
 
    // TODO Support non-Feature objects
    auto ifm = copy->from()->asFeature();
    auto ofm = copy->into()->asFeature();
 
    if ((ifm == nullptr) || (ofm == nullptr))
    {
      continue;
    }
 
    assert(ifm->layout()->batch() == ofm->layout()->batch());
    assert(ifm->layout()->shape() == ofm->layout()->shape());
 
    auto shuffle = m->entity()->instr()->create<coco::Shuffle>();
 
    shuffle->from(ifm->bag());
    shuffle->into(ofm->bag());
 
    const uint32_t B = ifm->layout()->batch();
    const uint32_t C = ifm->layout()->shape().depth();
    const uint32_t H = ifm->layout()->shape().height();
    const uint32_t W = ifm->layout()->shape().width();
 
    for (uint32_t b = 0; b < B; ++b)
    {
      for (uint32_t ch = 0; ch < C; ++ch)
      {
        for (uint32_t row = 0; row < H; ++row)
        {
          for (uint32_t col = 0; col < W; ++col)
          {
            const auto from = ifm->layout()->at(b, ch, row, col);
            const auto into = ofm->layout()->at(b, ch, row, col);
 
            shuffle->insert(from, into);
          }
        }
      }
    }
 
    shuffle->insertBefore(copy);
    lowered_copies.insert(copy);
  }
 
  // Destroy lowered copy
  for (const auto &copy : lowered_copies)
  {
    copy->detach();
    m->entity()->instr()->destroy(copy);
  }
}

References coco::PtrManager< T >::at(), code(), coco::Module::entity(), coco::Shuffle::from(), coco::EntityManager::instr(), m, enco::Code::module(), and size.

Referenced by enco::CopyLoweringPass::run().

make_session()

SessionID enco::make_session	(	coco::Module *	m,
		coco::Data *	d
	)

Definition at line 36 of file Session.cpp.

{
  static uint32_t sess = 0;
  SessionID curr{sess++};
 
  sess_to_code[curr] = make_unique<Code>(m, d);
  module_to_sess[m] = curr;
  data_to_sess[d] = curr;
 
  return curr;
}

References m.

module()

coco::Module * enco::module

(

const SessionID &

sess

)

Definition at line 51 of file Session.cpp.

{ return sess_to_code.at(sess)->module(); }

Referenced by validate_output_shape().

output_shape()

coco::FeatureShape enco::output_shape

(

coco::Conv2D *

conv2D

)

Definition at line 24 of file IRValidator.cpp.

{
  auto load = conv2D->arg()->asLoad();
  assert(load);
 
  auto ifm = load->object()->asFeature();
  assert(ifm);
 
  auto ker = conv2D->ker();
  auto stride = conv2D->stride();
  auto pad = conv2D->pad();
 
  auto striding_width = ifm->shape().width() + pad->left() + pad->right() - ker->shape().width();
  auto striding_height = ifm->shape().height() + pad->top() + pad->bottom() - ker->shape().height();
 
  // Normally the formula is round(striding_width)/stride->horizontal.
  // in coco IR, striding_width should be a multiple of stride->horizontal(), so round(...) was
  // removed. So does striding_height.
  assert(striding_width % stride->horizontal() == 0);
  assert(striding_height % stride->vertical() == 0);
 
  auto ofm_width = striding_width / stride->horizontal() + 1;
  auto ofm_height = striding_height / stride->vertical() + 1;
 
  return coco::FeatureShape(ifm->shape().batch(), ker->shape().count(), ofm_height, ofm_width);
}

References coco::Conv2D::arg(), coco::Conv2D::ker(), coco::Padding2D::left(), coco::Conv2D::pad(), and coco::Conv2D::stride().

readers()

std::set< coco::Block * > enco::readers

(

const coco::Bag *

bag

)

Returns the set of blocks that reads a given bag.

Definition at line 22 of file Usage.cpp.

{
  std::set<coco::Block *> res;
 
  for (auto read : coco::readers(bag))
  {
    assert(read != nullptr);
    auto instr = read->loc();
    assert(instr != nullptr);
    auto block = instr->parent();
    assert(block != nullptr);
 
    res.insert(block);
  }
 
  return res;
}

References coco::readers().

reduce_duplicated_object()

void enco::reduce_duplicated_object

(

enco::Code *

code

)

Reduce duplicated feature objects as its dominating feature object.

‍BEFORE <<<

obj_0 = Feature(layout: ???) at ... obj_1 = Feature(layout: BHWC) at ... obj_2 = Feature(layout: BHWC) at ...

copy(from: obj_0, into: obj_1) copy(from: obj_0, into: obj_2)

... Use(obj_1) Use(obj_2) ...

‍AFTER <<<

obj_0 = Feature(layout: ???) at ... obj_1 = Feature(layout: BHWC) at ... obj_2 = Feature(layout: BHWC) at ...

copy(from: obj_0, into: obj_1) copy(from: obj_0, into: obj_2)

... Use(obj_1) Use(obj_1) <– CHANGED ...

NOTE Given a set of feature objects, a feature object referred to as a dominating feature object if its producer proceeds the producer of every feature object in the given set

Definition at line 81 of file DuplicatedObjectReduction.cpp.

{
  auto m = code->module();
 
  for (const auto &src : features(m))
  {
    auto copied = candidates(src);
 
    if (copied.size() <= 1)
    {
      continue;
    }
 
    // Find the dominator
    coco::FeatureObject *dominator = nullptr;
 
    for (auto candidate : copied)
    {
      if (dominator == nullptr)
      {
        dominator = candidate;
      }
      else if (code_index(coco::producer(candidate)) < code_index(coco::producer(dominator)))
      {
        dominator = candidate;
      }
    }
 
    // Replace all the occurunce of dominated objects with its dominator
    copied.erase(dominator);
 
    for (auto dominatee : copied)
    {
      subst(dominatee, dominator);
    }
  }
}

References code(), m, enco::Code::module(), coco::producer(), and subst().

Referenced by enco::DuplicatedObjectReductionPass::run().

reduce_identical_object()

void enco::reduce_identical_object

(

enco::Code *

code

)

Reduce identically copied objects as its original object.

‍BEFORE <<<

bag_0 = Bag(size: N) bag_1 = Bag(size: N)

obj_0 = Feature(layout: BHWC) at bag_0 obj_1 = Feature(layout: BHWC) at bag_1

copy(from: obj_0, into: obj_1) ... Use(obj_0) Use(obj_1) ...

‍AFTER <<<

bag_0 = Bag(size: N) bag_1 = Bag(size: N)

obj_0 = Feature(layout: BHWC) at bag_0 obj_1 = Feature(layout: BHWC) at bag_1

copy(from: obj_0, into: obj_1) ... Use(obj_0) Use(obj_0) <- obj_1 is replaced ...

Definition at line 25 of file IdenticalObjectReduction.cpp.

{
  auto m = code->module();
 
  std::set<coco::Copy *> detached;
 
  // Preceding optimizations may generate "free" instructions.
  //  - i.e. an instruction not linked to a block
  //
  // Let's iterate over only a sequence of "bounded" instructions.
  for (auto ins : instr_sequence(m))
  {
    assert(ins != nullptr);
    assert(ins->parent() != nullptr);
 
    auto copy = ins->asCopy();
 
    if (copy == nullptr)
    {
      // Skip if instruction is not a copy
      continue;
    }
 
    // TODO Support non-Feature Objects
    auto ifm = copy->from()->asFeature();
    auto ofm = copy->into()->asFeature();
 
    assert(ofm->bag() != nullptr);
 
    if (ifm->layout()->id() != ofm->layout()->id())
    {
      continue;
    }
 
    if (ifm->layout()->id() != coco::FeatureLayouts::BHWC::uid())
    {
      continue;
    }
 
    // Skip if this copy produces network output
    if (ofm->bag()->output())
    {
      // TODO Optimize this case
      //
      // Note that the code under optimization is of the following form:
      //
      //   %ifm <- Instr(...)
      //   %ofm <- Copy(%ifm)
      //
      // Let's assume that "Copy" is the only reader of %ifm (to be precise, its bag).
      //
      // Then, it is possible to rewrite the above fragment as follows:
      //
      //   %ofm <- Instr(...)
      //
      continue;
    }
 
    if (ofm->bag()->reads()->size() > 0)
    {
      // Let us consider the following code:
      //
      // Bag:
      //   %bag_0 = Bag(...)
      //   %bag_1 = Bag(...)
      //   %bag_2 = Bag(...)
      //
      // Object:
      //   %obj_0 = FeatureObject(bag: %bag_0)
      //   %obj_1 = FeatureObject(bag: %bag_1)
      //
      // Instr:
      //   copy an object from %obj_0 into %obj_1
      //   shuffle values from %bag_1 into %bag_2
      //   eval Conv2D with %obj_1
      //
      // Identical Object Reduction (IOR) tries to eliminate the first copy via
      // substitution (substitute all the occurrence of %obj_1 as use with %obj_0).
      //
      // Here is the code transformed by IOR:
      //
      // Bag:
      //   %bag_0 = Bag(...)
      //   %bag_1 = Bag(...)
      //   %bag_2 = Bag(...)
      //
      // Object:
      //   %obj_0 = FeatureObject(bag: %bag_0)
      //   %obj_1 = FeatureObject(bag: %bag_1)
      //
      // Instr:
      //   shuffle values from %bag_1 into %bag_2
      //   eval Conv2D with %obj_0
      //
      // Note that there is no updater of %bag_1 after IOR, and thus the behavior
      // of the first shuffle instruction has changed.
      //
      // This examples shows that it is impossible to simply substitute %obj_1
      // with %obj_0 in the presence of readers over its backing bag.
      continue;
    }
 
    subst(copy->into(), copy->from());
 
    copy->detach();
    detached.insert(copy);
  }
 
  for (auto copy : detached)
  {
    m->entity()->instr()->destroy(copy);
  }
}

References code(), instr_sequence(), m, enco::Code::module(), subst(), and coco::FeatureLayouts::BHWC::uid().

Referenced by enco::IdenticalObjectReductionPass::run().

select_intrinsic()

void enco::select_intrinsic

(

enco::Code *

)

Select Intricsic (API) to be used.

This pass is analogue of "Instruction Selection" pass. This "Intrisic Selection" pass will replace a general coco IR instruction into a backend-specific coco (extended) IR instruction.

Definition at line 77 of file IntrinsicSelection.cpp.

{
  auto m = code->module();
 
  for (auto blk = m->block()->head(); blk; blk = blk->next())
  {
    auto ins = blk->instr()->head();
 
    while (ins)
    {
      if (auto rewritten_ins = rewrite(ins))
      {
        rewritten_ins->insertBefore(ins);
        ins->detach();
 
        ins = rewritten_ins;
      }
 
      ins = ins->next();
    }
  }
}

References code(), m, and enco::Code::module().

Referenced by enco::IntrinsicSelectionPass::run().

session() [1/2]

SessionID enco::session

(

const coco::Data *

d

)

Definition at line 49 of file Session.cpp.

{ return data_to_sess.at(d); }

session() [2/2]

SessionID enco::session

(

const coco::Module *

m

)

Definition at line 48 of file Session.cpp.

{ return module_to_sess.at(m); }

References m.

split_into_phases()

void enco::split_into_phases

(

enco::Code *

code

)

Split instructions into a set of phases.

Definition at line 1227 of file Split.cpp.

{
  SplitPass split;
  split.runOnCode(code);
}

References code().

Referenced by enco::PhaseConstructionPass::run().

subst()

void enco::subst	(	coco::Object *	from,
		coco::Object *	into
	)

Substitute all the USE occurrences of an object with another object.

Replace all the "USE" of 'from' with 'into'.

Parameters

from	Object to be replaced
into	Object to be used instead NOTE This maybe used when something like – 'from' will be removed so we need to replace object Consumers that use 'from' to 'into' EXAMPLE { subst(child, bigone); m->entity()->object()->destroy(child); } This code will change all the Consumers that use 'child' to 'bigone' and destroy the 'child' object.

NOTE subst(from, into) WILL NOT update 'DEF'

Definition at line 38 of file IRUtils.cpp.

{
  assert(from != into);
 
  while (!from->uses()->empty())
  {
    auto use = *(from->uses()->begin());
 
    use->value(into);
  }
}

References coco::Object::uses().

Referenced by reduce_duplicated_object(), and reduce_identical_object().

updaters()

std::set< coco::Block * > enco::updaters

(

const coco::Bag *

bag

)

Return the set of blocks that updates a given bag.

Definition at line 40 of file Usage.cpp.

{
  std::set<coco::Block *> res;
 
  for (auto update : coco::updaters(bag))
  {
    assert(update != nullptr);
    auto instr = update->loc();
    assert(instr != nullptr);
    auto block = instr->parent();
    assert(block != nullptr);
 
    res.insert(block);
  }
 
  return res;
}

References coco::updaters().

validate()

bool enco::validate

(

Code *

code

)

Definition at line 83 of file IRValidator.cpp.

{ return validate_output_shape(code); }

References code(), validate(), and validate_output_shape().

Referenced by validate().

validate_output_shape()

bool enco::validate_output_shape

(

Code *

code

)

Definition at line 51 of file IRValidator.cpp.

{
  auto module = code->module();
 
  // for each eval ( conv2d ( ... ) ), check the output shape of conv2D matches output of eval
  for (auto blk = module->block()->head(); blk; blk = blk->next())
  {
    for (auto instr = blk->instr()->head(); instr; instr = instr->next())
    {
      auto eval = instr->asEval();
      if (eval == nullptr)
        continue;
 
      auto op = eval->op();
      if (!op->asConv2D())
        continue;
 
      auto conv2D = op->asConv2D();
      auto expected_shape = output_shape(conv2D);
 
      auto eval_out = eval->out()->asFeature();
      assert(eval_out);
 
      auto actual_shape = eval_out->shape();
 
      if (actual_shape != expected_shape)
        return false;
    }
  }
  return true;
}

References coco::Module::block(), coco::DLinkedList< Child, Parent >::Head::head(), module(), and output_shape.

Referenced by validate().