hgl_writer.cpp

Go to the documentation of this file.

#include "hgl_writer/hgl_writer.h"
 
#include "hal_core/netlist/gate_library/gate_library.h"
#include "hal_core/netlist/gate_library/gate_type_component/ff_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/init_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/latch_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/lut_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/ram_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/ram_port_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/state_component.h"
#include "hal_core/utilities/log.h"
#include "rapidjson/filewritestream.h"
#include "rapidjson/prettywriter.h"
 
#include <algorithm>
#include <iostream>
#include <string>
 
namespace hal
{
    bool HGLWriter::write(const GateLibrary* gate_lib, const std::filesystem::path& file_path)
    {
        if (gate_lib == nullptr)
        {
            log_error("hgl_writer", "received a nullptr as gate library.", file_path.string());
            return false;
        }
 
        FILE* fp = fopen(file_path.string().c_str(), "w");
        if (fp == NULL)
        {
            log_error("hgl_writer", "unable to open '{}' for writing.", file_path.string());
            return false;
        }
 
        rapidjson::Document document;
        document.SetObject();
 
        if (!write_gate_library(document, gate_lib))
        {
            fclose(fp);
            return false;
        }
 
        char writeBuffer[65536];
        rapidjson::FileWriteStream os(fp, writeBuffer, sizeof(writeBuffer));
 
        rapidjson::PrettyWriter<rapidjson::FileWriteStream> writer(os);
        document.Accept(writer);
 
        fclose(fp);
 
        return true;
    }
 
    bool HGLWriter::write_gate_library(rapidjson::Document& document, const GateLibrary* gate_lib)
    {
        rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
 
        // file format version
        document.AddMember("version", HGL_FORMAT_VERSION, allocator);
 
        // library name
        document.AddMember("library", gate_lib->get_name(), allocator);
 
        // gate location data specification
        rapidjson::Value gate_locs(rapidjson::kObjectType);
        gate_locs.AddMember("data_category", gate_lib->get_gate_location_data_category(), allocator);
        const std::pair<std::string, std::string>& location_identifiers = gate_lib->get_gate_location_data_identifiers();
        gate_locs.AddMember("data_x_identifier", location_identifiers.first, allocator);
        gate_locs.AddMember("data_y_identifier", location_identifiers.second, allocator);
        document.AddMember("gate_locations", gate_locs, allocator);
 
        // gate types
        std::vector<GateType*> gate_types;
 
        for (const auto& gt : gate_lib->get_gate_types())
        {
            if ((gt.first != "HAL_GND") && (gt.first != "HAL_VDD"))
            {
                gate_types.push_back(gt.second);
            }
        }
 
        std::sort(gate_types.begin(), gate_types.end(), [](GateType* l, GateType* r) { return l->get_id() < r->get_id(); });
 
        rapidjson::Value cells(rapidjson::kArrayType);
        for (const auto gt : gate_types)
        {
            rapidjson::Value cell(rapidjson::kObjectType);
 
            // name
            cell.AddMember("name", gt->get_name(), allocator);
 
            // base type
            std::set<GateTypeProperty> properties = gt->get_properties();
 
            rapidjson::Value bts(rapidjson::kArrayType);
 
            for (const auto& property : properties)
            {
                std::string bt_str = enum_to_string<GateTypeProperty>(property);
                bts.PushBack(rapidjson::Value{}.SetString(bt_str.c_str(), bt_str.length(), allocator), allocator);
            }
 
            cell.AddMember("types", bts, allocator);
 
            // parameters: declared at the gate-type level. Variables in Boolean functions whose
            // names match a parameter are sized according to the declaration when re-parsed.
            const auto& parameters = gt->get_parameters();
            if (!parameters.empty())
            {
                rapidjson::Value params_array(rapidjson::kArrayType);
                for (const auto& [pname, p] : parameters)
                {
                    rapidjson::Value entry(rapidjson::kObjectType);
                    entry.AddMember("name", rapidjson::Value{}.SetString(pname.c_str(), pname.length(), allocator), allocator);
                    switch (p.get_type())
                    {
                        case Parameter::Type::Boolean:
                            entry.AddMember("type", "boolean", allocator);
                            break;
                        case Parameter::Type::BitVector:
                            entry.AddMember("type", "bit_vector", allocator);
                            entry.AddMember("size", static_cast<u32>(p.get_size()), allocator);
                            break;
                        case Parameter::Type::LogicVector:
                            entry.AddMember("type", "logic_vector", allocator);
                            entry.AddMember("size", static_cast<u32>(p.get_size()), allocator);
                            break;
                        case Parameter::Type::Integer:
                            entry.AddMember("type", "integer", allocator);
                            break;
                        case Parameter::Type::String:
                            entry.AddMember("type", "string", allocator);
                            break;
                        case Parameter::Type::Float:
                            entry.AddMember("type", "float", allocator);
                            break;
                        case Parameter::Type::Time:
                            entry.AddMember("type", "time", allocator);
                            break;
                        case Parameter::Type::Enum: {
                            entry.AddMember("type", "enum", allocator);
                            rapidjson::Value values_array(rapidjson::kArrayType);
                            for (const auto& v : p.get_enum_values())
                            {
                                values_array.PushBack(rapidjson::Value{}.SetString(v.c_str(), v.length(), allocator), allocator);
                            }
                            entry.AddMember("values", values_array, allocator);
                            break;
                        }
                    }
                    entry.AddMember("default", rapidjson::Value{}.SetString(p.get_default_value().c_str(), p.get_default_value().length(), allocator), allocator);
                    params_array.PushBack(entry, allocator);
                }
                cell.AddMember("parameters", params_array, allocator);
            }
 
            std::unordered_map<std::string, BooleanFunction> functions = gt->get_boolean_functions();
 
            // lut_config, ff_config, latch_config, ram_config
            if (LUTComponent* lut_component = gt->get_component_as<LUTComponent>([](const GateTypeComponent* c) { return LUTComponent::is_class_of(c); }); lut_component != nullptr)
            {
                rapidjson::Value lut_config(rapidjson::kObjectType);
 
                rapidjson::Value output_pins(rapidjson::kArrayType);
                const auto& pin_configs = lut_component->get_output_pin_configs();
                for (const GatePin* pin : gt->get_pins([](const GatePin* p) { return p->get_type() == PinType::lut; }))
                {
                    const std::string& pin_name = pin->get_name();
                    rapidjson::Value entry(rapidjson::kObjectType);
                    entry.AddMember("pin", rapidjson::Value{}.SetString(pin_name.c_str(), pin_name.length(), allocator), allocator);
                    const auto it = pin_configs.find(pin_name);
                    if (it == pin_configs.end())
                    {
                        log_error("hgl_writer", "LUT gate type '{}': output pin '{}' has no INIT config — skipping.", gt->get_name(), pin_name);
                        continue;
                    }
                    const auto& cfg = it->second;
                    entry.AddMember("data_identifier", rapidjson::Value{}.SetString(cfg.init_identifier.c_str(), cfg.init_identifier.length(), allocator), allocator);
                    entry.AddMember("bit_offset", cfg.bit_offset, allocator);
                    entry.AddMember("bit_count", cfg.bit_count, allocator);
                    entry.AddMember("is_ascending", cfg.is_ascending, allocator);
                    rapidjson::Value input_pins_arr(rapidjson::kArrayType);
                    for (const auto& ip : cfg.input_pins)
                    {
                        input_pins_arr.PushBack(rapidjson::Value{}.SetString(ip.c_str(), ip.length(), allocator), allocator);
                    }
                    entry.AddMember("input_pins", input_pins_arr, allocator);
                    output_pins.PushBack(entry, allocator);
                }
                lut_config.AddMember("output_pins", output_pins, allocator);
                cell.AddMember("lut_config", lut_config, allocator);
            }
            else if (FFComponent* ff_component = gt->get_component_as<FFComponent>([](const GateTypeComponent* c) { return FFComponent::is_class_of(c); }); ff_component != nullptr)
            {
                rapidjson::Value ff_config(rapidjson::kObjectType);
 
                StateComponent* state_component = ff_component->get_component_as<StateComponent>([](const GateTypeComponent* c) { return StateComponent::is_class_of(c); });
                if (state_component == nullptr)
                {
                    log_error("hgl_writer", "missing StateComponent for FF state identifiers of gate type '{}'.", gt->get_name());
                    return false;
                }
 
                ff_config.AddMember("state", state_component->get_state_identifier(), allocator);
                ff_config.AddMember("neg_state", state_component->get_neg_state_identifier(), allocator);
 
                InitComponent* init_component = state_component->get_component_as<InitComponent>([](const GateTypeComponent* c) { return InitComponent::is_class_of(c); });
                if (init_component != nullptr)
                {
                    // data_category, data_identifier
                    ff_config.AddMember("data_category", init_component->get_init_category(), allocator);
                    ff_config.AddMember("data_identifier", init_component->get_init_identifiers().front(), allocator);
                }
 
                // next_state, clocked_on, clear_on, preset_on
                ff_config.AddMember("next_state", ff_component->get_next_state_function().to_string(), allocator);
                ff_config.AddMember("clocked_on", ff_component->get_clock_function().to_string(), allocator);
                if (BooleanFunction bf = ff_component->get_async_reset_function(); !bf.is_empty())
                {
                    ff_config.AddMember("clear_on", bf.to_string(), allocator);
                }
                if (BooleanFunction bf = ff_component->get_async_set_function(); !bf.is_empty())
                {
                    ff_config.AddMember("preset_on", bf.to_string(), allocator);
                }
 
                std::pair<AsyncSetResetBehavior, AsyncSetResetBehavior> cp_behav = ff_component->get_async_set_reset_behavior();
                if (cp_behav.first != AsyncSetResetBehavior::undef)
                {
                    ff_config.AddMember("state_clear_preset", enum_to_string<AsyncSetResetBehavior>(cp_behav.first), allocator);
                }
                if (cp_behav.second != AsyncSetResetBehavior::undef)
                {
                    ff_config.AddMember("neg_state_clear_preset", enum_to_string<AsyncSetResetBehavior>(cp_behav.second), allocator);
                }
 
                cell.AddMember("ff_config", ff_config, allocator);
            }
            else if (LatchComponent* latch_component = gt->get_component_as<LatchComponent>([](const GateTypeComponent* c) { return LatchComponent::is_class_of(c); }); latch_component != nullptr)
            {
                rapidjson::Value latch_config(rapidjson::kObjectType);
 
                StateComponent* state_component = latch_component->get_component_as<StateComponent>([](const GateTypeComponent* c) { return StateComponent::is_class_of(c); });
                if (state_component == nullptr)
                {
                    log_error("hgl_writer", "missing StateComponent for latch state identifiers of gate type '{}'.", gt->get_name());
                    return false;
                }
 
                latch_config.AddMember("state", state_component->get_state_identifier(), allocator);
                latch_config.AddMember("neg_state", state_component->get_neg_state_identifier(), allocator);
 
                // next_state, clocked_on, clear_on, preset_on
                if (BooleanFunction bf = latch_component->get_data_in_function(); !bf.is_empty())
                {
                    latch_config.AddMember("data_in", bf.to_string(), allocator);
                }
                if (BooleanFunction bf = latch_component->get_enable_function(); !bf.is_empty())
                {
                    latch_config.AddMember("enable_on", bf.to_string(), allocator);
                }
                if (BooleanFunction bf = latch_component->get_async_reset_function(); !bf.is_empty())
                {
                    latch_config.AddMember("clear_on", bf.to_string(), allocator);
                }
                if (BooleanFunction bf = latch_component->get_async_set_function(); !bf.is_empty())
                {
                    latch_config.AddMember("preset_on", bf.to_string(), allocator);
                }
 
                std::pair<AsyncSetResetBehavior, AsyncSetResetBehavior> cp_behav = latch_component->get_async_set_reset_behavior();
                if (cp_behav.first != AsyncSetResetBehavior::undef)
                {
                    latch_config.AddMember("state_clear_preset", enum_to_string<AsyncSetResetBehavior>(cp_behav.first), allocator);
                }
                if (cp_behav.second != AsyncSetResetBehavior::undef)
                {
                    latch_config.AddMember("neg_state_clear_preset", enum_to_string<AsyncSetResetBehavior>(cp_behav.second), allocator);
                }
 
                cell.AddMember("latch_config", latch_config, allocator);
            }
            else if (RAMComponent* ram_component = gt->get_component_as<RAMComponent>([](const GateTypeComponent* c) { return RAMComponent::is_class_of(c); }); ram_component != nullptr)
            {
                rapidjson::Value ram_config(rapidjson::kObjectType);
 
                rapidjson::Value identifiers(rapidjson::kArrayType);
                for (const std::string& identifier : ram_component->get_init_identifiers())
                {
                    identifiers.PushBack(rapidjson::Value{}.SetString(identifier.c_str(), identifier.length(), allocator), allocator);
                }
                ram_config.AddMember("data_identifiers", identifiers, allocator);
                ram_config.AddMember("bit_size", ram_component->get_bit_size(), allocator);
 
                rapidjson::Value ram_ports(rapidjson::kArrayType);
                for (const GateTypeComponent* component : ram_component->get_components([](const GateTypeComponent* c) { return RAMPortComponent::is_class_of(c); }))
                {
                    const RAMPortComponent* port_component = component->convert_to<RAMPortComponent>();
                    if (port_component == nullptr)
                    {
                        return false;
                    }
 
                    rapidjson::Value port(rapidjson::kObjectType);
                    port.AddMember("data_group", port_component->get_data_group(), allocator);
                    port.AddMember("address_group", port_component->get_address_group(), allocator);
                    port.AddMember("clocked_on", port_component->get_clock_function().to_string(), allocator);
                    port.AddMember("enabled_on", port_component->get_enable_function().to_string(), allocator);
                    port.AddMember("is_write", port_component->is_write_port(), allocator);
                    ram_ports.PushBack(port, allocator);
                }
                ram_config.AddMember("ram_ports", ram_ports, allocator);
                cell.AddMember("ram_config", ram_config, allocator);
            }
 
            // pins
            const auto pin_groups = gt->get_pin_groups();
            rapidjson::Value pg_array(rapidjson::kArrayType);
            for (const auto* group : pin_groups)
            {
                rapidjson::Value pg_val(rapidjson::kObjectType);
                pg_val.AddMember("name", group->get_name(), allocator);
                pg_val.AddMember("direction", enum_to_string(group->get_direction()), allocator);
                pg_val.AddMember("type", enum_to_string(group->get_type()), allocator);
                pg_val.AddMember("ascending", group->is_ascending(), allocator);
                pg_val.AddMember("start_index", group->get_start_index(), allocator);
                pg_val.AddMember("ordered", group->is_ordered(), allocator);
 
                // pins of group
                rapidjson::Value p_array(rapidjson::kArrayType);
                for (const auto* pin : group->get_pins())
                {
                    rapidjson::Value p_val(rapidjson::kObjectType);
                    p_val.AddMember("name", pin->get_name(), allocator);
                    p_val.AddMember("direction", enum_to_string(pin->get_direction()), allocator);
                    p_val.AddMember("type", enum_to_string(pin->get_type()), allocator);
 
                    // check pin function
                    if (pin->get_direction() == PinDirection::output || pin->get_direction() == PinDirection::inout)
                    {
                        if (const auto it = functions.find(pin->get_name()); it != functions.end())
                        {
                            p_val.AddMember("function", it->second.to_string(), allocator);
                        }
 
                        if (const auto it = functions.find(pin->get_name() + "_undefined"); it != functions.end())
                        {
                            p_val.AddMember("x_function", it->second.to_string(), allocator);
                        }
 
                        if (const auto it = functions.find(pin->get_name() + "_tristate"); it != functions.end())
                        {
                            p_val.AddMember("z_function", it->second.to_string(), allocator);
                        }
                    }
 
                    p_array.PushBack(p_val, allocator);
                }
 
                pg_val.AddMember("pins", p_array, allocator);
                pg_array.PushBack(pg_val, allocator);
            }
 
            cell.AddMember("pin_groups", pg_array, allocator);
            cells.PushBack(cell, allocator);
        }
 
        document.AddMember("cells", cells, allocator);
 
        return true;
    }
 
    std::vector<HGLWriter::PinCtx> HGLWriter::get_pins(GateType* gt, const std::unordered_map<std::string, BooleanFunction>& functions)
    {
        std::vector<PinCtx> res;
        for (const auto* pin : gt->get_pins())
        {
            PinCtx res_pin;
            res_pin.name      = pin->get_name();
            res_pin.direction = enum_to_string(pin->get_direction());
            res_pin.type      = enum_to_string(pin->get_type());
 
            if (pin->get_direction() == PinDirection::output || pin->get_direction() == PinDirection::inout)
            {
                if (const auto it = functions.find(pin->get_name()); it != functions.end())
                {
                    res_pin.function = it->second.to_string();
                }
 
                if (const auto it = functions.find(pin->get_name() + "_undefined"); it != functions.end())
                {
                    res_pin.x_function = it->second.to_string();
                }
 
                if (const auto it = functions.find(pin->get_name() + "_tristate"); it != functions.end())
                {
                    res_pin.z_function = it->second.to_string();
                }
            }
 
            res.push_back(res_pin);
        }
 
        return res;
    }
}    // namespace hal