Method writeTernaryOperator

src/codegen/cppCodeGen.cpp:500–544

}

std::string dnnc::cppCodeGen::writeTernaryOperator(opNode &computeNode,
                                                   std::vector<node *> &ins,
                                                   std::vector<node *> &outs) {
  std::string code;

  assert(ins.size() == 3 && outs.size() == 1);

  std::string opCode = getOpCodeStr(computeNode.symbol());

  std::string opName = computeNode.name();

  assert(opName.length());

  std::string outType = getDNNC_DataTypeStr(computeNode.dtype());
  std::string in1Type = getDNNC_DataTypeStr(ins[0]->dtype());
  std::string in2Type = getDNNC_DataTypeStr(ins[1]->dtype());

  // Step 1: Instantiate opterator
  code += "\n";
  code += _tab + opCode + "<" + outType + ", " + in1Type + ", " + in2Type +
          "> " + opName + "(\"" + opName + "\");\n";

  // Step 2: Add attribute
  for (nodeAttribute attr : computeNode) {
    std::string attrName = getAttrNameStr(attr.name());
    std::string attrVar = opName + "_" + attrName;
    code += initializeData(attr.data(), attrVar);
    code += _tab + opName + ".setAttribute ( attr_" + attrName + ", " +
            attrVar + " );\n";
  }

  // Step 3: Add compute function.
  std::string outTensor = nodeName(&computeNode);
  code += _tab + "tensor<" + outType + "> " + outTensor + " = " + opName +
          ".compute ( " + nodeName(ins[0]) + ", " + nodeName(ins[1]) + ", " +
          nodeName(ins[2]) + ");\n";

  if (_graph.isOutput(computeNode.outputs()[0])) {
    code += "\n" + _tab + "// Write the output tensor in a file.\n";
    code += _tab + outTensor + ".write(\"" + computeNode.outputs()[0] +
            ".out\");\n";
  }

  return code;
}

std::string dnnc::cppCodeGen::writeCustomOperator(opNode &computeNode,
                                                  std::vector<node *> &ins,