netlist.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2019 Ruhr University Bochum, Chair for Embedded Security. All Rights reserved.
// Copyright (c) 2019 Marc Fyrbiak, Sebastian Wallat, Max Hoffmann ("ORIGINAL AUTHORS"). All rights reserved.
// Copyright (c) 2021 Max Planck Institute for Security and Privacy. All Rights reserved.
// Copyright (c) 2021 Jörn Langheinrich, Julian Speith, Nils Albartus, René Walendy, Simon Klix ("ORIGINAL AUTHORS"). All Rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#pragma once
 
#include "hal_core/defines.h"
#include "hal_core/netlist/event_system/event_handler.h"
#include "hal_core/netlist/gate_library/gate_library.h"
 
#include <functional>
#include <memory>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
 
namespace hal
{
    class NetlistInternalManager;
    class Net;
    class Gate;
    class Module;
    class Grouping;
    class Endpoint;
 
    class NETLIST_API Netlist
    {
        friend class NetlistInternalManager;
 
    public:
        explicit Netlist(const GateLibrary* gate_library);
 
        ~Netlist();
 
        bool operator==(const Netlist& other) const;
 
        bool operator!=(const Netlist& other) const;
 
        u32 get_id() const;
 
        void set_id(const u32 id);
 
        std::filesystem::path get_input_filename() const;
 
        void set_input_filename(const std::filesystem::path& path);
 
        const std::string& get_design_name() const;
 
        void set_design_name(const std::string& name);
 
        const std::string& get_device_name() const;
 
        void set_device_name(const std::string& name);
 
        const GateLibrary* get_gate_library() const;
 
        Result<std::unique_ptr<Netlist>> copy() const;
 
        /*
         * ################################################################
         *      gate functions
         * ################################################################
         */
 
        u32 get_unique_gate_id();
 
        Gate* create_gate(const u32 gate_id, GateType* gate_type, const std::string& name = "", i32 x = -1, i32 y = -1);
 
        Gate* create_gate(GateType* gate_type, const std::string& name = "", i32 x = -1, i32 y = -1);
 
        bool delete_gate(Gate* gate);
 
        bool is_gate_in_netlist(const Gate* gate) const;
 
        Gate* get_gate_by_id(const u32 gate_id) const;
 
        const std::vector<Gate*>& get_gates() const;
 
        std::vector<Gate*> get_gates(const std::function<bool(const Gate*)>& filter) const;
 
        bool mark_vcc_gate(Gate* gate);
 
        bool mark_gnd_gate(Gate* gate);
 
        bool unmark_vcc_gate(Gate* gate);
 
        bool unmark_gnd_gate(Gate* gate);
 
        bool is_vcc_gate(const Gate* gate) const;
 
        bool is_gnd_gate(const Gate* gate) const;
 
        const std::vector<Gate*>& get_vcc_gates() const;
 
        const std::vector<Gate*>& get_gnd_gates() const;
 
        /*
         * ################################################################
         *      net functions
         * ################################################################
         */
 
        u32 get_unique_net_id();
 
        Net* create_net(const u32 net_id, const std::string& name);
 
        Net* create_net(const std::string& name);
 
        bool delete_net(Net* net);
 
        bool is_net_in_netlist(const Net* net) const;
 
        Net* get_net_by_id(u32 net_id) const;
 
        const std::vector<Net*>& get_nets() const;
 
        std::vector<Net*> get_nets(const std::function<bool(const Net*)>& filter) const;
 
        bool mark_global_input_net(Net* net);
 
        bool mark_global_output_net(Net* net);
 
        bool unmark_global_input_net(Net* net);
 
        bool unmark_global_output_net(Net* net);
 
        bool is_global_input_net(const Net* net) const;
 
        bool is_global_output_net(const Net* net) const;
 
        const std::vector<Net*>& get_global_input_nets() const;
 
        const std::vector<Net*>& get_global_output_nets() const;
 
        std::vector<Net*> get_gnd_nets() const;
 
        std::vector<Net*> get_vcc_nets() const;
 
        void enable_automatic_net_checks(bool enable_checks = true);
 
        /*
         * ################################################################
         *      module functions
         * ################################################################
         */
 
        u32 get_unique_module_id();
 
        Module* create_module(const u32 module_id, const std::string& name, Module* parent, const std::vector<Gate*>& gates = {});
 
        Module* create_module(const std::string& name, Module* parent, const std::vector<Gate*>& gates = {});
 
        bool delete_module(Module* module);
 
        bool is_module_in_netlist(const Module* module) const;
 
        Module* get_module_by_id(u32 module_id) const;
 
        const std::vector<Module*>& get_modules() const;
 
        std::vector<Module*> get_modules(const std::function<bool(const Module*)>& filter) const;
 
        Module* get_top_module() const;
 
        /*
         * ################################################################
         *      grouping functions
         * ################################################################
         */
 
        u32 get_unique_grouping_id();
 
        Grouping* create_grouping(const u32 grouping_id, const std::string& name = "");
 
        Grouping* create_grouping(const std::string& name = "");
 
        bool delete_grouping(Grouping* grouping);
 
        bool is_grouping_in_netlist(const Grouping* grouping) const;
 
        Grouping* get_grouping_by_id(u32 grouping_id) const;
 
        const std::vector<Grouping*>& get_groupings() const;
 
        std::vector<Grouping*> get_groupings(const std::function<bool(const Grouping*)>& filter) const;
 
        /*
         * ################################################################
         *      getter/setter for ID tracking
         * ################################################################
         */
 
        u32 get_next_gate_id() const;
 
        void set_next_gate_id(const u32 id);
 
        std::set<u32> get_used_gate_ids() const;
 
        void set_used_gate_ids(const std::set<u32> ids);
 
        std::set<u32> get_free_gate_ids() const;
 
        void set_free_gate_ids(const std::set<u32> ids);
 
        u32 get_next_net_id() const;
 
        void set_next_net_id(const u32 id);
 
        std::set<u32> get_used_net_ids() const;
 
        void set_used_net_ids(const std::set<u32> ids);
 
        std::set<u32> get_free_net_ids() const;
 
        void set_free_net_ids(const std::set<u32> ids);
 
        u32 get_next_module_id() const;
 
        void set_next_module_id(const u32 id);
 
        std::set<u32> get_used_module_ids() const;
 
        void set_used_module_ids(const std::set<u32> ids);
 
        std::set<u32> get_free_module_ids() const;
 
        void set_free_module_ids(const std::set<u32> ids);
 
        u32 get_next_grouping_id() const;
 
        void set_next_grouping_id(const u32 id);
 
        std::set<u32> get_used_grouping_ids() const;
 
        void set_used_grouping_ids(const std::set<u32> ids);
 
        std::set<u32> get_free_grouping_ids() const;
 
        void set_free_grouping_ids(const std::set<u32> ids);
 
        EventHandler* get_event_handler() const;
 
        /*
         * ################################################################
         *      utility functions
         * ################################################################
         */
 
        void clear_caches();
 
        bool load_gate_locations_from_data(const std::string& data_category = "", const std::pair<std::string, std::string>& data_identifiers = std::pair<std::string, std::string>());
 
    private:
        /* stores the gate library */
        const GateLibrary* m_gate_library;
 
        /* stores the netlist id */
        u32 m_netlist_id;
 
        /* stores the name of the input file */
        std::filesystem::path m_file_name;
 
        /* stores the name of the design */
        std::string m_design_name;
 
        /* stores the name of the device */
        std::string m_device_name;
 
        /* stores the pointer to the netlist internal manager */
        NetlistInternalManager* m_manager;
 
        /* the event handler associated with the netlist */
        std::unique_ptr<EventHandler> m_event_handler;
 
        /* stores the auto generated ids for fast next id */
        u32 m_next_gate_id;
        std::set<u32> m_used_gate_ids;
        std::set<u32> m_free_gate_ids;
        u32 m_next_net_id;
        std::set<u32> m_used_net_ids;
        std::set<u32> m_free_net_ids;
        u32 m_next_module_id;
        std::set<u32> m_used_module_ids;
        std::set<u32> m_free_module_ids;
        u32 m_next_grouping_id;
        std::set<u32> m_used_grouping_ids;
        std::set<u32> m_free_grouping_ids;
 
        /* stores the modules */
        Module* m_top_module;
        std::unordered_map<u32, std::unique_ptr<Module>> m_modules_map;
        std::unordered_set<const Module*> m_modules_set;
        std::vector<Module*> m_modules;
 
        /* stores the nets */
        std::unordered_map<u32, std::unique_ptr<Net>> m_nets_map;
        std::unordered_set<const Net*> m_nets_set;
        std::vector<Net*> m_nets;
 
        /* stores the gates */
        std::unordered_map<u32, std::unique_ptr<Gate>> m_gates_map;
        std::unordered_set<const Gate*> m_gates_set;
        std::vector<Gate*> m_gates;
 
        /* stores the groupings */
        std::unordered_map<u32, std::unique_ptr<Grouping>> m_groupings_map;
        std::unordered_set<const Grouping*> m_groupings_set;
        std::vector<Grouping*> m_groupings;
 
        /* stores the set of global gates and nets */
        std::vector<Net*> m_global_input_nets;
        std::vector<Net*> m_global_output_nets;
        std::vector<Gate*> m_gnd_gates;
        std::vector<Gate*> m_vcc_gates;
    };
}    // namespace hal