verified_candidate.h

Go to the documentation of this file.

#pragma once
 
#include "hal_core/netlist/boolean_function.h"
#include "hal_core/utilities/result.h"
 
#include <map>
#include <string>
#include <vector>
 
namespace hal
{
    class Net;
    class Gate;
 
    namespace module_identification
    {
        enum class CandidateType;
 
        struct WordLevelOperation
        {
            std::map<std::string, BooleanFunction> operands;
 
            std::vector<BooleanFunction> ctrl_signals;
 
            BooleanFunction operation;
        };
 
        class VerifiedCandidate
        {
        public:
            VerifiedCandidate(const std::vector<std::vector<Net*>>& operands,
                              const std::vector<Net*>& output_nets,
                              const std::vector<Net*>& control_signals,
                              const std::vector<std::map<Net*, BooleanFunction::Value>>& control_signal_mappings,
                              const std::map<std::map<Net*, BooleanFunction::Value>, BooleanFunction>& word_level_operations,
                              const std::vector<Gate*>& gates,
                              const std::vector<Gate*>& base_gates,
                              const std::map<std::string, std::string>& additional_data,
                              const std::set<CandidateType>& types);
 
            VerifiedCandidate();
 
            bool operator==(const VerifiedCandidate& other) const
            {
                return (m_operands == other.m_operands) && (m_control_signals == other.m_control_signals) && (m_control_signal_mappings == other.m_control_signal_mappings)
                       && (m_output_nets == other.m_output_nets) && (m_gates == other.m_gates) && (m_types == other.m_types) && (m_verified == other.m_verified);
            }
 
            static hal::Result<VerifiedCandidate> merge(const std::vector<VerifiedCandidate>& candidates);
 
            std::string get_candidate_info() const;
 
            bool is_verified() const;
 
            std::string get_name() const;
 
            BooleanFunction get_merged_word_level_operation() const;
 
            std::vector<std::vector<Net*>> m_operands;
 
            std::vector<Net*> m_output_nets;
 
            std::vector<Net*> m_control_signals;
 
            std::vector<std::map<Net*, BooleanFunction::Value>> m_control_signal_mappings;
 
            std::map<std::map<Net*, BooleanFunction::Value>, BooleanFunction> m_word_level_operations;
 
            std::vector<Gate*> m_gates;
 
            std::vector<Gate*> m_base_gates;
 
            std::vector<Net*> m_total_input_nets;
 
            std::vector<Net*> m_total_output_nets;
 
            std::set<CandidateType> m_types;
 
            bool m_verified;
 
            // void add_additional_data(std::string key, std::string value);
            // std::map<std::string, std::string> get_all_additional_data() const;
 
        private:
            std::map<std::string, std::string> m_additional_data;
        };
    }    // namespace module_identification
}    // namespace hal