Utility data structures
Truth table cache
Header: mockturtle/utils/truth_table_cache.hpp
Method
|
Description
|
---|---|
Creates a truth table cache and reserves memory.
|
|
Inserts a truth table and returns a literal.
|
|
Returns truth table for a given literal.
|
|
Returns number of normalized truth tables in the cache.
|
-
template<typename TT>
class truth_table_cache Truth table cache.
A truth table cache is used to store truth tables. Many applications require to assign truth tables to nodes in a network. But since the truth tables often repeat, it is more convenient to store an index to a cache that stores the truth table. In order to reduce space, only one entry for a truth table and its complement are stored in the cache. To distinguish between both versions, the index to an entry in the truth table cache is represented as literal. The truth table whose function maps the input assignment \(0, \dots, 0\) to \(0\) is considered the normal truth table, while its complement is considered the complemented version. Only the normal truth table is stored at some index \(i\). A positive literal \(2i\) points to the normal truth table at index \(i\). A negative literal \(2i + 1\) points to the same truth table but returns its complement.
Example
truth_table_cache cache; kitty::dynamic_truth_table maj( 3 ); kitty::create_majority( maj ); auto l1 = cache.insert( maj ); // index is 0 auto tt = cache[l1 ^ 1]; // tt is ~maj auto l2 = cache.insert( tt ); // index is 1 auto s = cache.size(); // size is 1
Public Functions
-
truth_table_cache(uint32_t capacity = 1000u)
Creates a truth table cache and reserves memory.
-
uint32_t insert(TT tt)
Inserts a truth table and returns a literal.
To save space, only normal functions are stored in the truth table cache. A function is normal, if the input pattern \(0, \dots, 0\) maps to \(0\). If a function is not normal, its complement is inserted into the cache and a negative literal is returned.
The default convention for literals is assumed. That is an index \(i\) (starting) from \(0\) has positive literal \(2i\) and negative literal \(2i + 1\).
- Parameters:
tt – Truth table to insert
- Returns:
Literal of position in cache
-
TT operator[](uint32_t lit) const
Returns truth table for a given literal.
The function requires that
lit
is smaller thansize()
.
-
inline auto size() const
Returns number of normalized truth tables in the cache.
-
void resize(uint32_t capacity)
Resizes the cache.
Reserve additional space for cache and data.
-
truth_table_cache(uint32_t capacity = 1000u)
Node map
Header: mockturtle/utils/node_map.hpp
This group of containers helps to store and access values associated to nodes in a network.
Three implementations are provided, two using std::vector and one using std::unordered_map as internal storage. Using std::vector, the default implementation of node_map pre-allocates memory for all nodes and provides a fast way to access the data. When only a subset of nodes are associated with values, both unordered_node_map and incomplete_node_map provide interfaces to check whether a value is available. Using std::unordered_map, the former uses less memory but has a slower access speed; the latter uses std::vector together with validity tags to trade efficiency with memory.
Example
aig_network aig = ...
node_map<std::string, aig_network> node_names( aig );
aig.foreach_node( [&]( auto n ) {
node_names[n] = "some string";
} );
-
template<class T, class Ntk, class Impl = std::vector<T>>
class node_map Associative container network nodes.
This container helps to store and access values associated to nodes in a network.
Two implementations are provided, one using std::vector and another using std::unordered_map as internal storage. The former implementation can be pre-allocated and provides a fast way to access the data. The later implementation offers a way to associate values to a subset of nodes and to check whether a value is available.
-
template<class T, class Ntk>
class incomplete_node_map Vector-based node map with validity query.
This container is initialized with a network to derive the size according to the number of nodes. The container can be accessed via nodes, or indirectly via signals, from which the corresponding node is derived.
The implementation uses a vector as underlying data structure, so that it benefits from fast access. It is supplemented with an additional validity field such that it can be used like an
unordered_node_map
.Required network functions:
size
get_node
node_to_index
Public Functions
-
inline incomplete_node_map(Ntk const &ntk, T const &init_value)
Constructor with default value.
Initializes all values in the container to
init_value
.
-
inline auto size() const
Number of keys stored in the data structure.
-
inline bool has(node const &n) const
Check if a key is already defined.
-
template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
inline bool has(signal const &f) const Check if a key is already defined.
-
inline void erase(node const &n)
Erase a key (if it exists).
-
template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
inline void erase(signal const &f) Erase a key (if it exists).
-
template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
inline T &operator[](signal const &f) Mutable access to value by signal.
This method derives the node from the signal. If the node and signal type are the same in the network implementation, this method is disabled.
-
template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
inline T const &operator[](signal const &f) const Constant access to value by signal.
This method derives the node from the signal. If the node and signal type are the same in the network implementation, this method is disabled.
-
inline void reset()
Resets the size of the map.
This function should be called, if the network changed in size. Then, the map is cleared, and resized to the current network’s size. All values are initialized with the place holder (empty) element.
-
inline void reset(T const &init_value)
Resets the size of the map.
This function should be called, if the network changed in size. Then, the map is cleared, and resized to the current network’s size. All values are initialized with
init_value
.- Parameters:
init_value – Initialization value after resize
-
template<class NtkDest, class NtkSrc>
std::pair<NtkDest, node_map<signal<NtkDest>, NtkSrc>> mockturtle::initialize_copy_network(NtkSrc const &src) Initializes a network for copying together with node map.
This utility function is helpful when creating a network from another one, a very common task. It creates the network of type
NtkDest
and already creates a node map to map nodes from the source network, of typeNtkSrc
to nodes of the new network. The function map constant inputs and creates and maps primary inputs.
Tech library
Header: mockturtle/utils/tech_library.hpp
Method
|
Description
|
---|---|
Get the gates matching the function.
|
|
Get inverter information.
|
|
Returns the maximum number of variables of the gates.
|
|
Returns the original gates.
|
-
template<unsigned NInputs = 6u, classification_type Configuration = classification_type::np_configurations>
class tech_library Library of gates for Boolean matching.
This class creates a technology library from a set of input gates. Each NP- or P-configuration of the gates are enumerated and inserted in the library.
The configuration is selected using the template parameter
Configuration
. P-configuration is suggested for big libraries with few symmetric gates. The template parameterNInputs
selects the maximum number of variables allowed for a gate in the library.The library can be generated also using supergates definitions.
Example
std::vector<gate> gates; lorina::read_genlib( "file.genlib", genlib_reader( gates ) ); // standard library mockturtle::tech_library lib( gates ); super_lib supergates_spec; lorina::read_super( "file.super", super_reader( supergates_spec ) ); // library with supergates mockturtle::tech_library lib_super( gates, supergates_spec );
Public Functions
-
inline const supergates_list_t *get_supergates(TT const &tt) const
Get the gates matching the function.
Returns a list of gates that match the function represented by the truth table.
-
inline const multi_supergates_list_t *get_multi_supergates(std::array<TT, max_multi_outputs> const &tts) const
Get the multi-output gates matching the function.
Returns a list of multi-output gates that match the function represented by the truth table.
-
inline uint64_t get_multi_function_id(uint64_t const &tt) const
Get the multi-output gate function ID for a single output.
Returns the function ID of a multi-output gate output if matched. This function supports up to 6 inputs. Returns zero in case of no match.
-
inline uint32_t get_pattern_id(uint32_t id1, uint32_t id2) const
Get the pattern ID for structural matching.
Returns a pattern ID if found, UINT32_MAX otherwise given the children IDs. This function works with only AND operators.
-
inline const supergates_list_t *get_supergates_pattern(uint32_t id, bool phase) const
Get the gates matching the pattern ID and phase.
Returns a list of gates that match the pattern ID and the given polarity.
-
inline const std::tuple<float, float, uint32_t> get_inverter_info() const
Get inverter information.
Returns area, delay, and ID of the smallest inverter.
-
inline const std::tuple<float, float, uint32_t> get_buffer_info() const
Get buffer information.
Returns area, delay, and ID of the smallest buffer.
-
inline unsigned max_gate_size()
Returns the maximum number of variables of the gates.
-
inline const std::vector<gate> get_gates() const
Returns the original gates.
-
inline const std::vector<standard_cell> &get_cells() const
Returns the standard cells.
-
inline const std::vector<std::vector<composed_gate<NInputs>>> &get_multioutput_gates() const
Returns multioutput gates.
-
inline const uint32_t num_multioutput_gates() const
Returns the number of multi-output gates loaded in the library.
-
inline const uint32_t num_structural_gates() const
Returns the number of gates for structural matching.
-
inline const uint32_t num_structural_large_gates() const
Returns the number of gates for structural matching with more than 6 inputs.
-
inline const supergates_list_t *get_supergates(TT const &tt) const
Exact library
Header: mockturtle/utils/tech_library.hpp
Method
|
Description
|
---|---|
Get the structures matching the function.
|
|
Get the structures matching the function with DC.
|
|
Returns the NPN database of structures.
|
|
Returns the NPN database of structures.
|
|
Get inverter information.
|
-
template<typename Ntk, unsigned NInputs = 4u>
class exact_library Library of graph structures for Boolean matching.
This class creates a technology library from a database of structures classified in NPN classes. Each NPN-entry in the database is stored in its NP class by removing the output inverter if present. The class creates supergates from the database computing area and delay information.
Example
mockturtle::mig_npn_resynthesis mig_resyn{ true }; mockturtle::exact_library<mockturtle::mig_network> lib( mig_resyn );
Public Functions
-
inline const supergates_list_t *get_supergates(TT const &tt) const
Get the structures matching the function.
Returns a list of graph structures that match the function represented by the truth table.
-
inline const supergates_list_t *get_supergates(TT const &tt, TT const &dc, uint32_t &phase, std::vector<uint8_t> &perm) const
Get the structures matching the function with DC.
Returns a list of graph structures that match the function represented by the truth table and its dont care set. This functions also updates the phase and permutation vector of the original NPN class to the new one obtained using don’t cares.
-
inline const std::tuple<float, float> get_inverter_info() const
Get inverter information.
Returns area, and delay cost of the inverter.
-
inline const supergates_list_t *get_supergates(TT const &tt) const
Supergates utils
Header: mockturtle/utils/super_utils.hpp
Method
|
Description
|
---|---|
Get the all the supergates.
|
|
Get the number of standard gates.
|
-
template<unsigned NInputs = 6u>
class super_utils Utilities to generate supergates.
This class creates supergates starting from supergates specifications contained in
supergates_spec
extracted from a SUPER file.Multi-output gates are also extracted from the list of GENLIB gates. However multi-output gates are currently not supported as supergates members.
This utility is called by
tech_library
to construct the library for technology mapping.Public Functions
-
inline const std::deque<composed_gate<NInputs>> &get_super_library() const
Get the all the supergates.
Returns a list of supergates created accordingly to the standard library and the supergates specifications.
-
inline const uint32_t get_standard_library_size() const
Get the number of standard gates.
Returns the number of standard gates contained in the supergate library.
-
inline const std::deque<composed_gate<NInputs>> &get_super_library() const
Struct library
Header: mockturtle/utils/struct_library.hpp
Method
|
Description
|
---|---|
Construct the structural library.
|
|
Get the pattern ID.
|
|
Get the gates matching the pattern ID.
|
|
Print and table.
|
-
template<unsigned NInputs = 9u>
class struct_library Library of gates for structural matching.
This class creates a technology library from a set of input gates.
Gates are processed to derive rules in the AIG format. Then, every rule and subrule gets a unique id and the AND table is built. Every gate gets a unique label comprehensive of its rule id and whether it is positive or negative.
The template parameter
NInputs
selects the maximum number of variables allowed for a gate in the library.By default,
struct_library
is used intech_library
when NInputs is greater than 6.Example
std::vector<gate> gates; lorina::read_genlib( "file.genlib", genlib_reader( gates ) ); // struct library mockturtle::struct_library lib( gates );
Public Functions
-
inline void construct(uint32_t min_vars = 2u)
Construct the structural library.
Generates the patterns for structural matching. Variable
min_vars
defines the minimum number of gate inputs considered for the library creation. 0 < min_vars < UINT32_MAX
-
inline const map_label_gate &get_struct_library() const
Construct the structural library.
Generates the patterns for structural matching.
-
inline const uint32_t get_pattern_id(uint32_t id1, uint32_t id2) const
Get the pattern ID.
- Parameters:
id1 – first pattern id.
id2 – second pattern id. Returns a pattern ID if found, UINT32_MAX otherwise given the children IDs. This function works with only AND operators.
-
inline const supergates_list_t *get_supergates_pattern(uint32_t id, bool phase) const
Get the gates matching the pattern ID.
Returns a list of gates that match the pattern ID.
-
inline const uint32_t get_num_large_gates() const
Returns the number of large gates.
Number of gates with more than 6 inputs.
-
inline void print_and_table()
Print and table.
-
struct dsd_node
-
struct label
-
struct signal
-
struct signal_hash
-
struct tuple_s_hash
-
inline void construct(uint32_t min_vars = 2u)
Cuts
Header: mockturtle/utils/cuts.hpp
Method
|
Description
|
---|---|
Assignment operator.
|
|
Sets leaves (using iterators).
|
|
Sets leaves (using container).
|
|
Signature of the cut.
|
|
Returns the size of the cut (number of leaves).
|
|
Begin iterator (constant).
|
|
Begin iterator (mutable).
|
|
End iterator (constant).
|
|
End iterator (mutable).
|
|
Access to data (mutable).
|
|
Access to data (constant).
|
|
Access to data (mutable).
|
|
Access to data (constant).
|
|
Merges two cuts.
|
-
template<int MaxLeaves, typename T = empty_cut_data>
class cut A data-structure to hold a cut.
The cut class is specialized via two template arguments,
MaxLeaves
andT
.MaxLeaves
controls the maximum number of leaves a cut can hold. To guarantee an efficient implementation, this value should be \(k \cdot l\), where \(k\) is the maximum cut size and \(l\) is the maximum fanin size of a gate in the logic network. The second template argumentT
can be a type for which a data entry is created in the cut to store additional data, e.g., to compute the cost of a cut. It defaults toempty_cut_data
, which is an empty struct that does not consume memory.Example
std::vector<uint32_t> data{1, 2, 3, 4}; cut<10> cut1; cut1.set_leaves( data.begin(), data.end() ); cut<10, uint32_t> cut2; cut2.set_leaves( data.begin(), data.end() ); cut2.data() = 42u; struct cut_data { uint32_t costs; }; cut<20, cut_data> c3; c3.set_leaves( std::vector<uint32_t>{1, 2, 3} ); c3->costs = 37u;
Public Functions
-
cut() = default
Default constructor.
-
inline cut(cut const &other)
Copy constructor.
Copies leaves, length, signature, and data.
- Parameters:
other – Other cut
-
cut &operator=(cut const &other)
Assignment operator.
Copies leaves, length, signature, and data.
- Parameters:
other – Other cut
-
template<typename Iterator>
void set_leaves(Iterator begin, Iterator end) Sets leaves (using iterators).
- Parameters:
begin – Begin iterator to leaves
end – End iterator to leaves (exclusive)
-
template<typename Container>
void set_leaves(Container const &c) Sets leaves (using container).
Convenience function, which extracts the begin and end iterators from the container.
-
template<typename Iterator>
void add_leaves(Iterator begin, Iterator end) Add leaves (using iterators).
- Parameters:
begin – Begin iterator to leaves
end – End iterator to leaves (exclusive)
-
inline auto signature() const
Signature of the cut.
-
inline auto size() const
Returns the size of the cut (number of leaves).
-
inline auto begin() const
Begin iterator (constant).
-
inline auto end() const
End iterator (constant).
-
inline auto begin()
Begin iterator (mutable).
-
inline auto end()
End iterator (mutable).
-
bool dominates(cut const &that) const
Checks whether the cut is a subset of another cut.
If \(L_1\) are the leaves of the current cut and \(L_2\) are the leaves of
that
, then this method returns true if and only if \(L_1 \subseteq L_2\).- Parameters:
that – Other cut
-
bool merge(cut const &that, cut &res, uint32_t cut_size) const
Merges two cuts.
This method merges two cuts and stores the result in
res
. The merge of two cuts is the union \(L_1 \cup L_2\) of the two leaf sets \(L_1\) of the cut and \(L_2\) ofthat
. The merge is only successful if the union has not more thancut_size
elements. In that case, the function returnsfalse
, otherwisetrue
.- Parameters:
that – Other cut
res – Resulting cut
cut_size – Maximum cut size
- Returns:
True, if resulting cut is small enough
-
cut() = default
Cut sets
Header: mockturtle/utils/cuts.hpp
Method
|
Description
|
---|---|
Standard constructor.
|
|
Clears a cut set.
|
|
Adds a cut to the end of the set.
|
|
Inserts a cut into a set.
|
|
Begin iterator (constant).
|
|
Begin iterator (mutable).
|
|
End iterator (constant).
|
|
End iterator (mutable).
|
|
Number of cuts in the set.
|
|
Returns reference to cut at index.
|
|
Returns the best cut, i.e., the first cut.
|
|
Updates the best cut.
|
|
Resize the cut set, if it is too large.
|
|
Prints a cut set.
|
-
template<typename CutType, int MaxCuts>
class cut_set A data-structure to hold a set of cuts.
The aim of a cut set is to contain cuts and maintain two properties. First, all cuts are ordered according to the
<
operator, and second, all cuts are irredundant, i.e., no cut in the set dominates another cut in the set.The cut set is defined using the
CutType
of cuts it should hold and a maximum number of cuts it can hold. No check is performed whether a cut set is full, and therefore the caller must not insert cuts into a full set.Example
cut_set<cut<10>, 30> cuts; cut<10> c1, c2, c3, c4; c1.set_leaves( {1, 2, 3} ); c2.set_leaves( {4, 5} ); c3.set_leaves( {1, 2} ); c4.set_leaves( {1, 3, 4} ); cuts.insert( c1 ); cuts.insert( c2 ); cuts.insert( c3 ); cuts.insert( c4 ); assert( cuts.size() == 3 ); std::cout << cuts << std::endl; // will print: // { 4, 5 } // { 1, 2 } // { 1, 3, 4 }
Public Functions
-
cut_set()
Standard constructor.
-
void clear()
Clears a cut set.
-
template<typename Iterator>
CutType &add_cut(Iterator begin, Iterator end) Adds a cut to the end of the set.
This function should only be called to create a set of cuts which is known to be sorted and irredundant (i.e., no cut in the set dominates another cut).
- Parameters:
begin – Begin iterator to leaf indexes
end – End iterator (exclusive) to leaf indexes
- Returns:
Reference to the added cut
-
bool is_dominated(CutType const &cut) const
Checks whether cut is dominates by any cut in the set.
- Parameters:
cut – Cut outside of the set
-
void insert(CutType const &cut)
Inserts a cut into a set.
This method will insert a cut into a set and maintain an order. Before the cut is inserted into the correct position, it will remove all cuts that are dominated by
cut
.If
cut
is dominated by any of the cuts in the set, it will still be inserted. The caller is responsible to check whethercut
is dominated before inserting it into the set.- Parameters:
cut – Cut to insert.
-
inline auto begin() const
Begin iterator (constant).
The iterator will point to a cut pointer.
-
inline auto end() const
End iterator (constant).
-
inline auto begin()
Begin iterator (mutable).
The iterator will point to a cut pointer.
-
inline auto end()
End iterator (mutable).
-
inline auto size() const
Number of cuts in the set.
-
inline auto const &operator[](uint32_t index) const
Returns reference to cut at index.
This function does not return the cut pointer but dereferences it and returns a reference. The function does not check whether index is in the valid range.
- Parameters:
index – Index
-
inline auto const &best() const
Returns the best cut, i.e., the first cut.
-
void update_best(uint32_t index)
Updates the best cut.
This method will set the cut at index
index
to be the best cut. All cuts beforeindex
will be moved one position higher.- Parameters:
index – Index of new best cut
-
void limit(uint32_t size)
Resize the cut set, if it is too large.
This method will resize the cut set to
size
only if the cut set has more thansize
elements. Otherwise, the size will remain the same.
-
cut_set()
Index list
Header: mockturtle/utils/index_list.hpp
-
struct mig_index_list
Index list for majority-inverter graphs.
Small network consisting of majority gates and inverters represented as a list of literals.
Example: The following index list creates the output function
<<x1, x2, x3>, x2, x4>
with 4 inputs, 1 output, and 2 gates:{4 | 1 << 8 | 2 << 16, 2, 4, 6, 4, 8, 10, 12}
-
template<typename Ntk>
void mockturtle::encode(mig_index_list &indices, Ntk const &ntk) Generates a mig_index_list from a network.
The function requires
ntk
to consist of majority gates.Required network functions:
foreach_fanin
foreach_gate
get_node
is_complemented
is_maj
node_to_index
num_gates
num_pis
num_pos
- Parameters:
indices – An index list
ntk – A logic network
-
template<bool useSignal = true, typename Ntk, typename BeginIter, typename EndIter, typename Fn>
void mockturtle::insert(Ntk &ntk, BeginIter begin, EndIter end, mig_index_list const &indices, Fn &&fn) Inserts a mig_index_list into an existing network.
Required network functions:
get_constant
create_maj
- Parameters:
ntk – A logic network
begin – Begin iterator of signal inputs
end – End iterator of signal inputs
indices – An index list
fn – Callback function
-
inline std::string mockturtle::to_index_list_string(mig_index_list const &indices)
Converts an mig_index_list to a string.
- Parameters:
indices – An index list
- Returns:
A string representation of the index list
-
template<bool separate_header = false>
struct xag_index_list Index list for xor-and graphs.
Small network represented as a list of literals. Supports XOR and AND gates. The list has the following 32-bit unsigned integer elements. It starts with a signature whose partitioned into
| num_gates | num_pos | num_pis |
, wherenum_gates
accounts for the most-significant 16 bits,num_pos
accounts for 8 bits, andnum_pis
accounts for the least-significant 8 bits. Afterwards, gates are defined as literal indexes(2 * i + c)
, wherei
is an index, with 0 indexing the constant 0, 1 tonum_pis
indexing the primary inputs, and all successive indexes for the gates. Gate literals come in pairs. If the first literal has a smaller value than the second one, an AND gate is created, otherwise, an XOR gate is created. Afterwards, all outputs are defined in terms of literals.Example: The following index list creates the output function
(x1 AND x2) XOR (x3 AND x4)
with 4 inputs, 1 output, and 3 gates:{4 | 1 << 8 | 3 << 16, 2, 4, 6, 8, 12, 10, 14}
Note: if
separate_header = true
, the header will be split into 3 elements to support networks with larger number of PIs.
-
template<typename Ntk, bool separate_header = false>
void mockturtle::encode(xag_index_list<separate_header> &indices, Ntk const &ntk) Generates a xag_index_list from a network.
The function requires
ntk
to consist of XOR and AND gates.Required network functions:
foreach_fanin
foreach_gate
get_node
is_and
is_complemented
is_xor
node_to_index
num_gates
num_pis
num_pos
- Parameters:
indices – An index list
ntk – A logic network
-
template<bool useSignal = true, typename Ntk, typename BeginIter, typename EndIter, typename Fn, bool separate_header = false>
void mockturtle::insert(Ntk &ntk, BeginIter begin, EndIter end, xag_index_list<separate_header> const &indices, Fn &&fn) Inserts a xag_index_list into an existing network.
Required network functions:
create_and
create_xor
get_constant
- Parameters:
ntk – A logic network
begin – Begin iterator of signal inputs
end – End iterator of signal inputs
indices – An index list
fn – Callback function
-
inline std::string mockturtle::to_index_list_string(xag_index_list<true> const &indices)
-
template<typename Ntk, typename IndexList>
void mockturtle::decode(Ntk &ntk, IndexList const &indices) Generates a network from an index_list.
Required network functions:
create_pi
create_po
- Parameters:
ntk – A logic network
indices – An index list
-
class aig_index_list_enumerator
Enumerate structured index_lists.
Enumerate concrete
xag_index_list
s from an abstract index list specification. The specifiation is provided in an extended index list format, where a-1
indicates an unspecified input.The algorithm concretizes unspecified inputs and negates nodes.
The enumerator generates the following concrete index lists {2 | 1 << 8 | 1 << 16, 2, 4, 6} {2 | 1 << 8 | 1 << 16, 2, 4, 7} {2 | 1 << 8 | 1 << 16, 3, 4, 6} {2 | 1 << 8 | 1 << 16, 3, 4, 7} {2 | 1 << 8 | 1 << 16, 3, 5, 6} {2 | 1 << 8 | 1 << 16, 3, 5, 7} {2 | 1 << 8 | 1 << 16, 2, 5, 6} {2 | 1 << 8 | 1 << 16, 2, 5, 7} from the abstract index list specification
{ -1, -1, 6 }
.Example
aig_index_list_enumerator e( { -1, -1, -1, 6, 8 }, 2u, 2u, 1u ); e.run( [&]( xag_index_list const& il ) { aig_network aig; decode( aig, il ); } );
Stopwatch
Header: mockturtle/utils/stopwatch.hpp
Method
|
Description
|
---|---|
Default constructor.
|
|
Default deconstructor.
|
-
template<class Clock = std::chrono::steady_clock>
class stopwatch Stopwatch interface.
This class implements a stopwatch interface to track time. It starts tracking time at construction and stops tracking time at deletion automatically. A reference to a duration object is passed to the constructor. After stopping the time the measured time interval is added to the durationr reference.
Example
stopwatch<>::duration time{0}; { // some block stopwatch t( time ); // do some work } // stopwatch is stopped here std::cout << fmt::format( "{:5.2f} seconds passed\n", to_seconds( time ) );
-
template<class Fn, class Clock = std::chrono::steady_clock>
std::invoke_result_t<Fn> mockturtle::call_with_stopwatch(typename Clock::duration &dur, Fn &&fn) Calls a function and tracks time.
The function that is passed as second parameter can be any callable object that takes no parameters. This construction can be used to avoid pre-declaring the result type of a computation that should be tracked.
Example
stopwatch<>::duration time{0}; auto result = call_with_stopwatch( time, [&]() { return function( parameters ); } );
- Parameters:
dur – Duration reference (time will be added to it)
fn – Callable object with no arguments
-
template<class T, class ...Args, class Clock = std::chrono::steady_clock>
T mockturtle::make_with_stopwatch(typename Clock::duration &dur, Args... args) Constructs an object and calls time.
This function can track the time for the construction of an object and returns the constructed object.
Example
stopwatch<>::duration time{0}; // create vector with 100000 elements initialized to 42 auto result = make_with_stopwatch<std::vector<int>>( time, 100000, 42 );
Progress bar
Header: mockturtle/utils/progress_bar.hpp
Method
|
Description
|
---|---|
Constructor.
|
|
Constructor.
|
|
Deconstructor.
|
|
Prints and updates the progress bar status.
|
|
Removes the progress bar.
|
-
class progress_bar
Prints progress bars.
Example
{ // some block progress_bar bar( 100, "|{0}| neg. index = {1}, index squared = {2}" ); for ( auto i = 0; i < 100; ++i ) { bar( i, -i, i * i ); } } // progress bar is deleted at exit of this block
Public Functions
-
inline progress_bar(uint32_t size, std::string const &fmt, bool enable = true, std::ostream &os = std::cout)
Constructor.
This constructor is used when a the total number of iterations is known, and the progress should be visually printed. When using this constructor, the current iteration must be provided to the
operator()
call.- Parameters:
size – Number of iterations (for progress bar)
fmt – Format strind; used with
fmt::format
, first placeholder{0}
is used for progress bar, the others for the parameters passed tooperator()
enable – If true, output is printed, otherwise not
os – Output stream
-
inline progress_bar(std::string const &fmt, bool enable = true, std::ostream &os = std::cout)
Constructor.
This constructor is used when a the total number of iterations is not known. In this case, the progress is not visually printed. When using this constructor, just pass the arguments for the
fmt
string.- Parameters:
fmt – Format strind; used with
fmt::format
, parameters are passed tooperator()
enable – If true, output is printed, otherwise not
os – Output stream
-
inline ~progress_bar()
Deconstructor.
Will remove the last printed line and restore the cursor.
-
template<typename First, typename ...Args>
inline void operator()(First first, Args... args) Prints and updates the progress bar status.
This updates the progress and re-prints the progress line. The previous print of the line is removed. If the progress bar has a progress segment the first argument must be an integer indicating the current progress with respect to the
size
parameter passed to the constructor.- Parameters:
first – Progress position or first argument
args – Vardiadic argument pack with values for format string
-
inline void done()
Removes the progress bar.
This method is automatically invoked when the progress bar is deleted. In some cases, one may wish to invoke this method manually.
-
inline progress_bar(uint32_t size, std::string const &fmt, bool enable = true, std::ostream &os = std::cout)