Update introduction.rst

pull/1/head
潘鸿洋 2022-12-21 18:05:32 +08:00 committed by GitHub
parent ae9809adaf
commit 7713a1a0cf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 13 additions and 45 deletions

View File

@ -1,53 +1,21 @@
Introduction Introduction
============ ============
The `percy` library provides a collection of SAT based exact synthesis engines. The powerful heightened yielded Logic Synthesis (`phyLS`) is a growing logic synthesis tool based on EPFL Logic Synthesis Library `mockturtle` [#]_ .
That includes engines based on conventional methods, as well as It can optimize different logic attributes, such as `AIG`, `MIG`, `XAG`, and `XMG`.
state-of-the-art engines which can take advantage of DAG topology information `phyLS` combines logic optimization, technology mapping for look-up tables and standard cells, and verification.
The aim of `percy` is to provide a flexible common interface that makes it easy
to construct a parameterizable synthesis engine suitable for different domains.
It is a header-only library, meaning that it can be used simply by including
the percy/include folder in your project. Internally, `percy` uses the `kitty`
library [#]_ to represent the truth tables of the functions to be synthesized.
Synthesis using `percy` concerns five main components: `phyLS` provides an experimental implementation of these algorithms and a programming environment for building similar applications.
It also allows users to customize `phyLS` for their needs as the `ABC` [#]_ .
1. *Specifications* -- Specification objects contain the information essential `phyLS` concerns five main components of commands:
to the synthesis process such as which functions to synthesize, I/O
information, and possibly optional parameters such as conflict limits for
time-bound synthesis, or topology information.
2. *Encoders* -- Encoders are objects which convert specifications to CNF
formulae. There are various ways to create such encodings, and by
separating their implementations it becomes simple to experiment with
different encodings in various settings.
3. *Solvers* -- Once an encoding has been created, we use a SAT solver to find
a solution. Currently supported are ABC's `bsat` solver [#]_, the
Glucose and Glucose-Syrup solvers, [#]_ and the CryptoMinisat solver. [#]_
Adding a new solver to `percy` is as simple as declaring a handful of
interface functions. [#]_
4. *Synthesizers* -- Synthesizers perform the task of composing encoders and
solvers. Different synthesizers correspond to different synthesis flows. For
example, some synthesizers may support synthesis flows that use topological
constraints, or allow for parallel synthesis flows. To perform synthesis
using `percy`, one creates a synthesizer object. Synthesizers are
parameterizable: we can change their encoder and solver backends. This
happens at compile time, so there is no runtime overhead.
5. *Chains* -- Boolean chains are the result of exact synthesis. A Boolean
chain is a compact multi-level logic representation that can be used to
represent multi-output Boolean functions.
A typical workflow will have some source for generating specifications, which 1. *General* -- This component contains some general commands based on `alice` [#]_ , such as `ps` (Print statistics), `store` (Store management), and `show` (Show store entry).
are then given to a synthesizer that converts the specifications into optimum 2. *I/O* -- A specialized format BAF (Binary Aig Format `.aig`) for reading/writing large AIGs into binary files. Input file also parsers for binary BLIF, BENCH format, and Verilog. Output file writers for binary BLIF, BENCH format, Verilog, and circuit graph representation DOT format. It also support truth-table as input.
Boolean chains. Internally, the synthesizer will compose its underlying encoder 3. *Synthesis* -- We lists combinational synthesis commands implemented. Fast and efficient synthesis is achieved by DAG-aware rewriting of the AIG(command `rewrite`), or collapsing and refactoring of logic cones (command `refactor`), or AIG balancing (command `balance`) to reduce the AIG size and tends to reduce the number of AIG levels, or the technology-independent restructuring of the AIG (command `resub`).
and SAT solver in its specific synthesis flow. For example, a resynthesis 4. *Mapping* -- `phyLS` can realise both LUT-mapping (command `lutmap`) and Standard cell mapping (command `techmap`) of technology mapping.
algorithm might generate cuts in a logic network which serve as specifications. 5. *verification* -- Several equivalence checking options are currently implemented, such as combinational equivalence checking (command `cec`) and random simulation of the netowrk (command `sim`).
They are then fed to a synthesizer, and if the resulting optimum Boolean chains
leads to an improvement, are replaced in the logic network. In optimizing this
workflow, `percy` makes it easy to swap out one synthesis flow for another, to
change CNF encodings, or to switch to a different SAT solver.
.. [#] https://github.com/msoeken/kitty .. [#] https://github.com/lsils/mockturtle
.. [#] https://github.com/berkeley-abc/abc .. [#] https://github.com/berkeley-abc/abc
.. [#] http://www.labri.fr/perso/lsimon/glucose/ .. [#] https://github.com/msoeken/alice
.. [#] https://github.com/msoos/cryptominisat
.. [#] Unfortunately some solvers may not compile on your favorite OS...