daisytuner / sdfglib / 17651658650

CallocNode::CallocNode(

    : LibraryNode(

          element_id,

          debug_info,

          vertex,

          parent,

          {"_ret"},

          {},

      num_(num), size_(size) {}

const symbolic::Expression& CallocNode::num() const { return num_; }

const symbolic::Expression& CallocNode::size() const { return size_; }

void CallocNode::validate(const Function& function) const {}

symbolic::SymbolSet CallocNode::symbols() const {

    auto num_symbols = symbolic::atoms(this->num_);

    auto size_symbols = symbolic::atoms(this->size_);

    num_symbols.insert(size_symbols.begin(), size_symbols.end());

    return num_symbols;

}

    clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {

    return std::make_unique<CallocNode>(element_id, debug_info_, vertex, parent, num_, size_);

void CallocNode::replace(const symbolic::Expression& old_expression, const symbolic::Expression& new_expression) {

    this->size_ = symbolic::subs(this->size_, old_expression, new_expression);

    this->num_ = symbolic::subs(this->num_, old_expression, new_expression);

}

nlohmann::json CallocNodeSerializer::serialize(const data_flow::LibraryNode& library_node) {

    const CallocNode& node = static_cast<const CallocNode&>(library_node);

    nlohmann::json j;

    j["code"] = node.code().value();

    sdfg::serializer::JSONSerializer serializer;

    j["size"] = serializer.expression(node.size());

    j["num"] = serializer.expression(node.num());

    return j;

}

data_flow::LibraryNode& CallocNodeSerializer::deserialize(

    assert(j.contains("code"));

    assert(j.contains("debug_info"));

    assert(j.contains("size"));

    assert(j.contains("num"));

    auto code = j["code"].get<std::string>();

    if (code != LibraryNodeType_Calloc.value()) {

        throw InvalidSDFGException("Invalid library node code");

    sdfg::serializer::JSONSerializer serializer;

    DebugInfoRegion debug_info = serializer.json_to_debug_info_region(j["debug_info"], builder.debug_info());

    SymEngine::Expression size(j.at("size"));

    SymEngine::Expression num(j.at("num"));

    return builder.add_library_node<CallocNode>(parent, debug_info, num, size);

}

CallocNodeDispatcher::CallocNodeDispatcher(

    : codegen::LibraryNodeDispatcher(language_extension, function, data_flow_graph, node) {}

void CallocNodeDispatcher::dispatch_code(

    auto& Calloc_node = static_cast<const CallocNode&>(node_);

    stream << Calloc_node.outputs().at(0);

    stream << " = ";

    stream << "calloc(" << language_extension_.expression(Calloc_node.num()) << ", "

           << language_extension_.expression(Calloc_node.size()) << ")" << ";";

    stream << std::endl;

}