diff --git a/.clang-format b/.clang-format
index 7548f76b9b80cc6c1725505ab0492be1d7e3317a..22e04bab0e95d05981218e51cd6affb85f82a45f 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,6 +1,6 @@
AccessModifierOffset: -4
-AlignAfterOpenBracket: DontAlign
+AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignConsecutiveMacros: true
@@ -9,10 +9,10 @@ AlignOperands: false
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
-AllowAllConstructorInitializersOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: Empty
-AllowShortCaseLabelsOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: Never
AllowShortLambdasOnASingleLine: Inline
@@ -56,7 +56,7 @@ CommentPragmas: ''
CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
diff --git a/.gitignore b/.gitignore
index 3395e18ae0404b87b2abc5759426b6ef38a49d09..6ebc1f5d11e2158e895383297863436b651309f1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,4 +30,7 @@ $RECYCLE.BIN/
*.egg-info
__pycache__/
env/
-venv/
\ No newline at end of file
+venv/
+*.pyd
+*.so
+_b_asic_debug_log.txt
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3471fb4f473b069f9a4f77efec5d7aeb0fc84a79..85ecb3db700070ccf262b61002b8d8bf927e856a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,16 +3,18 @@ cmake_minimum_required(VERSION 3.8)
project(
"B-ASIC"
VERSION 0.0.1
- DESCRIPTION "Better ASIC Toolbox for python3"
+ DESCRIPTION "Better ASIC Toolbox for Python 3"
LANGUAGES C CXX
)
-find_package(fmt 5.2.1 REQUIRED)
+# Find dependencies.
+find_package(fmt REQUIRED)
find_package(pybind11 CONFIG REQUIRED)
-set(LIBRARY_NAME "b_asic")
-set(TARGET_NAME "_${LIBRARY_NAME}")
+set(LIBRARY_NAME "b_asic") # Name of the python library directory.
+set(TARGET_NAME "_${LIBRARY_NAME}") # Name of this extension module.
+# Set output directory for compiled binaries.
if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
include(GNUInstallDirs)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_INSTALL_LIBDIR}")
@@ -29,22 +31,42 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
+# Add files to be compiled into Python module.
pybind11_add_module(
"${TARGET_NAME}"
+
+ # Main files.
"${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp"
+ "${CMAKE_CURRENT_SOURCE_DIR}/src/simulation.cpp"
+
+ # For DOD simulation.
+ "${CMAKE_CURRENT_SOURCE_DIR}/src/simulation/compile.cpp"
+ "${CMAKE_CURRENT_SOURCE_DIR}/src/simulation/run.cpp"
+ "${CMAKE_CURRENT_SOURCE_DIR}/src/simulation/simulation.cpp"
+
+ # For OOP simulation (see legacy folder).
+ #"${CMAKE_CURRENT_SOURCE_DIR}/src/simulation/custom_operation.cpp"
+ #"${CMAKE_CURRENT_SOURCE_DIR}/src/simulation/operation.cpp"
+ #"${CMAKE_CURRENT_SOURCE_DIR}/src/simulation/signal_flow_graph.cpp"
+ #"${CMAKE_CURRENT_SOURCE_DIR}/src/simulation/simulation.cpp"
+ #"${CMAKE_CURRENT_SOURCE_DIR}/src/simulation/special_operations.cpp"
)
+# Include headers.
target_include_directories(
"${TARGET_NAME}"
PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/src"
)
+# Use C++17.
target_compile_features(
"${TARGET_NAME}"
PRIVATE
cxx_std_17
)
+
+# Set compiler-specific options using generator expressions.
target_compile_options(
"${TARGET_NAME}"
PRIVATE
@@ -60,20 +82,20 @@ target_compile_options(
>
)
+# Add libraries. Note: pybind11 is already added in pybind11_add_module.
target_link_libraries(
"${TARGET_NAME}"
PRIVATE
- fmt::fmt
+ $<TARGET_NAME_IF_EXISTS:fmt::fmt-header-only>
+ $<$<NOT:$<TARGET_EXISTS:fmt::fmt-header-only>>:fmt::fmt>
)
-add_custom_target(
- remove_old_python_dir ALL
- COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${LIBRARY_NAME}"
- COMMENT "Removing old python directory ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${LIBRARY_NAME}"
-)
-add_custom_target(
- copy_python_dir ALL
- COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_CURRENT_LIST_DIR}/${LIBRARY_NAME}" "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${LIBRARY_NAME}"
- COMMENT "Copying python files to ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${LIBRARY_NAME}"
- DEPENDS "${TARGET_NAME}" remove_old_python_dir
-)
\ No newline at end of file
+# Copy binaries to project folder for debugging during development.
+if(NOT ASIC_BUILDING_PYTHON_DISTRIBUTION)
+ add_custom_target(
+ copy_binaries ALL
+ COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:${TARGET_NAME}>" "${CMAKE_CURRENT_LIST_DIR}"
+ COMMENT "Copying binaries to ${CMAKE_CURRENT_LIST_DIR}"
+ DEPENDS "${TARGET_NAME}"
+ )
+endif()
\ No newline at end of file
diff --git a/GUI/main_window.py b/GUI/main_window.py
deleted file mode 100644
index 53dacce61b5acbfe9de9607a2499c57e0a386eae..0000000000000000000000000000000000000000
--- a/GUI/main_window.py
+++ /dev/null
@@ -1,200 +0,0 @@
-"""@package docstring
-B-ASIC GUI Module.
-This python file is an example of how a GUI can be implemented
-using buttons and textboxes.
-"""
-
-import sys
-
-from PyQt5.QtWidgets import QApplication, QWidget, QMainWindow, QLabel, QAction,\
-QStatusBar, QMenuBar, QLineEdit, QPushButton
-from PyQt5.QtCore import Qt
-from PyQt5.QtGui import QIcon, QFont, QPainter, QPen
-
-
-class DragButton(QPushButton):
- """How to create a dragbutton"""
- def mousePressEvent(self, event):
- self._mouse_press_pos = None
- self._mouse_move_pos = None
- if event.button() == Qt.LeftButton:
- self._mouse_press_pos = event.globalPos()
- self._mouse_move_pos = event.globalPos()
-
- super(DragButton, self).mousePressEvent(event)
-
- def mouseMoveEvent(self, event):
- if event.buttons() == Qt.LeftButton:
- cur_pos = self.mapToGlobal(self.pos())
- global_pos = event.globalPos()
- diff = global_pos - self._mouse_move_pos
- new_pos = self.mapFromGlobal(cur_pos + diff)
- self.move(new_pos)
-
- self._mouse_move_pos = global_pos
-
- super(DragButton, self).mouseMoveEvent(event)
-
- def mouseReleaseEvent(self, event):
- if self._mouse_press_pos is not None:
- moved = event.globalPos() - self._mouse_press_pos
- if moved.manhattanLength() > 3:
- event.ignore()
- return
-
- super(DragButton, self).mouseReleaseEvent(event)
-
-class SubWindow(QWidget):
- """Creates a sub window """
- def create_window(self, window_width, window_height):
- """Creates a window
- """
- parent = None
- super(SubWindow, self).__init__(parent)
- self.setWindowFlags(Qt.WindowStaysOnTopHint)
- self.resize(window_width, window_height)
-
-class MainWindow(QMainWindow):
- """Main window for the program"""
- def __init__(self, *args, **kwargs):
- super(MainWindow, self).__init__(*args, **kwargs)
-
- self.setWindowTitle(" ")
- self.setWindowIcon(QIcon('small_logo.png'))
-
- # Menu buttons
- test_button = QAction("Test", self)
-
- exit_button = QAction("Exit", self)
- exit_button.setShortcut("Ctrl+Q")
- exit_button.triggered.connect(self.exit_app)
-
- edit_button = QAction("Edit", self)
- edit_button.setStatusTip("Open edit menu")
- edit_button.triggered.connect(self.on_edit_button_click)
-
- view_button = QAction("View", self)
- view_button.setStatusTip("Open view menu")
- view_button.triggered.connect(self.on_view_button_click)
-
- menu_bar = QMenuBar()
- menu_bar.setStyleSheet("background-color:rgb(222, 222, 222)")
- self.setMenuBar(menu_bar)
-
- file_menu = menu_bar.addMenu("&File")
- file_menu.addAction(exit_button)
- file_menu.addSeparator()
- file_menu.addAction(test_button)
-
- edit_menu = menu_bar.addMenu("&Edit")
- edit_menu.addAction(edit_button)
-
- edit_menu.addSeparator()
-
- view_menu = menu_bar.addMenu("&View")
- view_menu.addAction(view_button)
-
- self.setStatusBar(QStatusBar(self))
-
- def on_file_button_click(self):
- print("File")
-
- def on_edit_button_click(self):
- print("Edit")
-
- def on_view_button_click(self):
- print("View")
-
- def exit_app(self, checked):
- QApplication.quit()
-
- def clicked(self):
- print("Drag button clicked")
-
- def add_drag_buttons(self):
- """Adds draggable buttons"""
- addition_button = DragButton("Addition", self)
- addition_button.move(10, 130)
- addition_button.setFixedSize(70, 20)
- addition_button.clicked.connect(self.create_sub_window)
-
- addition_button2 = DragButton("Addition", self)
- addition_button2.move(10, 130)
- addition_button2.setFixedSize(70, 20)
- addition_button2.clicked.connect(self.create_sub_window)
-
- subtraction_button = DragButton("Subtraction", self)
- subtraction_button.move(10, 170)
- subtraction_button.setFixedSize(70, 20)
- subtraction_button.clicked.connect(self.create_sub_window)
-
- subtraction_button2 = DragButton("Subtraction", self)
- subtraction_button2.move(10, 170)
- subtraction_button2.setFixedSize(70, 20)
- subtraction_button2.clicked.connect(self.create_sub_window)
-
- multiplication_button = DragButton("Multiplication", self)
- multiplication_button.move(10, 210)
- multiplication_button.setFixedSize(70, 20)
- multiplication_button.clicked.connect(self.create_sub_window)
-
- multiplication_button2 = DragButton("Multiplication", self)
- multiplication_button2.move(10, 210)
- multiplication_button2.setFixedSize(70, 20)
- multiplication_button2.clicked.connect(self.create_sub_window)
-
- def paintEvent(self, e):
- # Temporary black box for operations
- painter = QPainter(self)
- painter.setPen(QPen(Qt.black, 5, Qt.SolidLine))
- painter.drawRect(0, 110, 100, 400)
-
- # Temporary arrow resembling a signal
- painter.setRenderHint(QPainter.Antialiasing)
- painter.setPen(Qt.black)
- painter.setBrush(Qt.white)
- painter.drawLine(300, 200, 400, 200)
- painter.drawLine(400, 200, 395, 195)
- painter.drawLine(400, 200, 395, 205)
-
- def create_sub_window(self):
- """ Example of how to create a sub window
- """
- self.sub_window = SubWindow()
- self.sub_window.create_window(400, 300)
- self.sub_window.setWindowTitle("Properties")
-
- self.sub_window.properties_label = QLabel(self.sub_window)
- self.sub_window.properties_label.setText('Properties')
- self.sub_window.properties_label.setFixedWidth(400)
- self.sub_window.properties_label.setFont(QFont('SansSerif', 14, QFont.Bold))
- self.sub_window.properties_label.setAlignment(Qt.AlignCenter)
-
- self.sub_window.name_label = QLabel(self.sub_window)
- self.sub_window.name_label.setText('Name:')
- self.sub_window.name_label.move(20, 40)
-
- self.sub_window.name_line = QLineEdit(self.sub_window)
- self.sub_window.name_line.setPlaceholderText("Write a name here")
- self.sub_window.name_line.move(70, 40)
- self.sub_window.name_line.resize(100, 20)
-
- self.sub_window.id_label = QLabel(self.sub_window)
- self.sub_window.id_label.setText('Id:')
- self.sub_window.id_label.move(20, 70)
-
- self.sub_window.id_line = QLineEdit(self.sub_window)
- self.sub_window.id_line.setPlaceholderText("Write an id here")
- self.sub_window.id_line.move(70, 70)
- self.sub_window.id_line.resize(100, 20)
-
- self.sub_window.show()
-
-
-if __name__ == "__main__":
- app = QApplication(sys.argv)
- window = MainWindow()
- window.add_drag_buttons()
- window.resize(960, 720)
- window.show()
- app.exec_()
diff --git a/README.md b/README.md
index fd98f919202588942a3e8d394b0b461ef63cfe54..b2972f30828f19038e5efe612831f989b8f5ffd5 100644
--- a/README.md
+++ b/README.md
@@ -8,16 +8,26 @@ How to build and debug the library during development.
### Prerequisites
The following packages are required in order to build the library:
-* cmake 3.8+
+* C++:
+ * cmake 3.8+
* gcc 7+/clang 7+/msvc 16+
* fmtlib 5.2.1+
* pybind11 2.3.0+
-* python 3.6+
+* Python:
+ * python 3.6+
* setuptools
- * wheel
* pybind11
* numpy
- * pyside2/pyqt5
+ * pyside2
+
+To build a binary distribution, the following additional packages are required:
+* Python:
+ * wheel
+
+To run the test suite, the following additional packages are required:
+* Python:
+ * pytest
+ * pytest-cov (for testing with coverage)
### Using CMake directly
How to build using CMake.
diff --git a/b_asic/GUI/__init__.py b/b_asic/GUI/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..16dd0253b1690cef57efa5a25f5adf28f53646f7
--- /dev/null
+++ b/b_asic/GUI/__init__.py
@@ -0,0 +1,4 @@
+"""TODO"""
+from drag_button import *
+from improved_main_window import *
+from gui_interface import *
diff --git a/b_asic/GUI/about_window.py b/b_asic/GUI/about_window.py
new file mode 100644
index 0000000000000000000000000000000000000000..699e1b7cbbd8e1b1929ad7fe44df7b88238526ae
--- /dev/null
+++ b/b_asic/GUI/about_window.py
@@ -0,0 +1,130 @@
+from PySide2.QtWidgets import QVBoxLayout, QHBoxLayout, QWidget, QDialog, QLabel, QFrame, QScrollArea
+from PySide2.QtCore import Qt
+
+
+QUESTIONS = {
+ "Adding operations": "Select an operation under 'Special operations' or 'Core operations' to add it to the workspace.",
+ "Moving operations": "To drag an operation, select the operation on the workspace and drag it around.",
+ "Selecting operations": "To select one operation just press it once, it will then turn grey.",
+ "Selecting multiple operations using dragging": "To select multiple operations using your mouse, \ndrag the mouse while pressing left mouse button, any operation under the selection box will then be selected.",
+ "Selecting multiple operations using without dragging": "To select mutliple operations using without dragging, \npress 'Ctrl+LMouseButton' on any operation.",
+ "Remove operations": "To remove an operation, select the operation to be deleted, \nfinally press RMouseButton to bring up the context menu, then press 'Delete'.",
+ "Remove multiple operations": "To remove multiple operations, \nselect all operations to be deleted and press 'Delete' on your keyboard.",
+ "Connecting operations": "To connect operations, select the ports on the operation to connect from, \nthen select the next port by pressing 'Ctrl+LMouseButton' on the destination port. Tip: You can chain connection by selecting the ports in the order they should be connected.",
+ "Creating a signal-flow-graph": "To create a signal-flow-graph (SFG), \ncouple together the operations you wish to create a sfg from, then select all operations you wish to include in the sfg, \nfinally press 'Create SFG' in the upper left corner and enter the name of the sfg.",
+ "Simulating a signal-flow-graph": "To simulate a signal-flow-graph (SFG), press the run button in the toolbar, \nthen press 'Simulate SFG' and enter the properties of the simulation.",
+ "Properties of simulation": "The properties of the simulation are, 'Iteration Count': The number of iterations to run the simulation for, \n'Plot Results': Open a plot over the output in matplotlib, \n'Get All Results': Print the detailed output from simulating the sfg in the terminal, \n'Input Values': The input values to the SFG by index of the port."
+}
+
+
+class KeybindsWindow(QDialog):
+ def __init__(self, window):
+ super(KeybindsWindow, self).__init__()
+ self._window = window
+ self.setWindowFlags(Qt.WindowTitleHint | Qt.WindowCloseButtonHint)
+ self.setWindowTitle("B-ASIC Keybinds")
+
+ self.dialog_layout = QVBoxLayout()
+ self.setLayout(self.dialog_layout)
+
+ self.add_information_to_layout()
+
+ def add_information_to_layout(self):
+ information_layout = QVBoxLayout()
+
+ title_label = QLabel("B-ASIC / Better ASIC Toolbox")
+ subtitle_label = QLabel("Keybinds in the GUI.")
+
+ frame = QFrame()
+ frame.setFrameShape(QFrame.HLine)
+ frame.setFrameShadow(QFrame.Sunken)
+ self.dialog_layout.addWidget(frame)
+
+ keybinds_label = QLabel(
+ "'Ctrl+R' - Reload the operation list to add any new operations created.\n"
+ "'Ctrl+Q' - Quit the application.\n"
+ "'Ctrl+LMouseButton' - On a operation will select the operation, without deselecting the other operations.\n"
+ "'Ctrl+S' (Plot) - Save the plot if a plot is visible.\n"
+ "'Ctrl+?' - Open the FAQ section."
+ )
+
+ information_layout.addWidget(title_label)
+ information_layout.addWidget(subtitle_label)
+
+ self.dialog_layout.addLayout(information_layout)
+ self.dialog_layout.addWidget(frame)
+
+ self.dialog_layout.addWidget(keybinds_label)
+
+
+class AboutWindow(QDialog):
+ def __init__(self, window):
+ super(AboutWindow, self).__init__()
+ self._window = window
+ self.setWindowFlags(Qt.WindowTitleHint | Qt.WindowCloseButtonHint)
+ self.setWindowTitle("About B-ASIC")
+
+ self.dialog_layout = QVBoxLayout()
+ self.setLayout(self.dialog_layout)
+
+ self.add_information_to_layout()
+
+ def add_information_to_layout(self):
+ information_layout = QVBoxLayout()
+
+ title_label = QLabel("B-ASIC / Better ASIC Toolbox")
+ subtitle_label = QLabel("Construct, simulate and analyze components of an ASIC.")
+
+ frame = QFrame()
+ frame.setFrameShape(QFrame.HLine)
+ frame.setFrameShadow(QFrame.Sunken)
+ self.dialog_layout.addWidget(frame)
+
+ about_label = QLabel(
+ "B-ASIC is a open source tool using the B-ASIC library to construct, simulate and analyze ASICs.\n"
+ "B-ASIC is developed under the MIT-license and any extension to the program should follow that same license.\n"
+ "To read more about how the GUI works please refer to the FAQ under 'Help'."
+ )
+
+ information_layout.addWidget(title_label)
+ information_layout.addWidget(subtitle_label)
+
+ self.dialog_layout.addLayout(information_layout)
+ self.dialog_layout.addWidget(frame)
+
+ self.dialog_layout.addWidget(about_label)
+
+
+class FaqWindow(QDialog):
+ def __init__(self, window):
+ super(FaqWindow, self).__init__()
+ self._window = window
+ self.setWindowFlags(Qt.WindowTitleHint | Qt.WindowCloseButtonHint)
+ self.setWindowTitle("Frequently Asked Questions")
+
+ self.dialog_layout = QVBoxLayout()
+ self.scroll_area = QScrollArea()
+ self.setLayout(self.dialog_layout)
+ for question, answer in QUESTIONS.items():
+ self.add_question_to_layout(question, answer)
+
+ self.scroll_area.setWidget(self)
+ self.scroll_area.setWidgetResizable(True)
+
+ def add_question_to_layout(self, question, answer):
+ question_layout = QVBoxLayout()
+ answer_layout = QHBoxLayout()
+
+ question_label = QLabel(question)
+ question_layout.addWidget(question_label)
+
+ answer_label = QLabel(answer)
+ answer_layout.addWidget(answer_label)
+
+ frame = QFrame()
+ frame.setFrameShape(QFrame.HLine)
+ frame.setFrameShadow(QFrame.Sunken)
+ self.dialog_layout.addWidget(frame)
+
+ question_layout.addLayout(answer_layout)
+ self.dialog_layout.addLayout(question_layout)
diff --git a/b_asic/GUI/arrow.py b/b_asic/GUI/arrow.py
new file mode 100644
index 0000000000000000000000000000000000000000..aea8fec3b488d7fbfe49766f3a23b3fa2346a920
--- /dev/null
+++ b/b_asic/GUI/arrow.py
@@ -0,0 +1,40 @@
+from PySide2.QtWidgets import QApplication, QWidget, QMainWindow, QLabel, QAction,\
+QStatusBar, QMenuBar, QLineEdit, QPushButton, QSlider, QScrollArea, QVBoxLayout,\
+QHBoxLayout, QDockWidget, QToolBar, QMenu, QLayout, QSizePolicy, QListWidget, QListWidgetItem,\
+QGraphicsLineItem, QGraphicsWidget
+from PySide2.QtCore import Qt, QSize, QLineF, QPoint, QRectF
+from PySide2.QtGui import QIcon, QFont, QPainter, QPen
+
+from b_asic import Signal
+
+class Arrow(QGraphicsLineItem):
+
+ def __init__(self, source, destination, window, create_signal=True, parent=None):
+ super(Arrow, self).__init__(parent)
+ self.source = source
+ # if an signal does not exist create one
+ if create_signal:
+ self.signal = Signal(source.port, destination.port)
+ self.destination = destination
+ self._window = window
+ self.moveLine()
+ self.source.moved.connect(self.moveLine)
+ self.destination.moved.connect(self.moveLine)
+
+ def contextMenuEvent(self, event):
+ menu = QMenu()
+ menu.addAction("Delete", self.remove)
+ menu.exec_(self.cursor().pos())
+
+ def remove(self):
+ self.signal.remove_destination()
+ self.signal.remove_source()
+ self._window.scene.removeItem(self)
+ self._window.signalList.remove(self)
+
+ def moveLine(self):
+ self.setPen(QPen(Qt.black, 3))
+ self.setLine(QLineF(self.source.operation.x()+self.source.x()+14,\
+ self.source.operation.y()+self.source.y()+7.5,\
+ self.destination.operation.x()+self.destination.x(),\
+ self.destination.operation.y()+self.destination.y()+7.5))
diff --git a/b_asic/GUI/drag_button.py b/b_asic/GUI/drag_button.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe78f46323400555fce5687cc2459009e61c0a4a
--- /dev/null
+++ b/b_asic/GUI/drag_button.py
@@ -0,0 +1,145 @@
+"""@package docstring
+Drag button class.
+This class creates a dragbutton which can be clicked, dragged and dropped.
+"""
+
+import os.path
+
+from properties_window import PropertiesWindow
+
+from PySide2.QtWidgets import QPushButton, QMenu, QAction
+from PySide2.QtCore import Qt, QSize, Signal
+from PySide2.QtGui import QIcon
+
+from utils import decorate_class, handle_error
+
+
+@decorate_class(handle_error)
+class DragButton(QPushButton):
+ connectionRequested = Signal(QPushButton)
+ moved = Signal()
+ def __init__(self, name, operation, operation_path_name, is_show_name, window, parent = None):
+ self.name = name
+ self.ports = []
+ self.is_show_name = is_show_name
+ self._window = window
+ self.operation = operation
+ self.operation_path_name = operation_path_name
+ self.clicked = 0
+ self.pressed = False
+ self._m_press = False
+ self._m_drag = False
+ self._mouse_press_pos = None
+ self._mouse_move_pos = None
+ super(DragButton, self).__init__(parent)
+
+ def contextMenuEvent(self, event):
+ menu = QMenu()
+ properties = QAction("Properties")
+ menu.addAction(properties)
+ properties.triggered.connect(self.show_properties_window)
+
+ delete = QAction("Delete")
+ menu.addAction(delete)
+ delete.triggered.connect(self.remove)
+ menu.exec_(self.cursor().pos())
+
+ def show_properties_window(self):
+ self.properties_window = PropertiesWindow(self, self._window)
+ self.properties_window.show()
+
+ def add_label(self, label):
+ self.label = label
+
+ def mousePressEvent(self, event):
+ if event.button() == Qt.LeftButton:
+ self._m_press = True
+ self._mouse_press_pos = event.pos()
+ self._mouse_move_pos = event.pos()
+
+ super(DragButton, self).mousePressEvent(event)
+
+ def mouseMoveEvent(self, event):
+ if event.buttons() == Qt.LeftButton and self._m_press:
+ self._m_drag = True
+ self.move(self.mapToParent(event.pos() - self._mouse_press_pos))
+ if self in self._window.pressed_operations:
+ for button in self._window.pressed_operations:
+ if button is self:
+ continue
+
+ button.move(button.mapToParent(event.pos() - self._mouse_press_pos))
+
+ self._window.scene.update()
+ self._window.graphic_view.update()
+ super(DragButton, self).mouseMoveEvent(event)
+
+ def mouseReleaseEvent(self, event):
+ self._m_press = False
+ if self._m_drag:
+ if self._mouse_press_pos is not None:
+ moved = event.pos() - self._mouse_press_pos
+ if moved.manhattanLength() > 3:
+ event.ignore()
+
+ self._m_drag = False
+
+ else:
+ self.select_button(event.modifiers())
+
+ super(DragButton, self).mouseReleaseEvent(event)
+
+ def _toggle_button(self, pressed=False):
+ self.pressed = not pressed
+ self.setStyleSheet(f"background-color: {'white' if not self.pressed else 'grey'}; border-style: solid;\
+ border-color: black; border-width: 2px")
+ path_to_image = os.path.join('operation_icons', f"{self.operation_path_name}{'_grey.png' if self.pressed else '.png'}")
+ self.setIcon(QIcon(path_to_image))
+ self.setIconSize(QSize(55, 55))
+
+ def select_button(self, modifiers=None):
+ if modifiers != Qt.ControlModifier:
+ for button in self._window.pressed_operations:
+ button._toggle_button(button.pressed)
+
+ self._toggle_button(self.pressed)
+ self._window.pressed_operations = [self]
+
+ else:
+ self._toggle_button(self.pressed)
+ if self in self._window.pressed_operations:
+ self._window.pressed_operations.remove(self)
+ else:
+ self._window.pressed_operations.append(self)
+
+ for signal in self._window.signalList:
+ signal.update()
+
+ def remove(self):
+ self._window.logger.info(f"Removing operation with name {self.operation.name}.")
+ self._window.scene.removeItem(self._window.dragOperationSceneDict[self])
+
+ _signals = []
+ for signal, ports in self._window.signalPortDict.items():
+ if any(map(lambda port: set(port).intersection(set(self._window.portDict[self])), ports)):
+ self._window.logger.info(f"Removed signal with name: {signal.signal.name} to/from operation: {self.operation.name}.")
+ signal.remove()
+ _signals.append(signal)
+
+ if self in self._window.opToSFG:
+ self._window.logger.info(f"Operation detected in existing sfg, removing sfg with name: {self._window.opToSFG[self].name}.")
+ self._window.opToSFG = {op: self._window.opToSFG[op] for op in self._window.opToSFG if self._window.opToSFG[op] is self._window.opToSFG[self]}
+ del self._window.sfg_dict[self._window.opToSFG[self].name]
+
+ for signal in _signals:
+ del self._window.signalPortDict[signal]
+
+ for port in self._window.portDict[self]:
+ if port in self._window.pressed_ports:
+ self._window.pressed_ports.remove(port)
+
+ if self in self._window.pressed_operations:
+ self._window.pressed_operations.remove(self)
+
+ if self in self._window.dragOperationSceneDict.keys():
+ del self._window.dragOperationSceneDict[self]
diff --git a/b_asic/GUI/gui_interface.py b/b_asic/GUI/gui_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..a46a9d7984386daf9398bfe45267dba59a0eea31
--- /dev/null
+++ b/b_asic/GUI/gui_interface.py
@@ -0,0 +1,334 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'gui_interface.ui'
+#
+# Created by: PyQt5 UI code generator 5.14.2
+#
+# WARNING! All changes made in this file will be lost!
+
+
+from PySide2 import QtCore, QtGui, QtWidgets
+
+
+class Ui_main_window(object):
+ def setupUi(self, main_window):
+ main_window.setObjectName("main_window")
+ main_window.setEnabled(True)
+ main_window.resize(897, 633)
+ self.centralwidget = QtWidgets.QWidget(main_window)
+ self.centralwidget.setObjectName("centralwidget")
+ self.operation_box = QtWidgets.QGroupBox(self.centralwidget)
+ self.operation_box.setGeometry(QtCore.QRect(10, 10, 201, 531))
+ self.operation_box.setLayoutDirection(QtCore.Qt.LeftToRight)
+ self.operation_box.setAutoFillBackground(False)
+ self.operation_box.setStyleSheet("QGroupBox { \n"
+" border: 2px solid gray; \n"
+" border-radius: 3px;\n"
+" margin-top: 0.5em; \n"
+" } \n"
+"\n"
+"QGroupBox::title {\n"
+" subcontrol-origin: margin;\n"
+" left: 10px;\n"
+" padding: 0 3px 0 3px;\n"
+"}")
+ self.operation_box.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
+ self.operation_box.setFlat(False)
+ self.operation_box.setCheckable(False)
+ self.operation_box.setObjectName("operation_box")
+ self.operation_list = QtWidgets.QToolBox(self.operation_box)
+ self.operation_list.setGeometry(QtCore.QRect(10, 20, 171, 271))
+ self.operation_list.setAutoFillBackground(False)
+ self.operation_list.setObjectName("operation_list")
+ self.core_operations_page = QtWidgets.QWidget()
+ self.core_operations_page.setGeometry(QtCore.QRect(0, 0, 171, 217))
+ self.core_operations_page.setObjectName("core_operations_page")
+ self.core_operations_list = QtWidgets.QListWidget(self.core_operations_page)
+ self.core_operations_list.setGeometry(QtCore.QRect(10, 0, 141, 211))
+ self.core_operations_list.setMinimumSize(QtCore.QSize(141, 0))
+ self.core_operations_list.setEditTriggers(QtWidgets.QAbstractItemView.DoubleClicked|QtWidgets.QAbstractItemView.EditKeyPressed)
+ self.core_operations_list.setDragEnabled(False)
+ self.core_operations_list.setDragDropMode(QtWidgets.QAbstractItemView.NoDragDrop)
+ self.core_operations_list.setMovement(QtWidgets.QListView.Static)
+ self.core_operations_list.setFlow(QtWidgets.QListView.TopToBottom)
+ self.core_operations_list.setProperty("isWrapping", False)
+ self.core_operations_list.setResizeMode(QtWidgets.QListView.Adjust)
+ self.core_operations_list.setLayoutMode(QtWidgets.QListView.SinglePass)
+ self.core_operations_list.setViewMode(QtWidgets.QListView.ListMode)
+ self.core_operations_list.setUniformItemSizes(False)
+ self.core_operations_list.setWordWrap(False)
+ self.core_operations_list.setSelectionRectVisible(False)
+ self.core_operations_list.setObjectName("core_operations_list")
+ self.operation_list.addItem(self.core_operations_page, "")
+ self.special_operations_page = QtWidgets.QWidget()
+ self.special_operations_page.setGeometry(QtCore.QRect(0, 0, 171, 217))
+ self.special_operations_page.setObjectName("special_operations_page")
+ self.special_operations_list = QtWidgets.QListWidget(self.special_operations_page)
+ self.special_operations_list.setGeometry(QtCore.QRect(10, 0, 141, 211))
+ self.special_operations_list.setObjectName("special_operations_list")
+ self.operation_list.addItem(self.special_operations_page, "")
+ self.custom_operations_page = QtWidgets.QWidget()
+ self.custom_operations_page.setGeometry(QtCore.QRect(0, 0, 171, 217))
+ self.custom_operations_page.setObjectName("custom_operations_page")
+ self.custom_operations_list = QtWidgets.QListWidget(self.custom_operations_page)
+ self.custom_operations_list.setGeometry(QtCore.QRect(10, 0, 141, 211))
+ self.custom_operations_list.setObjectName("custom_operations_list")
+ self.operation_list.addItem(self.custom_operations_page, "")
+ main_window.setCentralWidget(self.centralwidget)
+ self.menu_bar = QtWidgets.QMenuBar(main_window)
+ self.menu_bar.setGeometry(QtCore.QRect(0, 0, 897, 21))
+ palette = QtGui.QPalette()
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 255, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Light, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Midlight, brush)
+ brush = QtGui.QBrush(QtGui.QColor(127, 127, 127))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Dark, brush)
+ brush = QtGui.QBrush(QtGui.QColor(170, 170, 170))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Mid, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.BrightText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ButtonText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Shadow, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.AlternateBase, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipBase, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.PlaceholderText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 255, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Light, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Midlight, brush)
+ brush = QtGui.QBrush(QtGui.QColor(127, 127, 127))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Dark, brush)
+ brush = QtGui.QBrush(QtGui.QColor(170, 170, 170))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Mid, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.BrightText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ButtonText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Shadow, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.AlternateBase, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipBase, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.PlaceholderText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(127, 127, 127))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 255, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Light, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Midlight, brush)
+ brush = QtGui.QBrush(QtGui.QColor(127, 127, 127))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Dark, brush)
+ brush = QtGui.QBrush(QtGui.QColor(170, 170, 170))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Mid, brush)
+ brush = QtGui.QBrush(QtGui.QColor(127, 127, 127))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.BrightText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(127, 127, 127))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ButtonText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Shadow, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.AlternateBase, brush)
+ brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipBase, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipText, brush)
+ brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
+ brush.setStyle(QtCore.Qt.SolidPattern)
+ palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.PlaceholderText, brush)
+ self.menu_bar.setPalette(palette)
+ self.menu_bar.setObjectName("menu_bar")
+ self.file_menu = QtWidgets.QMenu(self.menu_bar)
+ self.file_menu.setObjectName("file_menu")
+ self.edit_menu = QtWidgets.QMenu(self.menu_bar)
+ self.edit_menu.setObjectName("edit_menu")
+ self.view_menu = QtWidgets.QMenu(self.menu_bar)
+ self.view_menu.setObjectName("view_menu")
+ self.run_menu = QtWidgets.QMenu(self.menu_bar)
+ self.run_menu.setObjectName("run_menu")
+ self.help_menu = QtWidgets.QMenu(self.menu_bar)
+ self.help_menu.setObjectName("help_menu")
+ main_window.setMenuBar(self.menu_bar)
+ self.status_bar = QtWidgets.QStatusBar(main_window)
+ self.status_bar.setObjectName("status_bar")
+ main_window.setStatusBar(self.status_bar)
+ self.load_menu = QtWidgets.QAction(main_window)
+ self.load_menu.setObjectName("load_menu")
+ self.save_menu = QtWidgets.QAction(main_window)
+ self.save_menu.setObjectName("save_menu")
+ self.load_operations = QtWidgets.QAction(main_window)
+ self.load_operations.setObjectName("load_operations")
+ self.exit_menu = QtWidgets.QAction(main_window)
+ self.exit_menu.setObjectName("exit_menu")
+ self.actionUndo = QtWidgets.QAction(main_window)
+ self.actionUndo.setObjectName("actionUndo")
+ self.actionRedo = QtWidgets.QAction(main_window)
+ self.actionRedo.setObjectName("actionRedo")
+ self.actionSimulateSFG = QtWidgets.QAction(main_window)
+ self.actionSimulateSFG.setObjectName("actionSimulateSFG")
+ self.actionShowPC = QtWidgets.QAction(main_window)
+ self.actionShowPC.setObjectName("actionShowPC")
+ self.aboutBASIC = QtWidgets.QAction(main_window)
+ self.aboutBASIC.setObjectName("aboutBASIC")
+ self.faqBASIC = QtWidgets.QAction(main_window)
+ self.faqBASIC.setObjectName("faqBASIC")
+ self.keybindsBASIC = QtWidgets.QAction(main_window)
+ self.keybindsBASIC.setObjectName("keybindsBASIC")
+ self.actionToolbar = QtWidgets.QAction(main_window)
+ self.actionToolbar.setCheckable(True)
+ self.actionToolbar.setObjectName("actionToolbar")
+ self.file_menu.addAction(self.load_menu)
+ self.file_menu.addAction(self.save_menu)
+ self.file_menu.addAction(self.load_operations)
+ self.file_menu.addSeparator()
+ self.file_menu.addAction(self.exit_menu)
+ self.edit_menu.addAction(self.actionUndo)
+ self.edit_menu.addAction(self.actionRedo)
+ self.view_menu.addAction(self.actionToolbar)
+ self.run_menu.addAction(self.actionShowPC)
+ self.run_menu.addAction(self.actionSimulateSFG)
+ self.help_menu.addAction(self.aboutBASIC)
+ self.help_menu.addAction(self.faqBASIC)
+ self.help_menu.addAction(self.keybindsBASIC)
+ self.menu_bar.addAction(self.file_menu.menuAction())
+ self.menu_bar.addAction(self.edit_menu.menuAction())
+ self.menu_bar.addAction(self.view_menu.menuAction())
+ self.menu_bar.addAction(self.run_menu.menuAction())
+ self.menu_bar.addAction(self.help_menu.menuAction())
+
+ self.retranslateUi(main_window)
+ self.operation_list.setCurrentIndex(1)
+ self.core_operations_list.setCurrentRow(-1)
+ QtCore.QMetaObject.connectSlotsByName(main_window)
+
+ def retranslateUi(self, main_window):
+ _translate = QtCore.QCoreApplication.translate
+ main_window.setWindowTitle(_translate("main_window", "B-ASIC"))
+ self.operation_box.setTitle(_translate("main_window", "Operations"))
+ self.core_operations_list.setSortingEnabled(False)
+ __sortingEnabled = self.core_operations_list.isSortingEnabled()
+ self.core_operations_list.setSortingEnabled(False)
+ self.core_operations_list.setSortingEnabled(__sortingEnabled)
+ self.operation_list.setItemText(self.operation_list.indexOf(self.core_operations_page), _translate("main_window", "Core operations"))
+ __sortingEnabled = self.special_operations_list.isSortingEnabled()
+ self.special_operations_list.setSortingEnabled(False)
+ self.special_operations_list.setSortingEnabled(__sortingEnabled)
+ self.operation_list.setItemText(self.operation_list.indexOf(self.special_operations_page), _translate("main_window", "Special operations"))
+ __sortingEnabled = self.special_operations_list.isSortingEnabled()
+ self.custom_operations_list.setSortingEnabled(False)
+ self.custom_operations_list.setSortingEnabled(__sortingEnabled)
+ self.operation_list.setItemText(self.operation_list.indexOf(self.custom_operations_page), _translate("main_window", "Custom operation"))
+ self.file_menu.setTitle(_translate("main_window", "File"))
+ self.edit_menu.setTitle(_translate("main_window", "Edit"))
+ self.view_menu.setTitle(_translate("main_window", "View"))
+ self.run_menu.setTitle(_translate("main_window", "Run"))
+ self.actionShowPC.setText(_translate("main_window", "Show PC"))
+ self.help_menu.setTitle(_translate("main_window", "Help"))
+ self.actionSimulateSFG.setText(_translate("main_window", "Simulate SFG"))
+ self.aboutBASIC.setText(_translate("main_window", "About B-ASIC"))
+ self.faqBASIC.setText(_translate("main_window", "FAQ"))
+ self.keybindsBASIC.setText(_translate("main_window", "Keybinds"))
+ self.load_menu.setText(_translate("main_window", "Load SFG"))
+ self.save_menu.setText(_translate("main_window", "Save SFG"))
+ self.load_operations.setText(_translate("main_window", "Load Operations"))
+ self.exit_menu.setText(_translate("main_window", "Exit"))
+ self.exit_menu.setShortcut(_translate("main_window", "Ctrl+Q"))
+ self.actionUndo.setText(_translate("main_window", "Undo"))
+ self.actionRedo.setText(_translate("main_window", "Redo"))
+ self.actionToolbar.setText(_translate("main_window", "Toolbar"))
+
+
+if __name__ == "__main__":
+ import sys
+ app = QtWidgets.QApplication(sys.argv)
+ main_window = QtWidgets.QMainWindow()
+ ui = Ui_main_window()
+ ui.setupUi(main_window)
+ main_window.show()
+ sys.exit(app.exec_())
diff --git a/b_asic/GUI/gui_interface.ui b/b_asic/GUI/gui_interface.ui
new file mode 100644
index 0000000000000000000000000000000000000000..382747818a3286373b825e4115c9b283799156bc
--- /dev/null
+++ b/b_asic/GUI/gui_interface.ui
@@ -0,0 +1,763 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>main_window</class>
+ <widget class="QMainWindow" name="main_window">
+ <property name="enabled">
+ <bool>true</bool>
+ </property>
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>897</width>
+ <height>633</height>
+ </rect>
+ </property>
+ <property name="windowTitle">
+ <string>MainWindow</string>
+ </property>
+ <widget class="QWidget" name="centralwidget">
+ <widget class="QGroupBox" name="operation_box">
+ <property name="geometry">
+ <rect>
+ <x>10</x>
+ <y>10</y>
+ <width>201</width>
+ <height>531</height>
+ </rect>
+ </property>
+ <property name="layoutDirection">
+ <enum>Qt::LeftToRight</enum>
+ </property>
+ <property name="autoFillBackground">
+ <bool>false</bool>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">QGroupBox {
+ border: 2px solid gray;
+ border-radius: 3px;
+ margin-top: 0.5em;
+ }
+
+QGroupBox::title {
+ subcontrol-origin: margin;
+ left: 10px;
+ padding: 0 3px 0 3px;
+}</string>
+ </property>
+ <property name="title">
+ <string>Operations</string>
+ </property>
+ <property name="alignment">
+ <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
+ </property>
+ <property name="flat">
+ <bool>false</bool>
+ </property>
+ <property name="checkable">
+ <bool>false</bool>
+ </property>
+ <widget class="QToolBox" name="operation_list">
+ <property name="geometry">
+ <rect>
+ <x>10</x>
+ <y>20</y>
+ <width>171</width>
+ <height>271</height>
+ </rect>
+ </property>
+ <property name="autoFillBackground">
+ <bool>false</bool>
+ </property>
+ <property name="currentIndex">
+ <number>1</number>
+ </property>
+ <widget class="QWidget" name="core_operations_page">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>171</width>
+ <height>217</height>
+ </rect>
+ </property>
+ <attribute name="label">
+ <string>Core operations</string>
+ </attribute>
+ <widget class="QListWidget" name="core_operations_list">
+ <property name="geometry">
+ <rect>
+ <x>10</x>
+ <y>0</y>
+ <width>141</width>
+ <height>211</height>
+ </rect>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>141</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="editTriggers">
+ <set>QAbstractItemView::DoubleClicked|QAbstractItemView::EditKeyPressed</set>
+ </property>
+ <property name="dragEnabled">
+ <bool>false</bool>
+ </property>
+ <property name="dragDropMode">
+ <enum>QAbstractItemView::NoDragDrop</enum>
+ </property>
+ <property name="movement">
+ <enum>QListView::Static</enum>
+ </property>
+ <property name="flow">
+ <enum>QListView::TopToBottom</enum>
+ </property>
+ <property name="isWrapping" stdset="0">
+ <bool>false</bool>
+ </property>
+ <property name="resizeMode">
+ <enum>QListView::Adjust</enum>
+ </property>
+ <property name="layoutMode">
+ <enum>QListView::SinglePass</enum>
+ </property>
+ <property name="viewMode">
+ <enum>QListView::ListMode</enum>
+ </property>
+ <property name="uniformItemSizes">
+ <bool>false</bool>
+ </property>
+ <property name="wordWrap">
+ <bool>false</bool>
+ </property>
+ <property name="selectionRectVisible">
+ <bool>false</bool>
+ </property>
+ <property name="currentRow">
+ <number>-1</number>
+ </property>
+ <property name="sortingEnabled">
+ <bool>false</bool>
+ </property>
+ <item>
+ <property name="text">
+ <string>Addition</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Subtraction</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Multiplication</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Division</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Constant</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Constant multiplication</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Square root</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Complex conjugate</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Absolute</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Max</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Min</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Butterfly</string>
+ </property>
+ </item>
+ </widget>
+ </widget>
+ <widget class="QWidget" name="special_operations_page">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>171</width>
+ <height>217</height>
+ </rect>
+ </property>
+ <attribute name="label">
+ <string>Special operations</string>
+ </attribute>
+ <widget class="QListWidget" name="special_operations_list">
+ <property name="geometry">
+ <rect>
+ <x>10</x>
+ <y>0</y>
+ <width>141</width>
+ <height>81</height>
+ </rect>
+ </property>
+ <item>
+ <property name="text">
+ <string>Input</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Output</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Delay</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Custom</string>
+ </property>
+ </item>
+ </widget>
+ </widget>
+ </widget>
+ </widget>
+ </widget>
+ <widget class="QMenuBar" name="menu_bar">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>897</width>
+ <height>21</height>
+ </rect>
+ </property>
+ <property name="palette">
+ <palette>
+ <active>
+ <colorrole role="WindowText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Button">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>255</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Light">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Midlight">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Dark">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>127</red>
+ <green>127</green>
+ <blue>127</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Mid">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>170</red>
+ <green>170</green>
+ <blue>170</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Text">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="BrightText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ButtonText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Base">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Window">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Shadow">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="AlternateBase">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ToolTipBase">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>220</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ToolTipText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="PlaceholderText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="128">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ </active>
+ <inactive>
+ <colorrole role="WindowText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Button">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>255</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Light">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Midlight">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Dark">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>127</red>
+ <green>127</green>
+ <blue>127</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Mid">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>170</red>
+ <green>170</green>
+ <blue>170</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Text">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="BrightText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ButtonText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Base">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Window">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Shadow">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="AlternateBase">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ToolTipBase">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>220</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ToolTipText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="PlaceholderText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="128">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ </inactive>
+ <disabled>
+ <colorrole role="WindowText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>127</red>
+ <green>127</green>
+ <blue>127</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Button">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>255</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Light">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Midlight">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Dark">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>127</red>
+ <green>127</green>
+ <blue>127</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Mid">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>170</red>
+ <green>170</green>
+ <blue>170</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Text">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>127</red>
+ <green>127</green>
+ <blue>127</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="BrightText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ButtonText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>127</red>
+ <green>127</green>
+ <blue>127</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Base">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Window">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="Shadow">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="AlternateBase">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>255</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ToolTipBase">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>255</red>
+ <green>255</green>
+ <blue>220</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="ToolTipText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="255">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ <colorrole role="PlaceholderText">
+ <brush brushstyle="SolidPattern">
+ <color alpha="128">
+ <red>0</red>
+ <green>0</green>
+ <blue>0</blue>
+ </color>
+ </brush>
+ </colorrole>
+ </disabled>
+ </palette>
+ </property>
+ <widget class="QMenu" name="file_menu">
+ <property name="title">
+ <string>File</string>
+ </property>
+ <addaction name="save_menu"/>
+ <addaction name="separator"/>
+ <addaction name="exit_menu"/>
+ </widget>
+ <widget class="QMenu" name="edit_menu">
+ <property name="title">
+ <string>Edit</string>
+ </property>
+ <addaction name="actionUndo"/>
+ <addaction name="actionRedo"/>
+ </widget>
+ <widget class="QMenu" name="view_menu">
+ <property name="title">
+ <string>View</string>
+ </property>
+ <addaction name="actionToolbar"/>
+ </widget>
+ <addaction name="file_menu"/>
+ <addaction name="edit_menu"/>
+ <addaction name="view_menu"/>
+ </widget>
+ <widget class="QStatusBar" name="status_bar"/>
+ <action name="save_menu">
+ <property name="text">
+ <string>Save</string>
+ </property>
+ </action>
+ <action name="exit_menu">
+ <property name="text">
+ <string>Exit</string>
+ </property>
+ <property name="shortcut">
+ <string>Ctrl+Q</string>
+ </property>
+ </action>
+ <action name="actionUndo">
+ <property name="text">
+ <string>Undo</string>
+ </property>
+ </action>
+ <action name="actionRedo">
+ <property name="text">
+ <string>Redo</string>
+ </property>
+ </action>
+ <action name="actionToolbar">
+ <property name="checkable">
+ <bool>true</bool>
+ </property>
+ <property name="text">
+ <string>Toolbar</string>
+ </property>
+ </action>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/b_asic/GUI/main_window.py b/b_asic/GUI/main_window.py
new file mode 100644
index 0000000000000000000000000000000000000000..0607100a2f45b618f179b8a2bffcc98d52eb9173
--- /dev/null
+++ b/b_asic/GUI/main_window.py
@@ -0,0 +1,485 @@
+"""@package docstring
+B-ASIC GUI Module.
+This python file is the main window of the GUI for B-ASIC.
+"""
+
+from pprint import pprint
+from os import getcwd, path
+import importlib
+import logging
+logging.basicConfig(level=logging.INFO)
+import sys
+
+from about_window import AboutWindow, FaqWindow, KeybindsWindow
+from drag_button import DragButton
+from gui_interface import Ui_main_window
+from arrow import Arrow
+from port_button import PortButton
+from show_pc_window import ShowPCWindow
+
+from b_asic.simulation import Simulation
+from b_asic import Operation, SFG, InputPort, OutputPort, Input, Output, FastSimulation
+import b_asic.core_operations as c_oper
+import b_asic.special_operations as s_oper
+from utils import decorate_class, handle_error
+from simulate_sfg_window import SimulateSFGWindow, Plot
+from select_sfg_window import SelectSFGWindow
+from b_asic.save_load_structure import *
+
+from numpy import linspace
+
+from PySide2.QtWidgets import QApplication, QWidget, QMainWindow, QLabel, QAction,\
+QStatusBar, QMenuBar, QLineEdit, QPushButton, QSlider, QScrollArea, QVBoxLayout,\
+QHBoxLayout, QDockWidget, QToolBar, QMenu, QLayout, QSizePolicy, QListWidget,\
+QListWidgetItem, QGraphicsView, QGraphicsScene, QShortcut, QGraphicsTextItem,\
+QGraphicsProxyWidget, QInputDialog, QTextEdit, QFileDialog
+from PySide2.QtCore import Qt, QSize, QFileInfo
+from PySide2.QtGui import QIcon, QFont, QPainter, QPen, QBrush, QKeySequence
+
+from tkinter import Tk
+from tkinter.filedialog import askopenfilename, askopenfile
+
+
+MIN_WIDTH_SCENE = 600
+MIN_HEIGHT_SCENE = 520
+
+@decorate_class(handle_error)
+class MainWindow(QMainWindow):
+ def __init__(self):
+ super(MainWindow, self).__init__()
+ self.ui = Ui_main_window()
+ self.ui.setupUi(self)
+ self.setWindowIcon(QIcon('small_logo.png'))
+ self.scene = None
+ self._operations_from_name = dict()
+ self.zoom = 1
+ self.sfg_name_i = 0
+ self.dragOperationSceneDict = dict()
+ self.operationDragDict = dict()
+ self.operationItemSceneList = []
+ self.signalList = []
+ self.pressed_operations = []
+ self.portDict = dict()
+ self.signalPortDict = dict()
+ self.opToSFG = dict()
+ self.pressed_ports = []
+ self.sfg_dict = dict()
+ self._window = self
+ self.logger = logging.getLogger(__name__)
+ self.init_ui()
+ self.add_operations_from_namespace(c_oper, self.ui.core_operations_list)
+ self.add_operations_from_namespace(s_oper, self.ui.special_operations_list)
+
+ self.shortcut_core = QShortcut(QKeySequence("Ctrl+R"), self.ui.operation_box)
+ self.shortcut_core.activated.connect(self._refresh_operations_list_from_namespace)
+ self.scene.selectionChanged.connect(self._select_operations)
+
+ self.move_button_index = 0
+ self.is_show_names = True
+
+ self.check_show_names = QAction("Show operation names")
+ self.check_show_names.triggered.connect(self.view_operation_names)
+ self.check_show_names.setCheckable(True)
+ self.check_show_names.setChecked(1)
+ self.ui.view_menu.addAction(self.check_show_names)
+
+ self.ui.actionShowPC.triggered.connect(self.show_precedence_chart)
+ self.ui.actionSimulateSFG.triggered.connect(self.simulate_sfg)
+ self.ui.faqBASIC.triggered.connect(self.display_faq_page)
+ self.ui.aboutBASIC.triggered.connect(self.display_about_page)
+ self.ui.keybindsBASIC.triggered.connect(self.display_keybinds_page)
+ self.ui.core_operations_list.itemClicked.connect(self.on_list_widget_item_clicked)
+ self.ui.special_operations_list.itemClicked.connect(self.on_list_widget_item_clicked)
+ self.ui.custom_operations_list.itemClicked.connect(self.on_list_widget_item_clicked)
+ self.ui.save_menu.triggered.connect(self.save_work)
+ self.ui.load_menu.triggered.connect(self.load_work)
+ self.ui.load_operations.triggered.connect(self.add_namespace)
+ self.ui.exit_menu.triggered.connect(self.exit_app)
+ self.shortcut_open = QShortcut(QKeySequence("Ctrl+O"), self)
+ self.shortcut_open.activated.connect(self.load_work)
+ self.shortcut_save = QShortcut(QKeySequence("Ctrl+S"), self)
+ self.shortcut_save.activated.connect(self.save_work)
+ self.shortcut_help = QShortcut(QKeySequence("Ctrl+?"), self)
+ self.shortcut_help.activated.connect(self.display_faq_page)
+
+ self.logger.info("Finished setting up GUI")
+ self.logger.info("For questions please refer to 'Ctrl+?', or visit the 'Help' section on the toolbar.")
+
+ def init_ui(self):
+ self.create_toolbar_view()
+ self.create_graphics_view()
+
+ def create_graphics_view(self):
+ self.scene = QGraphicsScene(self)
+ self.graphic_view = QGraphicsView(self.scene, self)
+ self.graphic_view.setRenderHint(QPainter.Antialiasing)
+ self.graphic_view.setGeometry(self.ui.operation_box.width(), 20, self.width(), self.height())
+ self.graphic_view.setDragMode(QGraphicsView.RubberBandDrag)
+
+ def create_toolbar_view(self):
+ self.toolbar = self.addToolBar("Toolbar")
+ self.toolbar.addAction("Create SFG", self.create_SFG_from_toolbar)
+ self.toolbar.addAction("Clear Workspace", self.clear_workspace)
+
+ def resizeEvent(self, event):
+ self.ui.operation_box.setGeometry(10, 10, self.ui.operation_box.width(), self.height())
+ self.graphic_view.setGeometry(self.ui.operation_box.width() + 20, 30, self.width() - self.ui.operation_box.width() - 20, self.height()-30)
+ super(MainWindow, self).resizeEvent(event)
+
+ def wheelEvent(self, event):
+ if event.modifiers() == Qt.ControlModifier:
+ old_zoom = self.zoom
+ self.zoom += event.angleDelta().y()/2500
+ self.graphic_view.scale(self.zoom, self.zoom)
+ self.zoom = old_zoom
+
+ def view_operation_names(self):
+ if self.check_show_names.isChecked():
+ self.is_show_names = True
+ else:
+ self.is_show_names = False
+
+ for operation in self.dragOperationSceneDict.keys():
+ operation.label.setOpacity(self.is_show_names)
+ operation.is_show_name = self.is_show_names
+
+ def _save_work(self):
+ sfg = self.sfg_widget.sfg
+ file_dialog = QFileDialog()
+ file_dialog.setDefaultSuffix(".py")
+ module, accepted = file_dialog.getSaveFileName()
+ if not accepted:
+ return
+
+ self.logger.info(f"Saving sfg to path: {module}.")
+ operation_positions = dict()
+ for operation_drag, operation_scene in self.dragOperationSceneDict.items():
+ operation_positions[operation_drag.operation.graph_id] = (operation_scene.x(), operation_scene.y())
+
+ try:
+ with open(module, "w+") as file_obj:
+ file_obj.write(sfg_to_python(sfg, suffix=f"positions = {str(operation_positions)}"))
+ except Exception as e:
+ self.logger.error(f"Failed to save sfg to path: {module}, with error: {e}.")
+ return
+
+ self.logger.info(f"Saved sfg to path: {module}.")
+
+ def save_work(self):
+ self.sfg_widget = SelectSFGWindow(self)
+ self.sfg_widget.show()
+
+ # Wait for input to dialog.
+ self.sfg_widget.ok.connect(self._save_work)
+
+ def load_work(self):
+ module, accepted = QFileDialog().getOpenFileName()
+ if not accepted:
+ return
+
+ self.logger.info(f"Loading sfg from path: {module}.")
+ try:
+ sfg, positions = python_to_sfg(module)
+ except ImportError as e:
+ self.logger.error(f"Failed to load module: {module} with the following error: {e}.")
+ return
+
+ while sfg.name in self.sfg_dict:
+ self.logger.warning(f"Duplicate sfg with name: {sfg.name} detected. Please choose a new name.")
+ name, accepted = QInputDialog.getText(self, "Change SFG Name", "Name: ", QLineEdit.Normal)
+ if not accepted:
+ return
+
+ sfg.name = name
+
+ for op in sfg.split():
+ self.create_operation(op, positions[op.graph_id] if op.graph_id in positions else None)
+
+ def connect_ports(ports):
+ for port in ports:
+ for signal in port.signals:
+ source = [source for source in self.portDict[self.operationDragDict[signal.source.operation]] if source.port is signal.source]
+ destination = [destination for destination in self.portDict[self.operationDragDict[signal.destination.operation]] if destination.port is signal.destination]
+
+ if source and destination:
+ self.connect_button(source[0], destination[0])
+
+ for port in self.pressed_ports:
+ port.select_port()
+
+ for op in sfg.split():
+ connect_ports(op.inputs)
+
+ for op in sfg.split():
+ self.operationDragDict[op].setToolTip(sfg.name)
+
+ self.sfg_dict[sfg.name] = sfg
+ self.logger.info(f"Loaded sfg from path: {module}.")
+ self.update()
+
+ def exit_app(self):
+ self.logger.info("Exiting the application.")
+ QApplication.quit()
+
+ def clear_workspace(self):
+ self.logger.info("Clearing workspace from operations and sfgs.")
+ self.pressed_operations.clear()
+ self.pressed_ports.clear()
+ self.operationItemSceneList.clear()
+ self.operationDragDict.clear()
+ self.dragOperationSceneDict.clear()
+ self.signalList.clear()
+ self.portDict.clear()
+ self.signalPortDict.clear()
+ self.sfg_dict.clear()
+ self.scene.clear()
+ self.logger.info("Workspace cleared.")
+
+ def create_SFG_from_toolbar(self):
+ inputs = []
+ outputs = []
+ for op in self.pressed_operations:
+ if isinstance(op.operation, Input):
+ inputs.append(op.operation)
+ elif isinstance(op.operation, Output):
+ outputs.append(op.operation)
+
+ name, accepted = QInputDialog.getText(self, "Create SFG", "Name: ", QLineEdit.Normal)
+ if not accepted:
+ return
+
+ if name == "":
+ self.logger.warning(f"Failed to initialize SFG with empty name.")
+ return
+
+ self.logger.info(f"Creating SFG with name: {name} from selected operations.")
+
+ sfg = SFG(inputs=inputs, outputs=outputs, name=name)
+ self.logger.info(f"Created SFG with name: {name} from selected operations.")
+
+ sfg_operations = sfg.operations.copy()
+ for op in self.pressed_operations:
+ operation = [op_ for op_ in sfg_operations if op_.type_name() == op.operation.type_name()][0]
+ op.operation = operation
+ sfg_operations.remove(operation)
+
+ for op in self.pressed_operations:
+ op.setToolTip(sfg.name)
+ self.opToSFG[op] = sfg
+
+ self.sfg_dict[sfg.name] = sfg
+
+ def show_precedence_chart(self):
+ self.dialog = ShowPCWindow(self)
+ self.dialog.add_sfg_to_dialog()
+ self.dialog.show()
+
+ def _determine_port_distance(self, length, ports):
+ """Determine the distance between each port on the side of an operation.
+ The method returns the distance that each port should have from 0.
+ """
+ return [length / 2] if ports == 1 else linspace(0, length, ports)
+
+ def add_ports(self, operation):
+ _output_ports_dist = self._determine_port_distance(55 - 17, operation.operation.output_count)
+ _input_ports_dist = self._determine_port_distance(55 - 17, operation.operation.input_count)
+ self.portDict[operation] = list()
+
+ for i, dist in enumerate(_input_ports_dist):
+ port = PortButton(">", operation, operation.operation.input(i), self)
+ self.portDict[operation].append(port)
+ operation.ports.append(port)
+ port.move(0, dist)
+ port.show()
+
+ for i, dist in enumerate(_output_ports_dist):
+ port = PortButton(">", operation, operation.operation.output(i), self)
+ self.portDict[operation].append(port)
+ operation.ports.append(port)
+ port.move(55 - 12, dist)
+ port.show()
+
+ def get_operations_from_namespace(self, namespace):
+ self.logger.info(f"Fetching operations from namespace: {namespace.__name__}.")
+ return [comp for comp in dir(namespace) if hasattr(getattr(namespace, comp), "type_name")]
+
+ def add_operations_from_namespace(self, namespace, _list):
+ for attr_name in self.get_operations_from_namespace(namespace):
+ attr = getattr(namespace, attr_name)
+ try:
+ attr.type_name()
+ item = QListWidgetItem(attr_name)
+ _list.addItem(item)
+ self._operations_from_name[attr_name] = attr
+ except NotImplementedError:
+ pass
+
+ self.logger.info(f"Added operations from namespace: {namespace.__name__}.")
+
+ def add_namespace(self):
+ module, accepted = QFileDialog().getOpenFileName()
+ if not accepted:
+ return
+
+ spec = importlib.util.spec_from_file_location(f"{QFileInfo(module).fileName()}", module)
+ namespace = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(namespace)
+
+ self.add_operations_from_namespace(namespace, self.ui.custom_operations_list)
+
+ def create_operation(self, op, position=None):
+ self.logger.info(f"Creating operation of type: {op.type_name()}.")
+ try:
+ attr_button = DragButton(op.graph_id, op, op.type_name().lower(), True, window = self)
+ if position is None:
+ attr_button.move(250, 100)
+ else:
+ attr_button.move(*position)
+
+ attr_button.setFixedSize(55, 55)
+ attr_button.setStyleSheet("background-color: white; border-style: solid;\
+ border-color: black; border-width: 2px")
+ self.add_ports(attr_button)
+
+ icon_path = path.join("operation_icons", f"{op.type_name().lower()}.png")
+ if not path.exists(icon_path):
+ icon_path = path.join("operation_icons", f"custom_operation.png")
+ attr_button.setIcon(QIcon(icon_path))
+ attr_button.setIconSize(QSize(55, 55))
+ attr_button.setToolTip("No sfg")
+ attr_button.setStyleSheet(""" QToolTip { background-color: white;
+ color: black }""")
+ attr_button.setParent(None)
+ attr_button_scene = self.scene.addWidget(attr_button)
+ if position is None:
+ attr_button_scene.moveBy(self.move_button_index * 100, 0)
+ attr_button_scene.setFlag(attr_button_scene.ItemIsSelectable, True)
+ self.move_button_index += 1
+ operation_label = QGraphicsTextItem(op.type_name(), attr_button_scene)
+ if not self.is_show_names:
+ operation_label.setOpacity(0)
+ operation_label.setTransformOriginPoint(operation_label.boundingRect().center())
+ operation_label.moveBy(10, -20)
+ attr_button.add_label(operation_label)
+ self.operationDragDict[op] = attr_button
+ self.dragOperationSceneDict[attr_button] = attr_button_scene
+ except Exception as e:
+ self.logger.error(f"Unexpected error occured while creating operation: {e}.")
+
+ def _create_operation_item(self, item):
+ self.logger.info(f"Creating operation of type: {item.text()}.")
+ try:
+ attr_oper = self._operations_from_name[item.text()]()
+ self.create_operation(attr_oper)
+ except Exception as e:
+ self.logger.error(f"Unexpected error occured while creating operation: {e}.")
+
+ def _refresh_operations_list_from_namespace(self):
+ self.logger.info("Refreshing operation list.")
+ self.ui.core_operations_list.clear()
+ self.ui.special_operations_list.clear()
+
+ self.add_operations_from_namespace(c_oper, self.ui.core_operations_list)
+ self.add_operations_from_namespace(s_oper, self.ui.special_operations_list)
+ self.logger.info("Finished refreshing operation list.")
+
+ def on_list_widget_item_clicked(self, item):
+ self._create_operation_item(item)
+
+ def keyPressEvent(self, event):
+ if event.key() == Qt.Key_Delete:
+ for pressed_op in self.pressed_operations:
+ pressed_op.remove()
+ self.move_button_index -= 1
+ self.pressed_operations.clear()
+ super().keyPressEvent(event)
+
+ def _connect_button(self, event):
+ if len(self.pressed_ports) < 2:
+ self.logger.warning("Can't connect less than two ports. Please select more.")
+ return
+
+ for i in range(len(self.pressed_ports) - 1):
+ source = self.pressed_ports[i] if isinstance(self.pressed_ports[i].port, OutputPort) else self.pressed_ports[i + 1]
+ destination = self.pressed_ports[i + 1] if source is not self.pressed_ports[i + 1] else self.pressed_ports[i]
+ if source.port.operation is destination.port.operation:
+ continue
+
+ self.connect_button(source, destination)
+
+ for port in self.pressed_ports:
+ port.select_port()
+
+ def connect_button(self, source, destination):
+ signal_exists = any([signal.destination is destination.port for signal in source.port.signals])
+ self.logger.info(f"Connecting: {source.operation.operation.type_name()} -> {destination.operation.operation.type_name()}.")
+ line = Arrow(source, destination, self, create_signal=not signal_exists)
+ if line not in self.signalPortDict:
+ self.signalPortDict[line] = []
+
+ self.signalPortDict[line].append((source, destination))
+ self.scene.addItem(line)
+ self.signalList.append(line)
+
+ self.update()
+
+ def paintEvent(self, event):
+ for signal in self.signalPortDict.keys():
+ signal.moveLine()
+
+ def _select_operations(self):
+ selected = [button.widget() for button in self.scene.selectedItems()]
+ for button in selected:
+ button._toggle_button(pressed=False)
+
+ for button in self.pressed_operations:
+ if button not in selected:
+ button._toggle_button(pressed=True)
+
+ self.pressed_operations = selected
+
+ def _simulate_sfg(self):
+ for sfg, properties in self.dialog.properties.items():
+ self.logger.info(f"Simulating sfg with name: {sfg.name}.")
+ simulation = FastSimulation(sfg, input_providers=properties["input_values"])
+ l_result = simulation.run_for(properties["iteration_count"], save_results=properties["all_results"])
+
+ print(f"{'=' * 10} {sfg.name} {'=' * 10}")
+ pprint(simulation.results if properties["all_results"] else l_result)
+ print(f"{'=' * 10} /{sfg.name} {'=' * 10}")
+
+ if properties["show_plot"]:
+ self.logger.info(f"Opening plot for sfg with name: {sfg.name}.")
+ self.logger.info("To save the plot press 'Ctrl+S' when the plot is focused.")
+ self.plot = Plot(simulation, sfg, self)
+ self.plot.show()
+
+ def simulate_sfg(self):
+ self.dialog = SimulateSFGWindow(self)
+
+ for _, sfg in self.sfg_dict.items():
+ self.dialog.add_sfg_to_dialog(sfg)
+
+ self.dialog.show()
+
+ # Wait for input to dialog. Kinda buggy because of the separate window in the same thread.
+ self.dialog.simulate.connect(self._simulate_sfg)
+
+ def display_faq_page(self):
+ self.faq_page = FaqWindow(self)
+ self.faq_page.scroll_area.show()
+
+ def display_about_page(self):
+ self.about_page = AboutWindow(self)
+ self.about_page.show()
+
+ def display_keybinds_page(self):
+ self.keybinds_page = KeybindsWindow(self)
+ self.keybinds_page.show()
+
+
+if __name__ == "__main__":
+ app = QApplication(sys.argv)
+ window = MainWindow()
+ window.show()
+ sys.exit(app.exec_())
diff --git a/b_asic/GUI/operation_icons/abs.png b/b_asic/GUI/operation_icons/abs.png
new file mode 100644
index 0000000000000000000000000000000000000000..6573d4d96928d32a3a59641e877108ab60d38c19
Binary files /dev/null and b/b_asic/GUI/operation_icons/abs.png differ
diff --git a/b_asic/GUI/operation_icons/abs_grey.png b/b_asic/GUI/operation_icons/abs_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..4e16da3110d3497c7dab55b9cd9edf22aef4c097
Binary files /dev/null and b/b_asic/GUI/operation_icons/abs_grey.png differ
diff --git a/b_asic/GUI/operation_icons/add.png b/b_asic/GUI/operation_icons/add.png
new file mode 100644
index 0000000000000000000000000000000000000000..504e641e4642d9c03deeea9911927bbe714f053e
Binary files /dev/null and b/b_asic/GUI/operation_icons/add.png differ
diff --git a/b_asic/GUI/operation_icons/add_grey.png b/b_asic/GUI/operation_icons/add_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..a7620d2b56c8a5d06b2c04ff994eb334777008f4
Binary files /dev/null and b/b_asic/GUI/operation_icons/add_grey.png differ
diff --git a/b_asic/GUI/operation_icons/bfly.png b/b_asic/GUI/operation_icons/bfly.png
new file mode 100644
index 0000000000000000000000000000000000000000..9948a964d353e7325c696ae7f12e1ded09cdc13f
Binary files /dev/null and b/b_asic/GUI/operation_icons/bfly.png differ
diff --git a/b_asic/GUI/operation_icons/bfly_grey.png b/b_asic/GUI/operation_icons/bfly_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..cc282efe67637dda8b5e76b0f4c35015b19ddd93
Binary files /dev/null and b/b_asic/GUI/operation_icons/bfly_grey.png differ
diff --git a/b_asic/GUI/operation_icons/c.png b/b_asic/GUI/operation_icons/c.png
new file mode 100644
index 0000000000000000000000000000000000000000..0068adae8130f7b384f7fd70277fb8f87d9dbf94
Binary files /dev/null and b/b_asic/GUI/operation_icons/c.png differ
diff --git a/b_asic/GUI/operation_icons/c_grey.png b/b_asic/GUI/operation_icons/c_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..d7d3e585e21e70aa8b89b85008e5306184ccff8c
Binary files /dev/null and b/b_asic/GUI/operation_icons/c_grey.png differ
diff --git a/b_asic/GUI/operation_icons/cmul.png b/b_asic/GUI/operation_icons/cmul.png
new file mode 100644
index 0000000000000000000000000000000000000000..7e7ff82b3aa577886da6686f62df936e8aa3572e
Binary files /dev/null and b/b_asic/GUI/operation_icons/cmul.png differ
diff --git a/b_asic/GUI/operation_icons/cmul_grey.png b/b_asic/GUI/operation_icons/cmul_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..8fe92d2606b8bc1c2bce98ed45cccb6236e36476
Binary files /dev/null and b/b_asic/GUI/operation_icons/cmul_grey.png differ
diff --git a/b_asic/GUI/operation_icons/conj.png b/b_asic/GUI/operation_icons/conj.png
new file mode 100644
index 0000000000000000000000000000000000000000..c74c9de7f45c16b972ddc072e5e0203dcb902f1b
Binary files /dev/null and b/b_asic/GUI/operation_icons/conj.png differ
diff --git a/b_asic/GUI/operation_icons/conj_grey.png b/b_asic/GUI/operation_icons/conj_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..33f1e60e686cb711644a875341c34a12b8dfe4c9
Binary files /dev/null and b/b_asic/GUI/operation_icons/conj_grey.png differ
diff --git a/b_asic/GUI/operation_icons/custom_operation.png b/b_asic/GUI/operation_icons/custom_operation.png
new file mode 100644
index 0000000000000000000000000000000000000000..a598abaaf05934222c457fc8b141431ca04f91be
Binary files /dev/null and b/b_asic/GUI/operation_icons/custom_operation.png differ
diff --git a/b_asic/GUI/operation_icons/custom_operation_grey.png b/b_asic/GUI/operation_icons/custom_operation_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..a1d72e3b7f67fb78acccf8f5fb417be62cbc2b2a
Binary files /dev/null and b/b_asic/GUI/operation_icons/custom_operation_grey.png differ
diff --git a/b_asic/GUI/operation_icons/div.png b/b_asic/GUI/operation_icons/div.png
new file mode 100644
index 0000000000000000000000000000000000000000..d7bf8908ed0acae344dc04adf6a96ae8448bb9d4
Binary files /dev/null and b/b_asic/GUI/operation_icons/div.png differ
diff --git a/b_asic/GUI/operation_icons/div_grey.png b/b_asic/GUI/operation_icons/div_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..de3a82c369dde1b6a28ea93e5362e6eb8879fe68
Binary files /dev/null and b/b_asic/GUI/operation_icons/div_grey.png differ
diff --git a/b_asic/GUI/operation_icons/in.png b/b_asic/GUI/operation_icons/in.png
new file mode 100644
index 0000000000000000000000000000000000000000..ebfd1a23e5723496e69f02bebc959d68e3c2f986
Binary files /dev/null and b/b_asic/GUI/operation_icons/in.png differ
diff --git a/b_asic/GUI/operation_icons/in_grey.png b/b_asic/GUI/operation_icons/in_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..07d3362f93039ca65966bc04d0ea481840072559
Binary files /dev/null and b/b_asic/GUI/operation_icons/in_grey.png differ
diff --git a/b_asic/GUI/operation_icons/max.png b/b_asic/GUI/operation_icons/max.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f759155f632e090a5dea49644f8dbc5dff7b4f4
Binary files /dev/null and b/b_asic/GUI/operation_icons/max.png differ
diff --git a/b_asic/GUI/operation_icons/max_grey.png b/b_asic/GUI/operation_icons/max_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..8179fb2e812cc617a012a1fb3d338e1c99e07aa7
Binary files /dev/null and b/b_asic/GUI/operation_icons/max_grey.png differ
diff --git a/b_asic/GUI/operation_icons/min.png b/b_asic/GUI/operation_icons/min.png
new file mode 100644
index 0000000000000000000000000000000000000000..5365002a74b91d91e40c95091ab8c052cfe3f3c5
Binary files /dev/null and b/b_asic/GUI/operation_icons/min.png differ
diff --git a/b_asic/GUI/operation_icons/min_grey.png b/b_asic/GUI/operation_icons/min_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..6978cd91288a9d5705903efb017e2dc3b42b1af1
Binary files /dev/null and b/b_asic/GUI/operation_icons/min_grey.png differ
diff --git a/b_asic/GUI/operation_icons/mul.png b/b_asic/GUI/operation_icons/mul.png
new file mode 100644
index 0000000000000000000000000000000000000000..2042dd16781e64ea97ed5323b79f4f310f760009
Binary files /dev/null and b/b_asic/GUI/operation_icons/mul.png differ
diff --git a/b_asic/GUI/operation_icons/mul_grey.png b/b_asic/GUI/operation_icons/mul_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..00e2304b634e02810d6a17aa2850c9afe4922eb9
Binary files /dev/null and b/b_asic/GUI/operation_icons/mul_grey.png differ
diff --git a/b_asic/GUI/operation_icons/out.png b/b_asic/GUI/operation_icons/out.png
new file mode 100644
index 0000000000000000000000000000000000000000..e7da51bbe3640b03b9f7d89f9dd90543c3022273
Binary files /dev/null and b/b_asic/GUI/operation_icons/out.png differ
diff --git a/b_asic/GUI/operation_icons/out_grey.png b/b_asic/GUI/operation_icons/out_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..2cde317beecf019db5c4eac2a35baa8ef8e99f5e
Binary files /dev/null and b/b_asic/GUI/operation_icons/out_grey.png differ
diff --git a/b_asic/GUI/operation_icons/reg.png b/b_asic/GUI/operation_icons/reg.png
new file mode 100644
index 0000000000000000000000000000000000000000..f294072fc6d3b3567d8252aee881d035aa4913eb
Binary files /dev/null and b/b_asic/GUI/operation_icons/reg.png differ
diff --git a/b_asic/GUI/operation_icons/reg_grey.png b/b_asic/GUI/operation_icons/reg_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..88af5760169b161fdd7aa5dce7c61cdb13b69231
Binary files /dev/null and b/b_asic/GUI/operation_icons/reg_grey.png differ
diff --git a/b_asic/GUI/operation_icons/sqrt.png b/b_asic/GUI/operation_icons/sqrt.png
new file mode 100644
index 0000000000000000000000000000000000000000..8160862b675680bb5fc2f31a0a5f870b73352bbb
Binary files /dev/null and b/b_asic/GUI/operation_icons/sqrt.png differ
diff --git a/b_asic/GUI/operation_icons/sqrt_grey.png b/b_asic/GUI/operation_icons/sqrt_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..4353217de9c38d665f1364a7f7c501c444232abc
Binary files /dev/null and b/b_asic/GUI/operation_icons/sqrt_grey.png differ
diff --git a/b_asic/GUI/operation_icons/sub.png b/b_asic/GUI/operation_icons/sub.png
new file mode 100644
index 0000000000000000000000000000000000000000..73db57daf9984fd1c1eb0775a1e0535b786396a8
Binary files /dev/null and b/b_asic/GUI/operation_icons/sub.png differ
diff --git a/b_asic/GUI/operation_icons/sub_grey.png b/b_asic/GUI/operation_icons/sub_grey.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b32557a56f08e27adcd028f080d517f6ce5bdf2
Binary files /dev/null and b/b_asic/GUI/operation_icons/sub_grey.png differ
diff --git a/b_asic/GUI/port_button.py b/b_asic/GUI/port_button.py
new file mode 100644
index 0000000000000000000000000000000000000000..06e1ee455a8ab0b7ad7552e18bf0bec6733a83aa
--- /dev/null
+++ b/b_asic/GUI/port_button.py
@@ -0,0 +1,58 @@
+
+import sys
+
+from PySide2.QtWidgets import QPushButton, QMenu
+from PySide2.QtCore import Qt, Signal
+
+class PortButton(QPushButton):
+ connectionRequested = Signal(QPushButton)
+ moved = Signal()
+ def __init__(self, name, operation, port, window, parent=None):
+ super(PortButton, self).__init__(name, operation, parent)
+ self.pressed = False
+ self._window = window
+ self.port = port
+ self.operation = operation
+ self.clicked = 0
+ self._m_drag = False
+ self._m_press = False
+
+ self.setStyleSheet("background-color: white")
+ self.connectionRequested.connect(self._window._connect_button)
+
+ def contextMenuEvent(self, event):
+ menu = QMenu()
+ menu.addAction("Connect", lambda: self.connectionRequested.emit(self))
+ menu.exec_(self.cursor().pos())
+
+ def mousePressEvent(self, event):
+ if event.button() == Qt.LeftButton:
+ self.select_port(event.modifiers())
+
+ super(PortButton, self).mousePressEvent(event)
+
+ def mouseReleaseEvent(self, event):
+ super(PortButton, self).mouseReleaseEvent(event)
+
+ def _toggle_port(self, pressed=False):
+ self.pressed = not pressed
+ self.setStyleSheet(f"background-color: {'white' if not self.pressed else 'grey'}")
+
+ def select_port(self, modifiers=None):
+ if modifiers != Qt.ControlModifier:
+ for port in self._window.pressed_ports:
+ port._toggle_port(port.pressed)
+
+ self._toggle_port(self.pressed)
+ self._window.pressed_ports = [self]
+
+ else:
+ self._toggle_port(self.pressed)
+ if self in self._window.pressed_ports:
+ self._window.pressed_ports.remove(self)
+ else:
+ self._window.pressed_ports.append(self)
+
+ for signal in self._window.signalList:
+ signal.update()
+
diff --git a/b_asic/GUI/properties_window.py b/b_asic/GUI/properties_window.py
new file mode 100644
index 0000000000000000000000000000000000000000..04d899fd317dfbaa6a5b65934edd62a9fc479b68
--- /dev/null
+++ b/b_asic/GUI/properties_window.py
@@ -0,0 +1,137 @@
+from PySide2.QtWidgets import QDialog, QLineEdit, QPushButton, QVBoxLayout, QHBoxLayout,\
+QLabel, QCheckBox, QGridLayout
+from PySide2.QtCore import Qt
+from PySide2.QtGui import QIntValidator
+
+class PropertiesWindow(QDialog):
+ def __init__(self, operation, main_window):
+ super(PropertiesWindow, self).__init__()
+ self.operation = operation
+ self._window = main_window
+ self.setWindowFlags(Qt.WindowTitleHint | Qt.WindowCloseButtonHint)
+ self.setWindowTitle("Properties")
+
+ self.name_layout = QHBoxLayout()
+ self.name_layout.setSpacing(50)
+ self.name_label = QLabel("Name:")
+ self.edit_name = QLineEdit(self.operation.operation_path_name)
+ self.name_layout.addWidget(self.name_label)
+ self.name_layout.addWidget(self.edit_name)
+ self.latency_fields = dict()
+
+ self.vertical_layout = QVBoxLayout()
+ self.vertical_layout.addLayout(self.name_layout)
+
+ if self.operation.operation_path_name == "c":
+ self.constant_layout = QHBoxLayout()
+ self.constant_layout.setSpacing(50)
+ self.constant_value = QLabel("Constant:")
+ self.edit_constant = QLineEdit(str(self.operation.operation.value))
+ self.only_accept_int = QIntValidator()
+ self.edit_constant.setValidator(self.only_accept_int)
+ self.constant_layout.addWidget(self.constant_value)
+ self.constant_layout.addWidget(self.edit_constant)
+ self.vertical_layout.addLayout(self.constant_layout)
+
+ self.show_name_layout = QHBoxLayout()
+ self.check_show_name = QCheckBox("Show name?")
+ if self.operation.is_show_name:
+ self.check_show_name.setChecked(1)
+ else:
+ self.check_show_name.setChecked(0)
+ self.check_show_name.setLayoutDirection(Qt.RightToLeft)
+ self.check_show_name.setStyleSheet("spacing: 170px")
+ self.show_name_layout.addWidget(self.check_show_name)
+ self.vertical_layout.addLayout(self.show_name_layout)
+
+ if self.operation.operation.input_count > 0:
+ self.latency_layout = QHBoxLayout()
+ self.latency_label = QLabel("Set Latency For Input Ports (-1 for None):")
+ self.latency_layout.addWidget(self.latency_label)
+ self.vertical_layout.addLayout(self.latency_layout)
+
+ input_grid = QGridLayout()
+ x, y = 0, 0
+ for i in range(self.operation.operation.input_count):
+ input_layout = QHBoxLayout()
+ input_layout.addStretch()
+ if i % 2 == 0 and i > 0:
+ x += 1
+ y = 0
+
+ input_label = QLabel("in" + str(i))
+ input_layout.addWidget(input_label)
+ input_value = QLineEdit()
+ try:
+ input_value.setPlaceholderText(str(self.operation.operation.latency))
+ except ValueError:
+ input_value.setPlaceholderText("-1")
+ int_valid = QIntValidator()
+ int_valid.setBottom(-1)
+ input_value.setValidator(int_valid)
+ input_value.setFixedWidth(50)
+ self.latency_fields["in" + str(i)] = input_value
+ input_layout.addWidget(input_value)
+ input_layout.addStretch()
+ input_layout.setSpacing(10)
+ input_grid.addLayout(input_layout, x, y)
+ y += 1
+
+ self.vertical_layout.addLayout(input_grid)
+
+ if self.operation.operation.output_count > 0:
+ self.latency_layout = QHBoxLayout()
+ self.latency_label = QLabel("Set Latency For Output Ports (-1 for None):")
+ self.latency_layout.addWidget(self.latency_label)
+ self.vertical_layout.addLayout(self.latency_layout)
+
+ input_grid = QGridLayout()
+ x, y = 0, 0
+ for i in range(self.operation.operation.output_count):
+ input_layout = QHBoxLayout()
+ input_layout.addStretch()
+ if i % 2 == 0 and i > 0:
+ x += 1
+ y = 0
+
+ input_label = QLabel("out" + str(i))
+ input_layout.addWidget(input_label)
+ input_value = QLineEdit()
+ try:
+ input_value.setPlaceholderText(str(self.operation.operation.latency))
+ except ValueError:
+ input_value.setPlaceholderText("-1")
+ int_valid = QIntValidator()
+ int_valid.setBottom(-1)
+ input_value.setValidator(int_valid)
+ input_value.setFixedWidth(50)
+ self.latency_fields["out" + str(i)] = input_value
+ input_layout.addWidget(input_value)
+ input_layout.addStretch()
+ input_layout.setSpacing(10)
+ input_grid.addLayout(input_layout, x, y)
+ y += 1
+
+ self.vertical_layout.addLayout(input_grid)
+
+ self.ok = QPushButton("OK")
+ self.ok.clicked.connect(self.save_properties)
+ self.vertical_layout.addWidget(self.ok)
+ self.setLayout(self.vertical_layout)
+
+ def save_properties(self):
+ self._window.logger.info(f"Saving properties of operation: {self.operation.name}.")
+ self.operation.name = self.edit_name.text()
+ self.operation.label.setPlainText(self.operation.name)
+ if self.operation.operation_path_name == "c":
+ self.operation.operation.value = int(self.edit_constant.text())
+ if self.check_show_name.isChecked():
+ self.operation.label.setOpacity(1)
+ self.operation.is_show_name = True
+ else:
+ self.operation.label.setOpacity(0)
+ self.operation.is_show_name = False
+
+ self.operation.operation.set_latency_offsets({port: int(self.latency_fields[port].text()) if self.latency_fields[port].text() and int(self.latency_fields[port].text()) > 0 else None for port in self.latency_fields})
+
+ self.reject()
\ No newline at end of file
diff --git a/b_asic/GUI/select_sfg_window.py b/b_asic/GUI/select_sfg_window.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b70c2c27f066f8ab28808673d347eec717f1e5c
--- /dev/null
+++ b/b_asic/GUI/select_sfg_window.py
@@ -0,0 +1,39 @@
+from PySide2.QtWidgets import QDialog, QLineEdit, QPushButton, QVBoxLayout, QHBoxLayout,\
+QLabel, QCheckBox, QSpinBox, QGroupBox, QFrame, QFormLayout, QGridLayout, QSizePolicy, QFileDialog, QShortcut, QComboBox
+from PySide2.QtCore import Qt, Signal
+from PySide2.QtGui import QIntValidator, QKeySequence
+
+from matplotlib.backends import qt_compat
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+
+
+class SelectSFGWindow(QDialog):
+ ok = Signal()
+
+ def __init__(self, window):
+ super(SelectSFGWindow, self).__init__()
+ self._window = window
+ self.setWindowFlags(Qt.WindowTitleHint | Qt.WindowCloseButtonHint)
+ self.setWindowTitle("Select SFG")
+
+ self.dialog_layout = QVBoxLayout()
+ self.ok_btn = QPushButton("Ok")
+ self.ok_btn.clicked.connect(self.save_properties)
+ self.dialog_layout.addWidget(self.ok_btn)
+ self.combo_box = QComboBox()
+
+ self.sfg = None
+ self.setLayout(self.dialog_layout)
+ self.add_sfgs_to_layout()
+
+ def add_sfgs_to_layout(self):
+ for sfg in self._window.sfg_dict:
+ self.combo_box.addItem(sfg)
+
+ self.dialog_layout.addWidget(self.combo_box)
+
+ def save_properties(self):
+ self.sfg = self._window.sfg_dict[self.combo_box.currentText()]
+ self.accept()
+ self.ok.emit()
diff --git a/b_asic/GUI/show_pc_window.py b/b_asic/GUI/show_pc_window.py
new file mode 100644
index 0000000000000000000000000000000000000000..5952ca991c70a4a466183900adab6f0fb39610a1
--- /dev/null
+++ b/b_asic/GUI/show_pc_window.py
@@ -0,0 +1,48 @@
+from PySide2.QtWidgets import QDialog, QPushButton, QVBoxLayout, QCheckBox,\
+QFrame, QFormLayout
+from PySide2.QtCore import Qt, Signal
+
+from b_asic import SFG
+
+class ShowPCWindow(QDialog):
+ pc = Signal()
+
+ def __init__(self, window):
+ super(ShowPCWindow, self).__init__()
+ self._window = window
+ self.check_box_dict = dict()
+ self.setWindowFlags(Qt.WindowTitleHint | Qt.WindowCloseButtonHint)
+ self.setWindowTitle("Show PC")
+
+ self.dialog_layout = QVBoxLayout()
+ self.pc_btn = QPushButton("Show PC")
+ self.pc_btn.clicked.connect(self.show_precedence_graph)
+ self.dialog_layout.addWidget(self.pc_btn)
+ self.setLayout(self.dialog_layout)
+
+ def add_sfg_to_dialog(self):
+ self.sfg_layout = QVBoxLayout()
+ self.options_layout = QFormLayout()
+
+ for sfg in self._window.sfg_dict:
+ check_box = QCheckBox()
+ self.options_layout.addRow(sfg, check_box)
+ self.check_box_dict[check_box] = sfg
+
+ self.sfg_layout.addLayout(self.options_layout)
+
+ frame = QFrame()
+ frame.setFrameShape(QFrame.HLine)
+ frame.setFrameShadow(QFrame.Sunken)
+ self.dialog_layout.addWidget(frame)
+
+ self.dialog_layout.addLayout(self.sfg_layout)
+
+ def show_precedence_graph(self):
+ for check_box, sfg in self.check_box_dict.items():
+ if check_box.isChecked():
+ self._window.logger.info(f"Creating a precedence chart from sfg with name: {sfg}.")
+ self._window.sfg_dict[sfg].show_precedence_graph()
+
+ self.accept()
+ self.pc.emit()
\ No newline at end of file
diff --git a/b_asic/GUI/simulate_sfg_window.py b/b_asic/GUI/simulate_sfg_window.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e60e3dbeb1f8036e55e0992eb65feb985aa6c31
--- /dev/null
+++ b/b_asic/GUI/simulate_sfg_window.py
@@ -0,0 +1,148 @@
+from PySide2.QtWidgets import QDialog, QLineEdit, QPushButton, QVBoxLayout, QHBoxLayout,\
+QLabel, QCheckBox, QSpinBox, QGroupBox, QFrame, QFormLayout, QGridLayout, QSizePolicy, QFileDialog, QShortcut
+from PySide2.QtCore import Qt, Signal
+from PySide2.QtGui import QIntValidator, QKeySequence
+
+from matplotlib.backends import qt_compat
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+
+
+class SimulateSFGWindow(QDialog):
+ simulate = Signal()
+
+ def __init__(self, window):
+ super(SimulateSFGWindow, self).__init__()
+ self._window = window
+ self.properties = dict()
+ self.sfg_to_layout = dict()
+ self.input_fields = dict()
+ self.setWindowFlags(Qt.WindowTitleHint | Qt.WindowCloseButtonHint)
+ self.setWindowTitle("Simulate SFG")
+
+ self.dialog_layout = QVBoxLayout()
+ self.simulate_btn = QPushButton("Simulate")
+ self.simulate_btn.clicked.connect(self.save_properties)
+ self.dialog_layout.addWidget(self.simulate_btn)
+ self.setLayout(self.dialog_layout)
+
+ def add_sfg_to_dialog(self, sfg):
+ sfg_layout = QVBoxLayout()
+ options_layout = QFormLayout()
+
+ name_label = QLabel(f"{sfg.name}")
+ sfg_layout.addWidget(name_label)
+
+ spin_box = QSpinBox()
+ spin_box.setRange(0, 2147483647)
+ options_layout.addRow("Iteration Count: ", spin_box)
+
+ check_box_plot = QCheckBox()
+ options_layout.addRow("Plot Results: ", check_box_plot)
+
+ check_box_all = QCheckBox()
+ options_layout.addRow("Get All Results: ", check_box_all)
+
+ sfg_layout.addLayout(options_layout)
+
+ self.input_fields[sfg] = {
+ "iteration_count": spin_box,
+ "show_plot": check_box_plot,
+ "all_results": check_box_all,
+ "input_values": []
+ }
+
+ if sfg.input_count > 0:
+ input_label = QHBoxLayout()
+ input_label = QLabel("Input Values:")
+ options_layout.addRow(input_label)
+
+ input_grid = QGridLayout()
+ x, y = 0, 0
+ for i in range(sfg.input_count):
+ input_layout = QHBoxLayout()
+ input_layout.addStretch()
+ if i % 2 == 0 and i > 0:
+ x += 1
+ y = 0
+
+ input_label = QLabel("in" + str(i))
+ input_layout.addWidget(input_label)
+ input_value = QLineEdit()
+ input_value.setPlaceholderText("0")
+ input_value.setValidator(QIntValidator())
+ input_value.setFixedWidth(50)
+ input_layout.addWidget(input_value)
+ input_layout.addStretch()
+ input_layout.setSpacing(10)
+ input_grid.addLayout(input_layout, x, y)
+
+ self.input_fields[sfg]["input_values"].append(input_value)
+ y += 1
+
+ sfg_layout.addLayout(input_grid)
+
+ frame = QFrame()
+ frame.setFrameShape(QFrame.HLine)
+ frame.setFrameShadow(QFrame.Sunken)
+ self.dialog_layout.addWidget(frame)
+
+ self.sfg_to_layout[sfg] = sfg_layout
+ self.dialog_layout.addLayout(sfg_layout)
+
+ def save_properties(self):
+ for sfg, properties in self.input_fields.items():
+
+ self.properties[sfg] = {
+ "iteration_count": self.input_fields[sfg]["iteration_count"].value(),
+ "show_plot": self.input_fields[sfg]["show_plot"].isChecked(),
+ "all_results": self.input_fields[sfg]["all_results"].isChecked(),
+ "input_values": [int(widget.text()) if widget.text() else 0 for widget in self.input_fields[sfg]["input_values"]]
+ }
+
+ # If we plot we should also print the entire data, since you can't really interact with the graph.
+ if self.properties[sfg]["show_plot"]:
+ self.properties[sfg]["all_results"] = True
+
+ self.accept()
+ self.simulate.emit()
+
+
+class Plot(FigureCanvas):
+ def __init__(self, simulation, sfg, window, parent=None, width=5, height=4, dpi=100):
+ self.simulation = simulation
+ self.sfg = sfg
+ self.dpi = dpi
+ self._window = window
+
+ fig = Figure(figsize=(width, height), dpi=dpi)
+ fig.suptitle(sfg.name, fontsize=20)
+ self.axes = fig.add_subplot(111)
+
+ FigureCanvas.__init__(self, fig)
+ self.setParent(parent)
+
+ FigureCanvas.setSizePolicy(self, QSizePolicy.Expanding, QSizePolicy.Expanding)
+ FigureCanvas.updateGeometry(self)
+ self.save_figure = QShortcut(QKeySequence("Ctrl+S"), self)
+ self.save_figure.activated.connect(self._save_plot_figure)
+ self._plot_values_sfg()
+
+ def _save_plot_figure(self):
+ self._window.logger.info(f"Saving plot of figure: {self.sfg.name}.")
+ file_choices = "PNG (*.png)|*.png"
+ path, ext = QFileDialog.getSaveFileName(self, "Save file", "", file_choices)
+ path = path.encode("utf-8")
+ if not path[-4:] == file_choices[-4:].encode("utf-8"):
+ path += file_choices[-4:].encode("utf-8")
+
+ if path:
+ self.print_figure(path.decode(), dpi=self.dpi)
+ self._window.logger.info(f"Saved plot: {self.sfg.name} to path: {path}.")
+
+ def _plot_values_sfg(self):
+ x_axis = list(range(len(self.simulation.results["0"])))
+ for _output in range(self.sfg.output_count):
+ y_axis = self.simulation.results[str(_output)]
+
+ self.axes.plot(x_axis, y_axis)
diff --git a/b_asic/GUI/utils.py b/b_asic/GUI/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..5234c6548bbbc66eb224fb9d3d3835d67a099213
--- /dev/null
+++ b/b_asic/GUI/utils.py
@@ -0,0 +1,20 @@
+from PySide2.QtWidgets import QErrorMessage
+from traceback import format_exc
+
+def handle_error(fn):
+ def wrapper(self, *args, **kwargs):
+ try:
+ return fn(self, *args, **kwargs)
+ except Exception as e:
+ self._window.logger.error(f"Unexpected error: {format_exc()}")
+ QErrorMessage(self._window).showMessage(f"Unexpected error: {format_exc()}")
+
+ return wrapper
+
+def decorate_class(decorator):
+ def decorate(cls):
+ for attr in cls.__dict__:
+ if callable(getattr(cls, attr)):
+ setattr(cls, attr, decorator(getattr(cls, attr)))
+ return cls
+ return decorate
\ No newline at end of file
diff --git a/b_asic/__init__.py b/b_asic/__init__.py
index bd3574ba07b2556fae03ff8fa22deecfd2656705..9405cbcb3d106a344d160d40108bc41fff1537d9 100644
--- a/b_asic/__init__.py
+++ b/b_asic/__init__.py
@@ -2,13 +2,14 @@
Better ASIC Toolbox.
TODO: More info.
"""
+from _b_asic import *
from b_asic.core_operations import *
from b_asic.graph_component import *
from b_asic.operation import *
-from b_asic.precedence_chart import *
from b_asic.port import *
-from b_asic.schema import *
from b_asic.signal_flow_graph import *
from b_asic.signal import *
from b_asic.simulation import *
from b_asic.special_operations import *
+from b_asic.save_load_structure import *
+from b_asic.schema import *
diff --git a/b_asic/core_operations.py b/b_asic/core_operations.py
index 296803e3e55b7b92d85f52b91b30533ecdfbc0b6..9a11d91943e9621e43daa3c88ddfa67d3441060c 100644
--- a/b_asic/core_operations.py
+++ b/b_asic/core_operations.py
@@ -4,7 +4,7 @@ TODO: More info.
"""
from numbers import Number
-from typing import Optional
+from typing import Optional, Dict
from numpy import conjugate, sqrt, abs as np_abs
from b_asic.port import SignalSourceProvider, InputPort, OutputPort
@@ -18,16 +18,16 @@ class Constant(AbstractOperation):
"""
def __init__(self, value: Number = 0, name: Name = ""):
- super().__init__(input_count = 0, output_count = 1, name = name)
+ super().__init__(input_count=0, output_count=1, name=name)
self.set_param("value", value)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "c"
def evaluate(self):
return self.param("value")
-
+
@property
def value(self) -> Number:
"""Get the constant value of this operation."""
@@ -44,11 +44,12 @@ class Addition(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 2, output_count = 1, name = name, input_sources = [src0, src1])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=2, output_count=1, name=name, input_sources=[src0, src1],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "add"
def evaluate(self, a, b):
@@ -60,11 +61,12 @@ class Subtraction(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 2, output_count = 1, name = name, input_sources = [src0, src1])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=2, output_count=1, name=name, input_sources=[src0, src1],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "sub"
def evaluate(self, a, b):
@@ -76,11 +78,12 @@ class Multiplication(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 2, output_count = 1, name = name, input_sources = [src0, src1])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=2, output_count=1, name=name, input_sources=[src0, src1],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "mul"
def evaluate(self, a, b):
@@ -92,11 +95,12 @@ class Division(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 2, output_count = 1, name = name, input_sources = [src0, src1])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=2, output_count=1, name=name, input_sources=[src0, src1],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "div"
def evaluate(self, a, b):
@@ -108,11 +112,12 @@ class Min(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 2, output_count = 1, name = name, input_sources = [src0, src1])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=2, output_count=1, name=name, input_sources=[src0, src1],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "min"
def evaluate(self, a, b):
@@ -126,11 +131,12 @@ class Max(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 2, output_count = 1, name = name, input_sources = [src0, src1])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=2, output_count=1, name=name, input_sources=[src0, src1],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "max"
def evaluate(self, a, b):
@@ -144,11 +150,12 @@ class SquareRoot(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 1, output_count = 1, name = name, input_sources = [src0])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=1, output_count=1, name=name, input_sources=[src0],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "sqrt"
def evaluate(self, a):
@@ -160,11 +167,12 @@ class ComplexConjugate(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 1, output_count = 1, name = name, input_sources = [src0])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=1, output_count=1, name=name, input_sources=[src0],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "conj"
def evaluate(self, a):
@@ -176,11 +184,12 @@ class Absolute(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 1, output_count = 1, name = name, input_sources = [src0])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=1, output_count=1, name=name, input_sources=[src0],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "abs"
def evaluate(self, a):
@@ -192,12 +201,13 @@ class ConstantMultiplication(AbstractOperation):
TODO: More info.
"""
- def __init__(self, value: Number = 0, src0: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 1, output_count = 1, name = name, input_sources = [src0])
+ def __init__(self, value: Number = 0, src0: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=1, output_count=1, name=name, input_sources=[src0],
+ latency=latency, latency_offsets=latency_offsets)
self.set_param("value", value)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "cmul"
def evaluate(self, a):
@@ -220,12 +230,30 @@ class Butterfly(AbstractOperation):
TODO: More info.
"""
- def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 2, output_count = 2, name = name, input_sources = [src0, src1])
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=2, output_count=2, name=name, input_sources=[src0, src1],
+ latency=latency, latency_offsets=latency_offsets)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "bfly"
def evaluate(self, a, b):
return a + b, a - b
+
+
+class MAD(AbstractOperation):
+ """Multiply-and-add operation.
+ TODO: More info.
+ """
+
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, src1: Optional[SignalSourceProvider] = None, src2: Optional[SignalSourceProvider] = None, name: Name = "", latency: int = None, latency_offsets: Dict[str, int] = None):
+ super().__init__(input_count=3, output_count=1, name=name, input_sources=[src0, src1, src2],
+ latency=latency, latency_offsets=latency_offsets)
+
+ @classmethod
+ def type_name(cls) -> TypeName:
+ return "mad"
+
+ def evaluate(self, a, b, c):
+ return a * b + c
diff --git a/b_asic/graph_component.py b/b_asic/graph_component.py
index e37997016a3276f4dbde0394c44bf5c54ecbd51c..e08422a842a84d08dcab58ab03d7f581cb1bc664 100644
--- a/b_asic/graph_component.py
+++ b/b_asic/graph_component.py
@@ -20,9 +20,9 @@ class GraphComponent(ABC):
TODO: More info.
"""
- @property
+ @classmethod
@abstractmethod
- def type_name(self) -> TypeName:
+ def type_name(cls) -> TypeName:
"""Get the type name of this graph component"""
raise NotImplementedError
@@ -105,6 +105,10 @@ class AbstractGraphComponent(GraphComponent):
self._graph_id = ""
self._parameters = {}
+ def __str__(self):
+ return f"id: {self.graph_id if self.graph_id else 'no_id'}, \tname: {self.name if self.name else 'no_name'}" + \
+ "".join((f", \t{key}: {str(param)}" for key, param in self._parameters.items()))
+
@property
def name(self) -> Name:
return self._name
@@ -112,7 +116,7 @@ class AbstractGraphComponent(GraphComponent):
@name.setter
def name(self, name: Name) -> None:
self._name = name
-
+
@property
def graph_id(self) -> GraphID:
return self._graph_id
@@ -136,7 +140,7 @@ class AbstractGraphComponent(GraphComponent):
new_component.name = copy(self.name)
new_component.graph_id = copy(self.graph_id)
for name, value in self.params.items():
- new_component.set_param(copy(name), deepcopy(value)) # pylint: disable=no-member
+ new_component.set_param(copy(name), deepcopy(value)) # pylint: disable=no-member
return new_component
def traverse(self) -> Generator[GraphComponent, None, None]:
@@ -149,4 +153,4 @@ class AbstractGraphComponent(GraphComponent):
for neighbor in component.neighbors:
if neighbor not in visited:
visited.add(neighbor)
- fontier.append(neighbor)
\ No newline at end of file
+ fontier.append(neighbor)
diff --git a/b_asic/operation.py b/b_asic/operation.py
index a0d0f48a1f7429ce0d393ad4e93ef24c84914f7b..0778b5747fd8ad342bc076187293b65a0524741e 100644
--- a/b_asic/operation.py
+++ b/b_asic/operation.py
@@ -3,22 +3,23 @@ B-ASIC Operation Module.
TODO: More info.
"""
+from b_asic.signal import Signal
+from b_asic.port import SignalSourceProvider, InputPort, OutputPort
+from b_asic.graph_component import GraphComponent, AbstractGraphComponent, Name
+import itertools as it
+from math import trunc
import collections
from abc import abstractmethod
from numbers import Number
-from typing import NewType, List, Sequence, Iterable, Mapping, MutableMapping, Optional, Any, Set, Union
-from math import trunc
+from typing import NewType, List, Dict, Sequence, Iterable, Mapping, MutableMapping, Optional, Any, Set, Union
-from b_asic.graph_component import GraphComponent, AbstractGraphComponent, Name
-from b_asic.port import SignalSourceProvider, InputPort, OutputPort
-from b_asic.signal import Signal
ResultKey = NewType("ResultKey", str)
ResultMap = Mapping[ResultKey, Optional[Number]]
MutableResultMap = MutableMapping[ResultKey, Optional[Number]]
-RegisterMap = Mapping[ResultKey, Number]
-MutableRegisterMap = MutableMapping[ResultKey, Number]
+DelayMap = Mapping[ResultKey, Number]
+MutableDelayMap = MutableMapping[ResultKey, Number]
class Operation(GraphComponent, SignalSourceProvider):
"""Operation interface.
@@ -82,6 +83,14 @@ class Operation(GraphComponent, SignalSourceProvider):
object that is connected to the self and other objects.
"""
raise NotImplementedError
+
+ @abstractmethod
+ def __lshift__(self, src: SignalSourceProvider) -> Signal:
+ """Overloads the left shift operator to make it connect the provided signal source
+ to this operation's input, assuming it has exactly 1 input port.
+ Returns the new signal.
+ """
+ raise NotImplementedError
@property
@abstractmethod
@@ -135,39 +144,41 @@ class Operation(GraphComponent, SignalSourceProvider):
@abstractmethod
def key(self, index: int, prefix: str = "") -> ResultKey:
- """Get the key used to access the result of a certain output of this operation
- from the results parameter passed to current_output(s) or evaluate_output(s).
+ """Get the key used to access the output of a certain output of this operation
+ from the output parameter passed to current_output(s) or evaluate_output(s).
"""
raise NotImplementedError
@abstractmethod
- def current_output(self, index: int, registers: Optional[RegisterMap] = None, prefix: str = "") -> Optional[Number]:
+ def current_output(self, index: int, delays: Optional[DelayMap] = None, prefix: str = "") -> Optional[Number]:
"""Get the current output at the given index of this operation, if available.
- The registers parameter will be used for lookup.
- The prefix parameter will be used as a prefix for the key string when looking for registers.
+ The delays parameter will be used for lookup.
+ The prefix parameter will be used as a prefix for the key string when looking for delays.
See also: current_outputs, evaluate_output, evaluate_outputs.
"""
raise NotImplementedError
@abstractmethod
- def evaluate_output(self, index: int, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, registers: Optional[MutableRegisterMap] = None, prefix: str = "") -> Number:
+ def evaluate_output(self, index: int, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, delays: Optional[MutableDelayMap] = None, prefix: str = "", bits_override: Optional[int] = None, truncate: bool = True) -> Number:
"""Evaluate the output at the given index of this operation with the given input values.
The results parameter will be used to store any results (including intermediate results) for caching.
- The registers parameter will be used to get the current value of any intermediate registers that are encountered, and be updated with their new values.
- The prefix parameter will be used as a prefix for the key string when storing results/registers.
+ The delays parameter will be used to get the current value of any intermediate delays that are encountered, and be updated with their new values.
+ The prefix parameter will be used as a prefix for the key string when storing results/delays.
+ The bits_override parameter specifies a word length override when truncating inputs which ignores the word length specified by the input signal.
+ The truncate parameter specifies whether input truncation should be enabled in the first place. If set to False, input values will be used driectly without any bit truncation.
See also: evaluate_outputs, current_output, current_outputs.
"""
raise NotImplementedError
@abstractmethod
- def current_outputs(self, registers: Optional[RegisterMap] = None, prefix: str = "") -> Sequence[Optional[Number]]:
+ def current_outputs(self, delays: Optional[DelayMap] = None, prefix: str = "") -> Sequence[Optional[Number]]:
"""Get all current outputs of this operation, if available.
See current_output for more information.
"""
raise NotImplementedError
@abstractmethod
- def evaluate_outputs(self, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, registers: Optional[MutableRegisterMap] = None, prefix: str = "") -> Sequence[Number]:
+ def evaluate_outputs(self, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, delays: Optional[MutableDelayMap] = None, prefix: str = "", bits_override: Optional[int] = None, truncate: bool = True) -> Sequence[Number]:
"""Evaluate all outputs of this operation given the input values.
See evaluate_output for more information.
"""
@@ -180,6 +191,56 @@ class Operation(GraphComponent, SignalSourceProvider):
"""
raise NotImplementedError
+ @abstractmethod
+ def inputs_required_for_output(self, output_index: int) -> Iterable[int]:
+ """Get the input indices of all inputs in this operation whose values are required in order to evaluate the output at the given output index."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def truncate_input(self, index: int, value: Number, bits: int) -> Number:
+ """Truncate the value to be used as input at the given index to a certain bit length."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def to_sfg(self) -> "SFG":
+ """Convert the operation into its corresponding SFG.
+ If the operation is composed by multiple operations, the operation will be split.
+ """
+ raise NotImplementedError
+
+ @property
+ @abstractmethod
+ def latency(self) -> int:
+ """Get the latency of the operation, which is the longest time it takes from one of
+ the operations inputport to one of the operations outputport.
+ """
+ raise NotImplementedError
+
+ @property
+ @abstractmethod
+ def latency_offsets(self) -> Sequence[Sequence[int]]:
+ """Get a nested list with all the operations ports latency-offsets, the first list contains the
+ latency-offsets of the operations input ports, the second list contains the latency-offsets of
+ the operations output ports.
+ """
+ raise NotImplementedError
+
+ @abstractmethod
+ def set_latency(self, latency: int) -> None:
+ """Sets the latency of the operation to the specified integer value by setting the
+ latency-offsets of operations input ports to 0 and the latency-offsets of the operations
+ output ports to the specified value. The latency cannot be a negative integers.
+ """
+ raise NotImplementedError
+
+ @abstractmethod
+ def set_latency_offsets(self, latency_offsets: Dict[str, int]) -> None:
+ """Sets the latency-offsets for the operations ports specified in the latency_offsets dictionary.
+ The latency offsets dictionary should be {'in0': 2, 'out1': 4} if you want to set the latency offset
+ for the inport port with index 0 to 2, and the latency offset of the output port with index 1 to 4.
+ """
+ raise NotImplementedError
+
class AbstractOperation(Operation, AbstractGraphComponent):
"""Generic abstract operation class which most implementations will derive from.
@@ -189,57 +250,131 @@ class AbstractOperation(Operation, AbstractGraphComponent):
_input_ports: List[InputPort]
_output_ports: List[OutputPort]
- def __init__(self, input_count: int, output_count: int, name: Name = "", input_sources: Optional[Sequence[Optional[SignalSourceProvider]]] = None):
+ def __init__(self, input_count: int, output_count: int, name: Name = "", input_sources: Optional[Sequence[Optional[SignalSourceProvider]]] = None, latency: int = None, latency_offsets: Dict[str, int] = None):
super().__init__(name)
- self._input_ports = [InputPort(self, i) for i in range(input_count)] # Allocate input ports.
- self._output_ports = [OutputPort(self, i) for i in range(output_count)] # Allocate output ports.
+
+ self._input_ports = [InputPort(self, i) for i in range(input_count)]
+ self._output_ports = [OutputPort(self, i) for i in range(output_count)]
# Connect given input sources, if any.
if input_sources is not None:
source_count = len(input_sources)
if source_count != input_count:
- raise ValueError(f"Wrong number of input sources supplied to Operation (expected {input_count}, got {source_count})")
+ raise ValueError(
+ f"Wrong number of input sources supplied to Operation (expected {input_count}, got {source_count})")
for i, src in enumerate(input_sources):
if src is not None:
self._input_ports[i].connect(src.source)
+ ports_without_latency_offset = set(([f"in{i}" for i in range(self.input_count)] +
+ [f"out{i}" for i in range(self.output_count)]))
+
+ if latency_offsets is not None:
+ self.set_latency_offsets(latency_offsets)
+
+ if latency is not None:
+ # Set the latency of the rest of ports with no latency_offset.
+ assert latency >= 0, "Negative latency entered"
+ for inp in self.inputs:
+ if inp.latency_offset is None:
+ inp.latency_offset = 0
+ for outp in self.outputs:
+ if outp.latency_offset is None:
+ outp.latency_offset = latency
+
@abstractmethod
- def evaluate(self, *inputs) -> Any: # pylint: disable=arguments-differ
+ def evaluate(self, *inputs) -> Any: # pylint: disable=arguments-differ
"""Evaluate the operation and generate a list of output values given a list of input values."""
raise NotImplementedError
def __add__(self, src: Union[SignalSourceProvider, Number]) -> "Addition":
- from b_asic.core_operations import Constant, Addition # Import here to avoid circular imports.
+ # Import here to avoid circular imports.
+ from b_asic.core_operations import Constant, Addition
return Addition(self, Constant(src) if isinstance(src, Number) else src)
-
+
def __radd__(self, src: Union[SignalSourceProvider, Number]) -> "Addition":
- from b_asic.core_operations import Constant, Addition # Import here to avoid circular imports.
+ # Import here to avoid circular imports.
+ from b_asic.core_operations import Constant, Addition
return Addition(Constant(src) if isinstance(src, Number) else src, self)
def __sub__(self, src: Union[SignalSourceProvider, Number]) -> "Subtraction":
- from b_asic.core_operations import Constant, Subtraction # Import here to avoid circular imports.
+ # Import here to avoid circular imports.
+ from b_asic.core_operations import Constant, Subtraction
return Subtraction(self, Constant(src) if isinstance(src, Number) else src)
-
+
def __rsub__(self, src: Union[SignalSourceProvider, Number]) -> "Subtraction":
- from b_asic.core_operations import Constant, Subtraction # Import here to avoid circular imports.
+ # Import here to avoid circular imports.
+ from b_asic.core_operations import Constant, Subtraction
return Subtraction(Constant(src) if isinstance(src, Number) else src, self)
def __mul__(self, src: Union[SignalSourceProvider, Number]) -> "Union[Multiplication, ConstantMultiplication]":
- from b_asic.core_operations import Multiplication, ConstantMultiplication # Import here to avoid circular imports.
+ # Import here to avoid circular imports.
+ from b_asic.core_operations import Multiplication, ConstantMultiplication
return ConstantMultiplication(src, self) if isinstance(src, Number) else Multiplication(self, src)
-
+
def __rmul__(self, src: Union[SignalSourceProvider, Number]) -> "Union[Multiplication, ConstantMultiplication]":
- from b_asic.core_operations import Multiplication, ConstantMultiplication # Import here to avoid circular imports.
+ # Import here to avoid circular imports.
+ from b_asic.core_operations import Multiplication, ConstantMultiplication
return ConstantMultiplication(src, self) if isinstance(src, Number) else Multiplication(src, self)
def __truediv__(self, src: Union[SignalSourceProvider, Number]) -> "Division":
- from b_asic.core_operations import Constant, Division # Import here to avoid circular imports.
+ # Import here to avoid circular imports.
+ from b_asic.core_operations import Constant, Division
return Division(self, Constant(src) if isinstance(src, Number) else src)
-
+
def __rtruediv__(self, src: Union[SignalSourceProvider, Number]) -> "Division":
- from b_asic.core_operations import Constant, Division # Import here to avoid circular imports.
+ # Import here to avoid circular imports.
+ from b_asic.core_operations import Constant, Division
return Division(Constant(src) if isinstance(src, Number) else src, self)
+
+ def __lshift__(self, src: SignalSourceProvider) -> Signal:
+ if self.input_count != 1:
+ diff = "more" if self.input_count > 1 else "less"
+ raise TypeError(
+ f"{self.__class__.__name__} cannot be used as a destination because it has {diff} than 1 input")
+ return self.input(0).connect(src)
+ def __str__(self):
+ inputs_dict = dict()
+ for i, port in enumerate(self.inputs):
+ if port.signal_count == 0:
+ inputs_dict[i] = '-'
+ break
+ dict_ele = []
+ for signal in port.signals:
+ if signal.source:
+ if signal.source.operation.graph_id:
+ dict_ele.append(signal.source.operation.graph_id)
+ else:
+ dict_ele.append("no_id")
+ else:
+ if signal.graph_id:
+ dict_ele.append(signal.graph_id)
+ else:
+ dict_ele.append("no_id")
+ inputs_dict[i] = dict_ele
+
+ outputs_dict = dict()
+ for i, port in enumerate(self.outputs):
+ if port.signal_count == 0:
+ outputs_dict[i] = '-'
+ break
+ dict_ele = []
+ for signal in port.signals:
+ if signal.destination:
+ if signal.destination.operation.graph_id:
+ dict_ele.append(signal.destination.operation.graph_id)
+ else:
+ dict_ele.append("no_id")
+ else:
+ if signal.graph_id:
+ dict_ele.append(signal.graph_id)
+ else:
+ dict_ele.append("no_id")
+ outputs_dict[i] = dict_ele
+
+ return super().__str__() + f", \tinputs: {str(inputs_dict)}, \toutputs: {str(outputs_dict)}"
+
@property
def input_count(self) -> int:
return len(self._input_ports)
@@ -277,7 +412,7 @@ class AbstractOperation(Operation, AbstractGraphComponent):
for s in p.signals:
result.append(s)
return result
-
+
def key(self, index: int, prefix: str = "") -> ResultKey:
key = prefix
if self.output_count != 1:
@@ -288,48 +423,46 @@ class AbstractOperation(Operation, AbstractGraphComponent):
key = str(index)
return key
- def current_output(self, index: int, registers: Optional[RegisterMap] = None, prefix: str = "") -> Optional[Number]:
+ def current_output(self, index: int, delays: Optional[DelayMap] = None, prefix: str = "") -> Optional[Number]:
return None
- def evaluate_output(self, index: int, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, registers: Optional[MutableRegisterMap] = None, prefix: str = "") -> Number:
+ def evaluate_output(self, index: int, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, delays: Optional[MutableDelayMap] = None, prefix: str = "", bits_override: Optional[int] = None, truncate: bool = True) -> Number:
if index < 0 or index >= self.output_count:
- raise IndexError(f"Output index out of range (expected 0-{self.output_count - 1}, got {index})")
+ raise IndexError(
+ f"Output index out of range (expected 0-{self.output_count - 1}, got {index})")
if len(input_values) != self.input_count:
raise ValueError(f"Wrong number of input values supplied to operation (expected {self.input_count}, got {len(input_values)})")
- if results is None:
- results = {}
- if registers is None:
- registers = {}
- values = self.evaluate(*self.truncate_inputs(input_values))
+ values = self.evaluate(*(self.truncate_inputs(input_values, bits_override) if truncate else input_values))
if isinstance(values, collections.abc.Sequence):
if len(values) != self.output_count:
- raise RuntimeError(f"Operation evaluated to incorrect number of outputs (expected {self.output_count}, got {len(values)})")
+ raise RuntimeError(
+ f"Operation evaluated to incorrect number of outputs (expected {self.output_count}, got {len(values)})")
elif isinstance(values, Number):
if self.output_count != 1:
- raise RuntimeError(f"Operation evaluated to incorrect number of outputs (expected {self.output_count}, got 1)")
+ raise RuntimeError(
+ f"Operation evaluated to incorrect number of outputs (expected {self.output_count}, got 1)")
values = (values,)
else:
- raise RuntimeError(f"Operation evaluated to invalid type (expected Sequence/Number, got {values.__class__.__name__})")
+ raise RuntimeError(
+ f"Operation evaluated to invalid type (expected Sequence/Number, got {values.__class__.__name__})")
- if self.output_count == 1:
- results[self.key(index, prefix)] = values[index]
- else:
+ if results is not None:
for i in range(self.output_count):
results[self.key(i, prefix)] = values[i]
return values[index]
- def current_outputs(self, registers: Optional[RegisterMap] = None, prefix: str = "") -> Sequence[Optional[Number]]:
- return [self.current_output(i, registers, prefix) for i in range(self.output_count)]
+ def current_outputs(self, delays: Optional[DelayMap] = None, prefix: str = "") -> Sequence[Optional[Number]]:
+ return [self.current_output(i, delays, prefix) for i in range(self.output_count)]
- def evaluate_outputs(self, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, registers: Optional[MutableRegisterMap] = None, prefix: str = "") -> Sequence[Number]:
- return [self.evaluate_output(i, input_values, results, registers, prefix) for i in range(self.output_count)]
+ def evaluate_outputs(self, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, delays: Optional[MutableDelayMap] = None, prefix: str = "", bits_override: Optional[int] = None, truncate: bool = True) -> Sequence[Number]:
+ return [self.evaluate_output(i, input_values, results, delays, prefix, bits_override, truncate) for i in range(self.output_count)]
def split(self) -> Iterable[Operation]:
# Import here to avoid circular imports.
from b_asic.special_operations import Input
try:
- result = self.evaluate([Input()] * self.input_count)
+ result = self.evaluate(*([Input()] * self.input_count))
if isinstance(result, collections.Sequence) and all(isinstance(e, Operation) for e in result):
return result
if isinstance(result, Operation):
@@ -340,10 +473,57 @@ class AbstractOperation(Operation, AbstractGraphComponent):
pass
return [self]
+ def to_sfg(self) -> "SFG":
+ # Import here to avoid circular imports.
+ from b_asic.special_operations import Input, Output
+ from b_asic.signal_flow_graph import SFG
+
+ inputs = [Input() for i in range(self.input_count)]
+
+ try:
+ last_operations = self.evaluate(*inputs)
+ if isinstance(last_operations, Operation):
+ last_operations = [last_operations]
+ outputs = [Output(o) for o in last_operations]
+ except TypeError:
+ operation_copy = self.copy_component()
+ inputs = []
+ for i in range(self.input_count):
+ _input = Input()
+ operation_copy.input(i).connect(_input)
+ inputs.append(_input)
+
+ outputs = [Output(operation_copy)]
+
+ return SFG(inputs=inputs, outputs=outputs)
+
+ def copy_component(self, *args, **kwargs) -> Operation:
+ new_component = super().copy_component(*args, **kwargs)
+ for i, inp in enumerate(self.inputs):
+ new_component.input(i).latency_offset = inp.latency_offset
+ for i, outp in enumerate(self.outputs):
+ new_component.output(i).latency_offset = outp.latency_offset
+ return new_component
+
+ def inputs_required_for_output(self, output_index: int) -> Iterable[int]:
+ if output_index < 0 or output_index >= self.output_count:
+ raise IndexError(f"Output index out of range (expected 0-{self.output_count - 1}, got {output_index})")
+ return [i for i in range(self.input_count)] # By default, assume each output depends on all inputs.
+
@property
def neighbors(self) -> Iterable[GraphComponent]:
return list(self.input_signals) + list(self.output_signals)
+ @property
+ def preceding_operations(self) -> Iterable[Operation]:
+ """Returns an Iterable of all Operations that are connected to this Operations input ports."""
+ return [signal.source.operation for signal in self.input_signals if signal.source]
+
+ @property
+ def subsequent_operations(self) -> Iterable[Operation]:
+ """Returns an Iterable of all Operations that are connected to this Operations output ports."""
+ return [signal.destination.operation for signal in self.output_signals if signal.destination]
+
@property
def source(self) -> OutputPort:
if self.output_count != 1:
@@ -351,26 +531,61 @@ class AbstractOperation(Operation, AbstractGraphComponent):
raise TypeError(
f"{self.__class__.__name__} cannot be used as an input source because it has {diff} than 1 output")
return self.output(0)
-
+
def truncate_input(self, index: int, value: Number, bits: int) -> Number:
- """Truncate the value to be used as input at the given index to a certain bit length."""
- n = value
- if not isinstance(n, int):
- n = trunc(value)
- return n & ((2 ** bits) - 1)
+ return int(value) & ((2 ** bits) - 1)
- def truncate_inputs(self, input_values: Sequence[Number]) -> Sequence[Number]:
+ def truncate_inputs(self, input_values: Sequence[Number], bits_override: Optional[int] = None) -> Sequence[Number]:
"""Truncate the values to be used as inputs to the bit lengths specified by the respective signals connected to each input."""
args = []
for i, input_port in enumerate(self.inputs):
- if input_port.signal_count >= 1:
+ value = input_values[i]
+ bits = bits_override
+ if bits_override is None and input_port.signal_count >= 1:
bits = input_port.signals[0].bits
- if bits is None:
- args.append(input_values[i])
- else:
- if isinstance(input_values[i], complex):
- raise TypeError("Complex value cannot be truncated to {bits} bits as requested by the signal connected to input #{i}")
- args.append(self.truncate_input(i, input_values[i], bits))
- else:
- args.append(input_values[i])
+ if bits_override is not None:
+ if isinstance(value, complex):
+ raise TypeError("Complex value cannot be truncated to {bits} bits as requested by the signal connected to input #{i}")
+ value = self.truncate_input(i, value, bits)
+ args.append(value)
return args
+
+ @property
+ def latency(self) -> int:
+ if None in [inp.latency_offset for inp in self.inputs] or None in [outp.latency_offset for outp in self.outputs]:
+ raise ValueError("All native offsets have to set to a non-negative value to calculate the latency.")
+
+ return max(((outp.latency_offset - inp.latency_offset) for outp, inp in it.product(self.outputs, self.inputs)))
+
+ def set_latency(self, latency: int) -> None:
+ assert latency >= 0, "Negative latency entered."
+ for inport in self.inputs:
+ inport.latency_offset = 0
+ for outport in self.outputs:
+ outport.latency_offset = latency
+
+ @property
+ def latency_offsets(self) -> Sequence[Sequence[int]]:
+ latency_offsets = dict()
+
+ for i, inp in enumerate(self.inputs):
+ latency_offsets["in" + str(i)] = inp.latency_offset
+
+ for i, outp in enumerate(self.outputs):
+ latency_offsets["out" + str(i)] = outp.latency_offset
+
+ return latency_offsets
+
+ def set_latency_offsets(self, latency_offsets: Dict[str, int]) -> None:
+ for port_str, latency_offset in latency_offsets.items():
+ port_str = port_str.lower()
+ if port_str.startswith("in"):
+ index_str = port_str[2:]
+ assert index_str.isdigit(), "Incorrectly formatted index in string, expected 'in' + index"
+ self.input(int(index_str)).latency_offset = latency_offset
+ elif port_str.startswith("out"):
+ index_str = port_str[3:]
+ assert index_str.isdigit(), "Incorrectly formatted index in string, expected 'out' + index"
+ self.output(int(index_str)).latency_offset = latency_offset
+ else:
+ raise ValueError("Incorrectly formatted string, expected 'in' + index or 'out' + index")
diff --git a/b_asic/port.py b/b_asic/port.py
index e8c007cbf077f9f40df0d53fc08001e6436f0093..2d6093886992922f22af1ac0c3f09c25696301b8 100644
--- a/b_asic/port.py
+++ b/b_asic/port.py
@@ -5,7 +5,7 @@ TODO: More info.
from abc import ABC, abstractmethod
from copy import copy
-from typing import NewType, Optional, List, Iterable, TYPE_CHECKING
+from typing import Optional, List, Iterable, TYPE_CHECKING
from b_asic.signal import Signal
from b_asic.graph_component import Name
@@ -32,6 +32,18 @@ class Port(ABC):
"""Return the index of the port."""
raise NotImplementedError
+ @property
+ @abstractmethod
+ def latency_offset(self) -> int:
+ """Get the latency_offset of the port."""
+ raise NotImplementedError
+
+ @latency_offset.setter
+ @abstractmethod
+ def latency_offset(self, latency_offset: int) -> None:
+ """Set the latency_offset of the port to the integer specified value."""
+ raise NotImplementedError
+
@property
@abstractmethod
def signal_count(self) -> int:
@@ -76,10 +88,12 @@ class AbstractPort(Port):
_operation: "Operation"
_index: int
+ _latency_offset: Optional[int]
- def __init__(self, operation: "Operation", index: int):
+ def __init__(self, operation: "Operation", index: int, latency_offset: int = None):
self._operation = operation
self._index = index
+ self._latency_offset = latency_offset
@property
def operation(self) -> "Operation":
@@ -89,6 +103,14 @@ class AbstractPort(Port):
def index(self) -> int:
return self._index
+ @property
+ def latency_offset(self) -> int:
+ return self._latency_offset
+
+ @latency_offset.setter
+ def latency_offset(self, latency_offset: int):
+ self._latency_offset = latency_offset
+
class SignalSourceProvider(ABC):
"""Signal source provider interface.
@@ -128,7 +150,7 @@ class InputPort(AbstractPort):
signal.set_destination(self)
def remove_signal(self, signal: Signal) -> None:
- assert signal is self._source_signal, "Attempted to remove already removed signal."
+ assert signal is self._source_signal, "Attempted to remove signal that is not connected."
self._source_signal = None
signal.remove_destination()
@@ -150,6 +172,12 @@ class InputPort(AbstractPort):
assert self._source_signal is None, "Attempted to connect already connected input port."
# self._source_signal is set by the signal constructor.
return Signal(source=src.source, destination=self, name=name)
+
+ def __lshift__(self, src: SignalSourceProvider) -> Signal:
+ """Overloads the left shift operator to make it connect the provided signal source to this input port.
+ Returns the new signal.
+ """
+ return self.connect(src)
class OutputPort(AbstractPort, SignalSourceProvider):
@@ -177,7 +205,7 @@ class OutputPort(AbstractPort, SignalSourceProvider):
signal.set_source(self)
def remove_signal(self, signal: Signal) -> None:
- assert signal in self._destination_signals, "Attempted to remove already removed signal."
+ assert signal in self._destination_signals, "Attempted to remove signal that is not connected."
self._destination_signals.remove(signal)
signal.remove_source()
diff --git a/b_asic/precedence_chart.py b/b_asic/precedence_chart.py
deleted file mode 100644
index be55a123e0ab4330057c0bb62581e45195f5e5ba..0000000000000000000000000000000000000000
--- a/b_asic/precedence_chart.py
+++ /dev/null
@@ -1,21 +0,0 @@
-"""@package docstring
-B-ASIC Precedence Chart Module.
-TODO: More info.
-"""
-
-from b_asic.signal_flow_graph import SFG
-
-
-class PrecedenceChart:
- """Precedence chart constructed from a signal flow graph.
- TODO: More info.
- """
-
- sfg: SFG
- # TODO: More members.
-
- def __init__(self, sfg: SFG):
- self.sfg = sfg
- # TODO: Implement.
-
- # TODO: More stuff.
diff --git a/b_asic/save_load_structure.py b/b_asic/save_load_structure.py
new file mode 100644
index 0000000000000000000000000000000000000000..5311d3fe72b1bb711b21c0aa3070b538db81d2d6
--- /dev/null
+++ b/b_asic/save_load_structure.py
@@ -0,0 +1,78 @@
+"""@package docstring
+B-ASIC Save/Load SFG Module.
+Given a structure try to serialize it and save it to a file.
+Given a serialized file try to deserialize it and load it to the library.
+"""
+
+from b_asic import SFG, GraphComponent
+
+from datetime import datetime
+from inspect import signature
+from os import path
+
+def sfg_to_python(sfg: SFG, counter: int = 0, suffix: str = None) -> str:
+ result = (
+ "\n\"\"\"\nB-ASIC automatically generated SFG file.\n" +
+ "Name: " + f"{sfg.name}" + "\n" +
+ "Last saved: " + f"{datetime.now()}" + ".\n" +
+ "\"\"\""
+ )
+
+ result += "\nfrom b_asic import SFG, Signal, Input, Output"
+ for op in {type(op) for op in sfg.operations}:
+ result += f", {op.__name__}"
+
+ def kwarg_unpacker(comp: GraphComponent, params=None) -> str:
+ if params is None:
+ params_filtered = {attr: getattr(op, attr) for attr in signature(op.__init__).parameters if attr != "latency" and hasattr(op, attr)}
+ params = {attr: getattr(op, attr) if not isinstance(getattr(op, attr), str) else f'"{getattr(op, attr)}"' for attr in params_filtered}
+
+ return ", ".join([f"{param[0]}={param[1]}" for param in params.items()])
+
+ result += "\n# Inputs:\n"
+ for op in sfg._input_operations:
+ result += f"{op.graph_id} = Input({kwarg_unpacker(op)})\n"
+
+ result += "\n# Outputs:\n"
+ for op in sfg._output_operations:
+ result += f"{op.graph_id} = Output({kwarg_unpacker(op)})\n"
+
+ result += "\n# Operations:\n"
+ for op in sfg.split():
+ if isinstance(op, SFG):
+ counter += 1
+ result = sfg_to_python(op, counter) + result
+ continue
+
+ result += f"{op.graph_id} = {op.__class__.__name__}({kwarg_unpacker(op)})\n"
+
+ result += "\n# Signals:\n"
+ connections = list() # Keep track of already existing connections to avoid adding duplicates
+ for op in sfg.split():
+ for out in op.outputs:
+ for signal in out.signals:
+ dest_op = signal.destination.operation
+ connection = f"\nSignal(source={op.graph_id}.output({op.outputs.index(signal.source)}), destination={dest_op.graph_id}.input({dest_op.inputs.index(signal.destination)}))"
+ if connection in connections:
+ continue
+
+ result += connection
+ connections.append(connection)
+
+ inputs = "[" + ", ".join(op.graph_id for op in sfg.input_operations) + "]"
+ outputs = "[" + ", ".join(op.graph_id for op in sfg.output_operations) + "]"
+ sfg_name = sfg.name if sfg.name else "sfg" + str(counter) if counter > 0 else 'sfg'
+ result += f"\n{sfg_name} = SFG(inputs={inputs}, outputs={outputs}, name='{sfg_name}')\n"
+ result += "\n# SFG Properties:\n" + "prop = {'name':" + f"{sfg_name}" + "}"
+
+ if suffix is not None:
+ result += "\n" + suffix + "\n"
+
+ return result
+
+def python_to_sfg(path: str) -> SFG:
+ with open(path) as f:
+ code = compile(f.read(), path, 'exec')
+ exec(code, globals(), locals())
+
+ return locals()["prop"]["name"], locals()["positions"] if "positions" in locals() else None
\ No newline at end of file
diff --git a/b_asic/schema.py b/b_asic/schema.py
index e5068cdc080c5c5004c44c885ac48f52ba44c1f3..157ed3b8ec57a35ffe66f1de476e2d77c3e28abd 100644
--- a/b_asic/schema.py
+++ b/b_asic/schema.py
@@ -1,21 +1,107 @@
"""@package docstring
-B-ASIC Schema Module.
-TODO: More info.
+This module contains the Schema class.
+TODO: More info
"""
-from b_asic.precedence_chart import PrecedenceChart
+from typing import Dict, List
+
+from b_asic.signal_flow_graph import SFG
+from b_asic.graph_component import GraphID
+from b_asic.operation import Operation
class Schema:
- """Schema constructed from a precedence chart.
- TODO: More info.
- """
+ """A class that represents an SFG with scheduled Operations."""
+
+ _sfg: SFG
+ _start_times: Dict[GraphID, int]
+ _laps: Dict[GraphID, List[int]]
+ _schedule_time: int
+ _cyclic: bool
+ _resolution: int
+
+ def __init__(self, sfg: SFG, schedule_time: int = None, cyclic: bool = False, resolution: int = 1, scheduling_alg: str = "ASAP"):
+
+ self._sfg = sfg
+ self._start_times = dict()
+ self._laps = dict()
+ self._cyclic = cyclic
+ self._resolution = resolution
+
+ if scheduling_alg == "ASAP":
+ self._schedule_asap()
+ else:
+ raise NotImplementedError(f"No algorithm with name: {scheduling_alg} defined.")
+
+ max_end_time = 0
+ for op_id, op_start_time in self._start_times.items():
+ op = self._sfg.find_by_id(op_id)
+ for outport in op.outputs:
+ max_end_time = max(max_end_time, op_start_time + outport.latency_offset)
+
+ if not self._cyclic:
+ if schedule_time is None:
+ self._schedule_time = max_end_time
+ elif schedule_time < max_end_time:
+ raise ValueError("Too short schedule time for non-cyclic Schedule entered.")
+ else:
+ self._schedule_time = schedule_time
+
+ def start_time_of_operation(self, op_id: GraphID):
+ """Get the start time of the operation with the specified by the op_id."""
+ assert op_id in self._start_times, "No operation with the specified op_id in this schema."
+ return self._start_times[op_id]
+
+ def forward_slack(self, op_id):
+ raise NotImplementedError
+
+ def backward_slack(self, op_id):
+ raise NotImplementedError
+
+ def print_slacks(self):
+ raise NotImplementedError
+
+ def _schedule_asap(self):
+ pl = self._sfg.get_precedence_list()
+
+ if len(pl) < 2:
+ print("Empty signal flow graph cannot be scheduled.")
+ return
+
+ non_schedulable_ops = set((outp.operation.graph_id for outp in pl[0]))
+
+ for outport in pl[1]:
+ op = outport.operation
+ if op not in self._start_times:
+ # Set start time of all operations in the first iter to 0
+ self._start_times[op.graph_id] = 0
+
+ for outports in pl[2:]:
+ for outport in outports:
+ op = outport.operation
+ if op.graph_id not in self._start_times:
+ # Schedule the operation if it doesn't have a start time yet.
+ op_start_time = 0
+ for inport in op.inputs:
+ print(inport.operation.graph_id)
+ assert len(inport.signals) == 1, "Error in scheduling, dangling input port detected."
+ assert inport.signals[0].source is not None, "Error in scheduling, signal with no source detected."
+ source_port = inport.signals[0].source
+
+ source_end_time = None
+ if source_port.operation.graph_id in non_schedulable_ops:
+ source_end_time = 0
+ else:
+ source_op_time = self._start_times[source_port.operation.graph_id]
+
+ assert source_port.latency_offset is not None, f"Output port: {source_port.index} of operation: \
+ {source_port.operation.graph_id} has no latency-offset."
+ assert inport.latency_offset is not None, f"Input port: {inport.index} of operation: \
+ {inport.operation.graph_id} has no latency-offset."
- pc: PrecedenceChart
- # TODO: More members.
+ source_end_time = source_op_time + source_port.latency_offset
- def __init__(self, pc: PrecedenceChart):
- self.pc = pc
- # TODO: Implement.
+ op_start_time_from_in = source_end_time - inport.latency_offset
+ op_start_time = max(op_start_time, op_start_time_from_in)
- # TODO: More stuff.
+ self._start_times[op.graph_id] = op_start_time
diff --git a/b_asic/signal.py b/b_asic/signal.py
index d322f161b1d9c1195c2f8e5beb40f0ea7244a25b..24e8cc81566b7ba5dfb961dadb137f74afe2e111 100644
--- a/b_asic/signal.py
+++ b/b_asic/signal.py
@@ -25,14 +25,14 @@ class Signal(AbstractGraphComponent):
self.set_destination(destination)
self.set_param("bits", bits)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "s"
@property
def neighbors(self) -> Iterable[GraphComponent]:
return [p.operation for p in [self.source, self.destination] if p is not None]
-
+
@property
def source(self) -> Optional["OutputPort"]:
"""Return the source OutputPort of the signal."""
@@ -103,5 +103,6 @@ class Signal(AbstractGraphComponent):
def bits(self, bits: Optional[int]) -> None:
"""Set the number of bits that operations using this signal as an input should truncate received values to.
None = unlimited."""
- assert bits is None or (isinstance(bits, int) and bits >= 0), "Bits must be non-negative."
- self.set_param("bits", bits)
\ No newline at end of file
+ assert bits is None or (isinstance(bits, int)
+ and bits >= 0), "Bits must be non-negative."
+ self.set_param("bits", bits)
diff --git a/b_asic/signal_flow_graph.py b/b_asic/signal_flow_graph.py
index 1a2f91cb324e08ced07c001d05b6b62a857c6404..15d37addcc58c496eac99f877479ac4947f9c1da 100644
--- a/b_asic/signal_flow_graph.py
+++ b/b_asic/signal_flow_graph.py
@@ -3,15 +3,22 @@ B-ASIC Signal Flow Graph Module.
TODO: More info.
"""
-from typing import List, Iterable, Sequence, Dict, Optional, DefaultDict, Set
+from typing import List, Iterable, Sequence, Dict, Optional, DefaultDict, MutableSet, Tuple
from numbers import Number
from collections import defaultdict, deque
+from io import StringIO
+from queue import PriorityQueue
+import itertools as it
+from graphviz import Digraph
from b_asic.port import SignalSourceProvider, OutputPort
-from b_asic.operation import Operation, AbstractOperation, ResultKey, RegisterMap, MutableResultMap, MutableRegisterMap
+from b_asic.operation import Operation, AbstractOperation, ResultKey, DelayMap, MutableResultMap, MutableDelayMap
from b_asic.signal import Signal
from b_asic.graph_component import GraphID, GraphIDNumber, GraphComponent, Name, TypeName
-from b_asic.special_operations import Input, Output
+from b_asic.special_operations import Input, Output, Delay
+
+
+DelayQueue = List[Tuple[str, ResultKey, OutputPort]]
class GraphIDGenerator:
@@ -30,7 +37,7 @@ class GraphIDGenerator:
@property
def id_number_offset(self) -> GraphIDNumber:
"""Get the graph id number offset of this generator."""
- return self._next_id_number.default_factory() # pylint: disable=not-callable
+ return self._next_id_number.default_factory() # pylint: disable=not-callable
class SFG(AbstractOperation):
@@ -40,37 +47,43 @@ class SFG(AbstractOperation):
_components_by_id: Dict[GraphID, GraphComponent]
_components_by_name: DefaultDict[Name, List[GraphComponent]]
- _components_ordered: List[GraphComponent]
- _operations_ordered: List[Operation]
+ _components_dfs_order: List[GraphComponent]
+ _operations_dfs_order: List[Operation]
+ _operations_topological_order: List[Operation]
_graph_id_generator: GraphIDGenerator
_input_operations: List[Input]
_output_operations: List[Output]
- _original_components_to_new: Set[GraphComponent]
+ _original_components_to_new: MutableSet[GraphComponent]
_original_input_signals_to_indices: Dict[Signal, int]
_original_output_signals_to_indices: Dict[Signal, int]
+ _precedence_list: Optional[List[List[OutputPort]]]
- def __init__(self, input_signals: Optional[Sequence[Signal]] = None, output_signals: Optional[Sequence[Signal]] = None, \
- inputs: Optional[Sequence[Input]] = None, outputs: Optional[Sequence[Output]] = None, \
- id_number_offset: GraphIDNumber = 0, name: Name = "", \
+ def __init__(self, input_signals: Optional[Sequence[Signal]] = None, output_signals: Optional[Sequence[Signal]] = None,
+ inputs: Optional[Sequence[Input]] = None, outputs: Optional[Sequence[Output]] = None,
+ id_number_offset: GraphIDNumber = 0, name: Name = "",
input_sources: Optional[Sequence[Optional[SignalSourceProvider]]] = None):
+
input_signal_count = 0 if input_signals is None else len(input_signals)
input_operation_count = 0 if inputs is None else len(inputs)
- output_signal_count = 0 if output_signals is None else len(output_signals)
+ output_signal_count = 0 if output_signals is None else len(
+ output_signals)
output_operation_count = 0 if outputs is None else len(outputs)
- super().__init__(input_count = input_signal_count + input_operation_count,
- output_count = output_signal_count + output_operation_count,
- name = name, input_sources = input_sources)
+ super().__init__(input_count=input_signal_count + input_operation_count,
+ output_count=output_signal_count + output_operation_count,
+ name=name, input_sources=input_sources)
self._components_by_id = dict()
self._components_by_name = defaultdict(list)
- self._components_ordered = []
- self._operations_ordered = []
+ self._components_dfs_order = []
+ self._operations_dfs_order = []
+ self._operations_topological_order = []
self._graph_id_generator = GraphIDGenerator(id_number_offset)
self._input_operations = []
self._output_operations = []
self._original_components_to_new = {}
self._original_input_signals_to_indices = {}
self._original_output_signals_to_indices = {}
+ self._precedence_list = None
# Setup input signals.
if input_signals is not None:
@@ -123,7 +136,8 @@ class SFG(AbstractOperation):
new_signal = self._original_components_to_new[signal]
else:
# New signal has to be created.
- new_signal = self._add_component_unconnected_copy(signal)
+ new_signal = self._add_component_unconnected_copy(
+ signal)
new_signal.set_destination(new_output_op.input(0))
self._original_output_signals_to_indices[signal] = output_index
@@ -138,13 +152,17 @@ class SFG(AbstractOperation):
new_signal = self._original_components_to_new[signal]
if new_signal.destination is None:
if signal.destination is None:
- raise ValueError(f"Input signal #{input_index} is missing destination in SFG")
+ raise ValueError(
+ f"Input signal #{input_index} is missing destination in SFG")
if signal.destination.operation not in self._original_components_to_new:
- self._add_operation_connected_tree_copy(signal.destination.operation)
+ self._add_operation_connected_tree_copy(
+ signal.destination.operation)
elif new_signal.destination.operation in output_operations_set:
# Add directly connected input to output to ordered list.
- self._components_ordered.extend([new_signal.source.operation, new_signal, new_signal.destination.operation])
- self._operations_ordered.extend([new_signal.source.operation, new_signal.destination.operation])
+ self._components_dfs_order.extend(
+ [new_signal.source.operation, new_signal, new_signal.destination.operation])
+ self._operations_dfs_order.extend(
+ [new_signal.source.operation, new_signal.destination.operation])
# Search the graph inwards from each output signal.
for signal, output_index in self._original_output_signals_to_indices.items():
@@ -152,91 +170,139 @@ class SFG(AbstractOperation):
new_signal = self._original_components_to_new[signal]
if new_signal.source is None:
if signal.source is None:
- raise ValueError(f"Output signal #{output_index} is missing source in SFG")
+ raise ValueError(
+ f"Output signal #{output_index} is missing source in SFG")
if signal.source.operation not in self._original_components_to_new:
- self._add_operation_connected_tree_copy(signal.source.operation)
-
+ self._add_operation_connected_tree_copy(
+ signal.source.operation)
+
def __str__(self) -> str:
"""Get a string representation of this SFG."""
- output_string = ""
- for component in self._components_ordered:
- if isinstance(component, Operation):
- for key, value in self._components_by_id.items():
- if value is component:
- output_string += "id: " + key + ", name: "
-
- if component.name != None:
- output_string += component.name + ", "
- else:
- output_string += "-, "
-
- if component.type_name is "c":
- output_string += "value: " + str(component.value) + ", input: ["
- else:
- output_string += "input: ["
-
- counter_input = 0
- for input in component.inputs:
- counter_input += 1
- for signal in input.signals:
- for key, value in self._components_by_id.items():
- if value is signal:
- output_string += key + ", "
-
- if counter_input > 0:
- output_string = output_string[:-2]
- output_string += "], output: ["
- counter_output = 0
- for output in component.outputs:
- counter_output += 1
- for signal in output.signals:
- for key, value in self._components_by_id.items():
- if value is signal:
- output_string += key + ", "
- if counter_output > 0:
- output_string = output_string[:-2]
- output_string += "]\n"
-
- return output_string
+ string_io = StringIO()
+ string_io.write(super().__str__() + "\n")
+ string_io.write("Internal Operations:\n")
+ line = "-" * 100 + "\n"
+ string_io.write(line)
+
+ for operation in self.get_operations_topological_order():
+ string_io.write(str(operation) + "\n")
+
+ string_io.write(line)
+
+ return string_io.getvalue()
def __call__(self, *src: Optional[SignalSourceProvider], name: Name = "") -> "SFG":
"""Get a new independent SFG instance that is identical to this SFG except without any of its external connections."""
- return SFG(inputs = self._input_operations, outputs = self._output_operations,
- id_number_offset = self.id_number_offset, name = name, input_sources = src if src else None)
+ return SFG(inputs=self._input_operations, outputs=self._output_operations,
+ id_number_offset=self.id_number_offset, name=name, input_sources=src if src else None)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "sfg"
def evaluate(self, *args):
- result = self.evaluate_outputs(args, {}, {}, "")
+ result = self.evaluate_outputs(args)
n = len(result)
return None if n == 0 else result[0] if n == 1 else result
- def evaluate_output(self, index: int, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, registers: Optional[MutableRegisterMap] = None, prefix: str = "") -> Number:
+ def evaluate_output(self, index: int, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, delays: Optional[MutableDelayMap] = None, prefix: str = "", bits_override: Optional[int] = None, truncate: bool = True) -> Number:
if index < 0 or index >= self.output_count:
- raise IndexError(f"Output index out of range (expected 0-{self.output_count - 1}, got {index})")
+ raise IndexError(
+ f"Output index out of range (expected 0-{self.output_count - 1}, got {index})")
if len(input_values) != self.input_count:
- raise ValueError(f"Wrong number of inputs supplied to SFG for evaluation (expected {self.input_count}, got {len(input_values)})")
+ raise ValueError(
+ f"Wrong number of inputs supplied to SFG for evaluation (expected {self.input_count}, got {len(input_values)})")
if results is None:
results = {}
- if registers is None:
- registers = {}
+ if delays is None:
+ delays = {}
# Set the values of our input operations to the given input values.
- for op, arg in zip(self._input_operations, self.truncate_inputs(input_values)):
+ for op, arg in zip(self._input_operations, self.truncate_inputs(input_values, bits_override) if truncate else input_values):
op.value = arg
- value = self._evaluate_source(self._output_operations[index].input(0).signals[0].source, results, registers, prefix)
+ deferred_delays = []
+ value = self._evaluate_source(self._output_operations[index].input(0).signals[0].source, results, delays, prefix, bits_override, truncate, deferred_delays)
+ while deferred_delays:
+ new_deferred_delays = []
+ for key_base, key, src in deferred_delays:
+ self._do_evaluate_source(key_base, key, src, results, delays, prefix, bits_override, truncate, new_deferred_delays)
+ deferred_delays = new_deferred_delays
results[self.key(index, prefix)] = value
return value
+ def connect_external_signals_to_components(self) -> bool:
+ """ Connects any external signals to this SFG's internal operations. This SFG becomes unconnected to the SFG
+ it is a component off, causing it to become invalid afterwards. Returns True if succesful, False otherwise. """
+ if len(self.inputs) != len(self.input_operations):
+ raise IndexError(f"Number of inputs does not match the number of input_operations in SFG.")
+ if len(self.outputs) != len(self.output_operations):
+ raise IndexError(f"Number of outputs does not match the number of output_operations SFG.")
+ if len(self.input_signals) == 0:
+ return False
+ if len(self.output_signals) == 0:
+ return False
+
+ # For each input_signal, connect it to the corresponding operation
+ for port, input_operation in zip(self.inputs, self.input_operations):
+ dest = input_operation.output(0).signals[0].destination
+ dest.clear()
+ port.signals[0].set_destination(dest)
+ # For each output_signal, connect it to the corresponding operation
+ for port, output_operation in zip(self.outputs, self.output_operations):
+ src = output_operation.input(0).signals[0].source
+ src.clear()
+ port.signals[0].set_source(src)
+ return True
+
+ @property
+ def input_operations(self) -> Sequence[Operation]:
+ """Get the internal input operations in the same order as their respective input ports."""
+ return self._input_operations
+
+ @property
+ def output_operations(self) -> Sequence[Operation]:
+ """Get the internal output operations in the same order as their respective output ports."""
+ return self._output_operations
+
def split(self) -> Iterable[Operation]:
return self.operations
-
+
+ def to_sfg(self) -> 'SFG':
+ return self
+
+ def inputs_required_for_output(self, output_index: int) -> Iterable[int]:
+ if output_index < 0 or output_index >= self.output_count:
+ raise IndexError(
+ f"Output index out of range (expected 0-{self.output_count - 1}, got {output_index})")
+
+ input_indexes_required = []
+ sfg_input_operations_to_indexes = {
+ input_op: index for index, input_op in enumerate(self._input_operations)}
+ output_op = self._output_operations[output_index]
+ queue = deque([output_op])
+ visited = set([output_op])
+ while queue:
+ op = queue.popleft()
+ if isinstance(op, Input):
+ if op in sfg_input_operations_to_indexes:
+ input_indexes_required.append(
+ sfg_input_operations_to_indexes[op])
+ del sfg_input_operations_to_indexes[op]
+
+ for input_port in op.inputs:
+ for signal in input_port.signals:
+ if signal.source is not None:
+ new_op = signal.source.operation
+ if new_op not in visited:
+ queue.append(new_op)
+ visited.add(new_op)
+
+ return input_indexes_required
+
def copy_component(self, *args, **kwargs) -> GraphComponent:
- return super().copy_component(*args, **kwargs, inputs = self._input_operations, outputs = self._output_operations,
- id_number_offset = self.id_number_offset, name = self.name)
+ return super().copy_component(*args, **kwargs, inputs=self._input_operations, outputs=self._output_operations,
+ id_number_offset=self.id_number_offset, name=self.name)
@property
def id_number_offset(self) -> GraphIDNumber:
@@ -246,19 +312,35 @@ class SFG(AbstractOperation):
@property
def components(self) -> Iterable[GraphComponent]:
"""Get all components of this graph in depth-first order."""
- return self._components_ordered
+ return self._components_dfs_order
@property
def operations(self) -> Iterable[Operation]:
"""Get all operations of this graph in depth-first order."""
- return self._operations_ordered
+ return self._operations_dfs_order
+
+ def get_components_with_type_name(self, type_name: TypeName) -> List[GraphComponent]:
+ """Get a list with all components in this graph with the specified type_name.
+
+ Keyword arguments:
+ type_name: The type_name of the desired components.
+ """
+ i = self.id_number_offset + 1
+ components = []
+ found_comp = self.find_by_id(type_name + str(i))
+ while found_comp is not None:
+ components.append(found_comp)
+ i += 1
+ found_comp = self.find_by_id(type_name + str(i))
+
+ return components
def find_by_id(self, graph_id: GraphID) -> Optional[GraphComponent]:
"""Find the graph component with the specified ID.
Returns None if the component was not found.
Keyword arguments:
- graph_id: Graph ID of the desired component(s)
+ graph_id: Graph ID of the desired component.
"""
return self._components_by_id.get(graph_id, None)
@@ -271,6 +353,7 @@ class SFG(AbstractOperation):
"""
return self._components_by_name.get(name, [])
+<<<<<<< HEAD
def find_result_keys_by_name(self, name: Name, output_index: int = 0) -> Sequence[ResultKey]:
"""Find all graph components with the specified name and
return a sequence of the keys to use when fetching their results
@@ -285,12 +368,292 @@ class SFG(AbstractOperation):
if isinstance(comp, Operation):
keys.append(comp.key(output_index, comp.graph_id))
return keys
+=======
+ def replace_component(self, component: Operation, _id: GraphID):
+ """Find and replace all components matching either on GraphID, Type or both.
+ Then return a new deepcopy of the sfg with the replaced component.
+
+ Arguments:
+ component: The new component(s), e.g Multiplication
+ _id: The GraphID to match the component to replace.
+ """
+
+ _sfg_copy = self()
+ _component = _sfg_copy.find_by_id(_id)
+
+ assert _component is not None and isinstance(_component, Operation), \
+ "No operation matching the criteria found"
+ assert _component.output_count == component.output_count, \
+ "The output count may not differ between the operations"
+ assert _component.input_count == component.input_count, \
+ "The input count may not differ between the operations"
+
+ for index_in, _inp in enumerate(_component.inputs):
+ for _signal in _inp.signals:
+ _signal.remove_destination()
+ _signal.set_destination(component.input(index_in))
+
+ for index_out, _out in enumerate(_component.outputs):
+ for _signal in _out.signals:
+ _signal.remove_source()
+ _signal.set_source(component.output(index_out))
+
+ # The old SFG will be deleted by Python GC
+ return _sfg_copy()
+
+ def insert_operation(self, component: Operation, output_comp_id: GraphID) -> Optional["SFG"]:
+ """Insert an operation in the SFG after a given source operation.
+ The source operation output count must match the input count of the operation as well as the output
+ Then return a new deepcopy of the sfg with the inserted component.
+
+ Arguments:
+ component: The new component, e.g Multiplication.
+ output_comp_id: The source operation GraphID to connect from.
+ """
+
+ # Preserve the original SFG by creating a copy.
+ sfg_copy = self()
+ output_comp = sfg_copy.find_by_id(output_comp_id)
+ if output_comp is None:
+ return None
+
+ assert not isinstance(output_comp, Output), \
+ "Source operation can not be an output operation."
+ assert len(output_comp.output_signals) == component.input_count, \
+ "Source operation output count does not match input count for component."
+ assert len(output_comp.output_signals) == component.output_count, \
+ "Destination operation input count does not match output for component."
+
+ for index, signal_in in enumerate(output_comp.output_signals):
+ destination = signal_in.destination
+ signal_in.set_destination(component.input(index))
+ destination.connect(component.output(index))
+
+ # Recreate the newly coupled SFG so that all attributes are correct.
+ return sfg_copy()
+
+ def remove_operation(self, operation_id: GraphID) -> "SFG":
+ """Returns a version of the SFG where the operation with the specified GraphID removed.
+ The operation has to have the same amount of input- and output ports or a ValueError will
+ be raised. If no operation with the entered operation_id is found then returns None and does nothing."""
+ sfg_copy = self()
+ operation = sfg_copy.find_by_id(operation_id)
+ if operation is None:
+ return None
+
+ if operation.input_count != operation.output_count:
+ raise ValueError("Different number of input and output ports of operation with the specified id")
+
+ for i, outport in enumerate(operation.outputs):
+ if outport.signal_count > 0:
+ if operation.input(i).signal_count > 0 and operation.input(i).signals[0].source is not None:
+ in_sig = operation.input(i).signals[0]
+ source_port = in_sig.source
+ source_port.remove_signal(in_sig)
+ operation.input(i).remove_signal(in_sig)
+ for out_sig in outport.signals.copy():
+ out_sig.set_source(source_port)
+ else:
+ for out_sig in outport.signals.copy():
+ out_sig.remove_source()
+ else:
+ if operation.input(i).signal_count > 0:
+ in_sig = operation.input(i).signals[0]
+ operation.input(i).remove_signal(in_sig)
+
+ return sfg_copy()
+
+ def get_precedence_list(self) -> List[List[OutputPort]]:
+ """Returns a Precedence list of the SFG where each element in n:th the list consists
+ of elements that are executed in the n:th step. If the precedence list already has been
+ calculated for the current SFG then returns the cached version."""
+ if self._precedence_list:
+ return self._precedence_list
+
+ # Find all operations with only outputs and no inputs.
+ no_input_ops = list(filter(lambda op: op.input_count == 0, self.operations))
+ delay_ops = self.get_components_with_type_name(Delay.type_name())
+
+ # Find all first iter output ports for precedence
+ first_iter_ports = [op.output(i) for op in (no_input_ops + delay_ops) for i in range(op.output_count)]
+
+ self._precedence_list = self._traverse_for_precedence_list(first_iter_ports)
+
+ return self._precedence_list
+
+ def _traverse_for_precedence_list(self, first_iter_ports: List[OutputPort]) -> List[List[OutputPort]]:
+ # Find dependencies of output ports and input ports.
+ remaining_inports_per_operation = {op: op.input_count for op in self.operations}
+
+ # Traverse output ports for precedence
+ curr_iter_ports = first_iter_ports
+ precedence_list = []
+
+ while curr_iter_ports:
+ # Add the found ports to the current iter
+ precedence_list.append(curr_iter_ports)
+
+ next_iter_ports = []
+
+ for outport in curr_iter_ports:
+ for signal in outport.signals:
+ new_inport = signal.destination
+ # Don't traverse over delays.
+ if new_inport is not None and not isinstance(new_inport.operation, Delay):
+ new_op = new_inport.operation
+ remaining_inports_per_operation[new_op] -= 1
+ if remaining_inports_per_operation[new_op] == 0:
+ next_iter_ports.extend(new_op.outputs)
+
+ curr_iter_ports = next_iter_ports
+
+ return precedence_list
+
+ def show_precedence_graph(self) -> None:
+ p_list = self.get_precedence_list()
+ pg = Digraph()
+ pg.attr(rankdir='LR')
+
+ # Creates nodes for each output port in the precedence list
+ for i in range(len(p_list)):
+ ports = p_list[i]
+ with pg.subgraph(name='cluster_' + str(i)) as sub:
+ sub.attr(label='N' + str(i + 1))
+ for port in ports:
+ sub.node(port.operation.graph_id + '.' + str(port.index))
+ # Creates edges for each output port and creates nodes for each operation and edges for them as well
+ for i in range(len(p_list)):
+ ports = p_list[i]
+ for port in ports:
+ for signal in port.signals:
+ pg.edge(port.operation.graph_id + '.' + str(port.index), signal.destination.operation.graph_id)
+ pg.node(signal.destination.operation.graph_id, shape='square')
+ pg.edge(port.operation.graph_id, port.operation.graph_id + '.' + str(port.index))
+ pg.node(port.operation.graph_id, shape='square')
+
+ pg.view()
+
+ def print_precedence_graph(self) -> None:
+ """Prints a representation of the SFG's precedence list to the standard out.
+ If the precedence list already has been calculated then it uses the cached version,
+ otherwise it calculates the precedence list and then prints it."""
+ precedence_list = self.get_precedence_list()
+
+ line = "-" * 120
+ out_str = StringIO()
+ out_str.write(line)
+
+ printed_ops = set()
+
+ for iter_num, iter in enumerate(precedence_list, start=1):
+ for outport_num, outport in enumerate(iter, start=1):
+ if outport not in printed_ops:
+ # Only print once per operation, even if it has multiple outports
+ out_str.write("\n")
+ out_str.write(str(iter_num))
+ out_str.write(".")
+ out_str.write(str(outport_num))
+ out_str.write(" \t")
+ out_str.write(str(outport.operation))
+ printed_ops.add(outport)
+
+ out_str.write("\n")
+ out_str.write(line)
+
+ print(out_str.getvalue())
+
+ def get_operations_topological_order(self) -> Iterable[Operation]:
+ """Returns an Iterable of the Operations in the SFG in Topological Order.
+ Feedback loops makes an absolutely correct Topological order impossible, so an
+ approximative Topological Order is returned in such cases in this implementation."""
+ if self._operations_topological_order:
+ return self._operations_topological_order
+
+ no_inputs_queue = deque(list(filter(lambda op: op.input_count == 0, self.operations)))
+ remaining_inports_per_operation = {op: op.input_count for op in self.operations}
+
+ # Maps number of input counts to a queue of seen objects with such a size.
+ seen_with_inputs_dict = defaultdict(deque)
+ seen = set()
+ top_order = []
+
+ assert len(no_inputs_queue) > 0, "Illegal SFG state, dangling signals in SFG."
+
+ first_op = no_inputs_queue.popleft()
+ visited = set([first_op])
+ p_queue = PriorityQueue()
+ p_queue_entry_num = it.count()
+ # Negative priority as max-heap popping is wanted
+ p_queue.put((-first_op.output_count, -next(p_queue_entry_num), first_op))
+
+ operations_left = len(self.operations) - 1
+
+ seen_but_not_visited_count = 0
+
+ while operations_left > 0:
+ while not p_queue.empty():
+
+ op = p_queue.get()[2]
+
+ operations_left -= 1
+ top_order.append(op)
+ visited.add(op)
+
+ for neighbor_op in op.subsequent_operations:
+ if neighbor_op not in visited:
+ remaining_inports_per_operation[neighbor_op] -= 1
+ remaining_inports = remaining_inports_per_operation[neighbor_op]
+
+ if remaining_inports == 0:
+ p_queue.put((-neighbor_op.output_count, -next(p_queue_entry_num), neighbor_op))
+
+ elif remaining_inports > 0:
+ if neighbor_op in seen:
+ seen_with_inputs_dict[remaining_inports + 1].remove(neighbor_op)
+ else:
+ seen.add(neighbor_op)
+ seen_but_not_visited_count += 1
+
+ seen_with_inputs_dict[remaining_inports].append(neighbor_op)
+
+ # Check if have to fetch Operations from somewhere else since p_queue is empty
+ if operations_left > 0:
+ # First check if can fetch from Operations with no input ports
+ if no_inputs_queue:
+ new_op = no_inputs_queue.popleft()
+ p_queue.put((-new_op.output_count, -next(p_queue_entry_num), new_op))
+
+ # Else fetch operation with lowest input count that is not zero
+ elif seen_but_not_visited_count > 0:
+ for i in it.count(start=1):
+ seen_inputs_queue = seen_with_inputs_dict[i]
+ if seen_inputs_queue:
+ new_op = seen_inputs_queue.popleft()
+ p_queue.put((-new_op.output_count, -next(p_queue_entry_num), new_op))
+ seen_but_not_visited_count -= 1
+ break
+ else:
+ raise RuntimeError("Unallowed structure in SFG detected")
+
+ self._operations_topological_order = top_order
+ return self._operations_topological_order
+
+ def set_latency_of_type(self, type_name: TypeName, latency: int) -> None:
+ """TODO: docstring"""
+ for op in self.get_components_with_type_name(type_name):
+ op.set_latency(latency)
+
+ def set_latency_offsets_of_type(self, type_name: TypeName, latency_offsets: Dict[str, int]) -> None:
+ """TODO: docstring"""
+ for op in self.get_components_with_type_name(type_name):
+ op.set_latency_offsets(latency_offsets)
+>>>>>>> d2ae5743259f581c116bb3772d17c3b2023ed9e0
def _add_component_unconnected_copy(self, original_component: GraphComponent) -> GraphComponent:
assert original_component not in self._original_components_to_new, "Tried to add duplicate SFG component"
new_component = original_component.copy_component()
self._original_components_to_new[original_component] = new_component
- new_id = self._graph_id_generator.next_id(new_component.type_name)
+ new_id = self._graph_id_generator.next_id(new_component.type_name())
new_component.graph_id = new_id
self._components_by_id[new_id] = new_component
self._components_by_name[new_component.name].append(new_component)
@@ -304,8 +667,8 @@ class SFG(AbstractOperation):
new_op = None
if original_op not in self._original_components_to_new:
new_op = self._add_component_unconnected_copy(original_op)
- self._components_ordered.append(new_op)
- self._operations_ordered.append(new_op)
+ self._components_dfs_order.append(new_op)
+ self._operations_dfs_order.append(new_op)
else:
new_op = self._original_components_to_new[original_op]
@@ -320,29 +683,33 @@ class SFG(AbstractOperation):
# New signal already created during first step of constructor.
new_signal = self._original_components_to_new[original_signal]
new_signal.set_destination(new_op.input(original_input_port.index))
- self._components_ordered.extend([new_signal, new_signal.source.operation])
- self._operations_ordered.append(new_signal.source.operation)
+
+ self._components_dfs_order.extend([new_signal, new_signal.source.operation])
+ self._operations_dfs_order.append(new_signal.source.operation)
# Check if the signal has not been added before.
elif original_signal not in self._original_components_to_new:
if original_signal.source is None:
raise ValueError("Dangling signal without source in SFG")
-
+
new_signal = self._add_component_unconnected_copy(original_signal)
new_signal.set_destination(new_op.input(original_input_port.index))
- self._components_ordered.append(new_signal)
+
+ self._components_dfs_order.append(new_signal)
original_connected_op = original_signal.source.operation
# Check if connected Operation has been added before.
if original_connected_op in self._original_components_to_new:
# Set source to the already added operations port.
- new_signal.set_source(self._original_components_to_new[original_connected_op].output(original_signal.source.index))
+ new_signal.set_source(self._original_components_to_new[original_connected_op].output(
+ original_signal.source.index))
else:
# Create new operation, set signal source to it.
new_connected_op = self._add_component_unconnected_copy(original_connected_op)
new_signal.set_source(new_connected_op.output(original_signal.source.index))
- self._components_ordered.append(new_connected_op)
- self._operations_ordered.append(new_connected_op)
+
+ self._components_dfs_order.append(new_connected_op)
+ self._operations_dfs_order.append(new_connected_op)
# Add connected operation to queue of operations to visit.
op_stack.append(original_connected_op)
@@ -355,8 +722,9 @@ class SFG(AbstractOperation):
# New signal already created during first step of constructor.
new_signal = self._original_components_to_new[original_signal]
new_signal.set_source(new_op.output(original_output_port.index))
- self._components_ordered.extend([new_signal, new_signal.destination.operation])
- self._operations_ordered.append(new_signal.destination.operation)
+
+ self._components_dfs_order.extend([new_signal, new_signal.destination.operation])
+ self._operations_dfs_order.append(new_signal.destination.operation)
# Check if signal has not been added before.
elif original_signal not in self._original_components_to_new:
@@ -365,76 +733,60 @@ class SFG(AbstractOperation):
new_signal = self._add_component_unconnected_copy(original_signal)
new_signal.set_source(new_op.output(original_output_port.index))
- self._components_ordered.append(new_signal)
+
+ self._components_dfs_order.append(new_signal)
original_connected_op = original_signal.destination.operation
# Check if connected operation has been added.
if original_connected_op in self._original_components_to_new:
# Set destination to the already connected operations port.
- new_signal.set_destination(self._original_components_to_new[original_connected_op].input(original_signal.destination.index))
+ new_signal.set_destination(self._original_components_to_new[original_connected_op].input(
+ original_signal.destination.index))
else:
# Create new operation, set destination to it.
new_connected_op = self._add_component_unconnected_copy(original_connected_op)
new_signal.set_destination(new_connected_op.input(original_signal.destination.index))
- self._components_ordered.append(new_connected_op)
- self._operations_ordered.append(new_connected_op)
+
+ self._components_dfs_order.append(new_connected_op)
+ self._operations_dfs_order.append(new_connected_op)
# Add connected operation to the queue of operations to visit.
op_stack.append(original_connected_op)
- def replace_component(self, component: Operation, _component: Operation = None, _id: GraphID = None):
- """Find and replace all components matching either on GraphID, Type or both.
- Then return a new deepcopy of the sfg with the replaced component.
-
- Arguments:
- component: The new component(s), e.g Multiplication
-
- Keyword arguments:
- _component: The specific component to replace.
- _id: The GraphID to match the component to replace.
- """
-
- assert _component is not None or _id is not None, \
- "Define either operation to replace or GraphID of operation"
-
- if _id is not None:
- _component = self.find_by_id(_id)
-
- assert _component is not None and isinstance(_component, Operation), \
- "No operation matching the criteria found"
- assert _component.output_count == component.output_count, \
- "The output count may not differ between the operations"
- assert _component.input_count == component.input_count, \
- "The input count may not differ between the operations"
-
- for index_in, _inp in enumerate(_component.inputs):
- for _signal in _inp.signals:
- _signal.remove_destination()
- _signal.set_destination(component.input(index_in))
-
- for index_out, _out in enumerate(_component.outputs):
- for _signal in _out.signals:
- _signal.remove_source()
- _signal.set_source(component.output(index_out))
-
- # The old SFG will be deleted by Python GC
- return self()
-
- def _evaluate_source(self, src: OutputPort, results: MutableResultMap, registers: MutableRegisterMap, prefix: str) -> Number:
- src_prefix = prefix
- if src_prefix:
- src_prefix += "."
- src_prefix += src.operation.graph_id
-
- key = src.operation.key(src.index, src_prefix)
+ def _evaluate_source(self, src: OutputPort, results: MutableResultMap, delays: MutableDelayMap, prefix: str, bits_override: Optional[int], truncate: bool, deferred_delays: DelayQueue) -> Number:
+ key_base = (prefix + "." + src.operation.graph_id) if prefix else src.operation.graph_id
+ key = src.operation.key(src.index, key_base)
if key in results:
value = results[key]
if value is None:
- raise RuntimeError(f"Direct feedback loop detected when evaluating operation.")
+ raise RuntimeError("Direct feedback loop detected when evaluating operation.")
return value
+
+ value = src.operation.current_output(src.index, delays, key_base)
+ results[key] = value
+ if value is None:
+ value = self._do_evaluate_source(key_base, key, src, results, delays, prefix, bits_override, truncate, deferred_delays)
+ else:
+ deferred_delays.append((key_base, key, src)) # Evaluate later. Use current value for now.
+ return value
- results[key] = src.operation.current_output(src.index, registers, src_prefix)
- input_values = [self._evaluate_source(input_port.signals[0].source, results, registers, prefix) for input_port in src.operation.inputs]
- value = src.operation.evaluate_output(src.index, input_values, results, registers, src_prefix)
+ def _do_evaluate_source(self, key_base: str, key: ResultKey, src: OutputPort, results: MutableResultMap, delays: MutableDelayMap, prefix: str, bits_override: Optional[int], truncate: bool, deferred_delays: DelayQueue) -> Number:
+ input_values = [self._evaluate_source(input_port.signals[0].source, results, delays, prefix, bits_override, truncate, deferred_delays) for input_port in src.operation.inputs]
+ value = src.operation.evaluate_output(src.index, input_values, results, delays, key_base, bits_override, truncate)
results[key] = value
return value
+
+ def _inputs_required_for_source(self, src: OutputPort, visited: MutableSet[Operation]) -> Sequence[bool]:
+ if src.operation in visited:
+ return []
+ visited.add(src.operation)
+
+ if isinstance(src.operation, Input):
+ for i, input_operation in enumerate(self._input_operations):
+ if input_operation is src.operation:
+ return [i]
+
+ input_indices = []
+ for i in src.operation.inputs_required_for_output(src.index):
+ input_indices.extend(self._inputs_required_for_source(src.operation.input(i).signals[0].source, visited))
+ return input_indices
diff --git a/b_asic/simulation.py b/b_asic/simulation.py
index 9d0d154fa899923ee28cf444512262fb85c73a3a..7829d171a38ff74c9a90b513e5a21034727e7492 100644
--- a/b_asic/simulation.py
+++ b/b_asic/simulation.py
@@ -3,15 +3,20 @@ B-ASIC Simulation Module.
TODO: More info.
"""
+import numpy as np
+
from collections import defaultdict
from numbers import Number
-from typing import List, Dict, DefaultDict, Callable, Sequence, Mapping, Union, Optional
+from typing import List, Dict, DefaultDict, Callable, Sequence, Mapping, Union, Optional, MutableSequence, MutableMapping
-from b_asic.operation import ResultKey, ResultMap
+from b_asic.operation import ResultKey, ResultMap, MutableResultMap, MutableDelayMap
from b_asic.signal_flow_graph import SFG
-InputProvider = Union[Number, Sequence[Number], Callable[[int], Number]]
+ResultArrayMap = Mapping[ResultKey, Sequence[Number]]
+MutableResultArrayMap = MutableMapping[ResultKey, MutableSequence[Number]]
+InputFunction = Callable[[int], Number]
+InputProvider = Union[Number, Sequence[Number], InputFunction]
class Simulation:
@@ -20,74 +25,74 @@ class Simulation:
"""
_sfg: SFG
- _results: DefaultDict[int, Dict[str, Number]]
- _registers: Dict[str, Number]
+ _results: MutableResultArrayMap
+ _delays: MutableDelayMap
_iteration: int
- _input_functions: Sequence[Callable[[int], Number]]
- _current_input_values: Sequence[Number]
- _latest_output_values: Sequence[Number]
- _save_results: bool
+ _input_functions: Sequence[InputFunction]
+ _input_length: Optional[int]
- def __init__(self, sfg: SFG, input_providers: Optional[Sequence[Optional[InputProvider]]] = None, save_results: bool = False):
+ def __init__(self, sfg: SFG, input_providers: Optional[Sequence[Optional[InputProvider]]] = None):
self._sfg = sfg
- self._results = defaultdict(dict)
- self._registers = {}
+ self._results = defaultdict(list)
+ self._delays = {}
self._iteration = 0
self._input_functions = [lambda _: 0 for _ in range(self._sfg.input_count)]
- self._current_input_values = [0 for _ in range(self._sfg.input_count)]
- self._latest_output_values = [0 for _ in range(self._sfg.output_count)]
- self._save_results = save_results
+ self._input_length = None
if input_providers is not None:
self.set_inputs(input_providers)
def set_input(self, index: int, input_provider: InputProvider) -> None:
"""Set the input function used to get values for the specific input at the given index to the internal SFG."""
if index < 0 or index >= len(self._input_functions):
- raise IndexError(f"Input index out of range (expected 0-{len(self._input_functions) - 1}, got {index})")
+ raise IndexError(
+ f"Input index out of range (expected 0-{len(self._input_functions) - 1}, got {index})")
if callable(input_provider):
self._input_functions[index] = input_provider
elif isinstance(input_provider, Number):
self._input_functions[index] = lambda _: input_provider
else:
+ if self._input_length is None:
+ self._input_length = len(input_provider)
+ elif self._input_length != len(input_provider):
+ raise ValueError(f"Inconsistent input length for simulation (was {self._input_length}, got {len(input_provider)})")
self._input_functions[index] = lambda n: input_provider[n]
def set_inputs(self, input_providers: Sequence[Optional[InputProvider]]) -> None:
"""Set the input functions used to get values for the inputs to the internal SFG."""
if len(input_providers) != self._sfg.input_count:
raise ValueError(f"Wrong number of inputs supplied to simulation (expected {self._sfg.input_count}, got {len(input_providers)})")
- self._input_functions = [None for _ in range(self._sfg.input_count)]
for index, input_provider in enumerate(input_providers):
if input_provider is not None:
self.set_input(index, input_provider)
- @property
- def save_results(self) -> bool:
- """Get the flag that determines if the results of ."""
- return self._save_results
-
- @save_results.setter
- def save_results(self, save_results) -> None:
- self._save_results = save_results
-
- def run(self) -> Sequence[Number]:
+ def step(self, save_results: bool = True, bits_override: Optional[int] = None, truncate: bool = True) -> Sequence[Number]:
"""Run one iteration of the simulation and return the resulting output values."""
- return self.run_for(1)
+ return self.run_for(1, save_results, bits_override, truncate)
- def run_until(self, iteration: int) -> Sequence[Number]:
+ def run_until(self, iteration: int, save_results: bool = True, bits_override: Optional[int] = None, truncate: bool = True) -> Sequence[Number]:
"""Run the simulation until its iteration is greater than or equal to the given iteration
- and return the resulting output values.
+ and return the output values of the last iteration.
"""
+ result = []
while self._iteration < iteration:
- self._current_input_values = [self._input_functions[i](self._iteration) for i in range(self._sfg.input_count)]
- self._latest_output_values = self._sfg.evaluate_outputs(self._current_input_values, self._results[self._iteration], self._registers)
- if not self._save_results:
- del self._results[self.iteration]
+ input_values = [self._input_functions[i](self._iteration) for i in range(self._sfg.input_count)]
+ results = {}
+ result = self._sfg.evaluate_outputs(input_values, results, self._delays, "", bits_override, truncate)
+ if save_results:
+ for key, value in results.items():
+ self._results[key].append(value)
self._iteration += 1
- return self._latest_output_values
+ return result
+
+ def run_for(self, iterations: int, save_results: bool = True, bits_override: Optional[int] = None, truncate: bool = True) -> Sequence[Number]:
+ """Run a given number of iterations of the simulation and return the output values of the last iteration."""
+ return self.run_until(self._iteration + iterations, save_results, bits_override, truncate)
- def run_for(self, iterations: int) -> Sequence[Number]:
- """Run a given number of iterations of the simulation and return the resulting output values."""
- return self.run_until(self._iteration + iterations)
+ def run(self, save_results: bool = True, bits_override: Optional[int] = None, truncate: bool = True) -> Sequence[Number]:
+ """Run the simulation until the end of its input arrays and return the output values of the last iteration."""
+ if self._input_length is None:
+ raise IndexError("Tried to run unlimited simulation")
+ return self.run_until(self._input_length, save_results, bits_override, truncate)
@property
def iteration(self) -> int:
@@ -95,12 +100,13 @@ class Simulation:
return self._iteration
@property
- def results(self) -> Mapping[int, ResultMap]:
- """Get a mapping of all results, including intermediate values, calculated for each iteration up until now.
- The outer mapping maps from iteration number to value mapping. The value mapping maps output port identifiers to values.
- Example: {0: {"c1": 3, "c2": 4, "bfly1.0": 7, "bfly1.1": -1, "0": 7}}
+ def results(self) -> ResultArrayMap:
+ """Get a mapping from result keys to numpy arrays containing all results, including intermediate values,
+ calculated for each iteration up until now that was run with save_results enabled.
+ The mapping is indexed using the key() method of Operation with the appropriate output index.
+ Example result after 3 iterations: {"c1": [3, 6, 7], "c2": [4, 5, 5], "bfly1.0": [7, 0, 0], "bfly1.1": [-1, 0, 2], "0": [7, -2, -1]}
"""
- return self._results
+ return {key: np.array(value) for key, value in self._results.items()}
def clear_results(self) -> None:
"""Clear all results that were saved until now."""
@@ -108,6 +114,4 @@ class Simulation:
def clear_state(self) -> None:
"""Clear all current state of the simulation, except for the results and iteration."""
- self._registers.clear()
- self._current_input_values = [0 for _ in range(self._sfg.input_count)]
- self._latest_output_values = [0 for _ in range(self._sfg.output_count)]
\ No newline at end of file
+ self._delays.clear()
diff --git a/b_asic/special_operations.py b/b_asic/special_operations.py
index 96d341b9cac01cc2d260544b4d2501d68c0808c0..8c15c55aed2ab7821467b51e84750a86743bde7a 100644
--- a/b_asic/special_operations.py
+++ b/b_asic/special_operations.py
@@ -6,7 +6,7 @@ TODO: More info.
from numbers import Number
from typing import Optional, Sequence
-from b_asic.operation import AbstractOperation, ResultKey, RegisterMap, MutableResultMap, MutableRegisterMap
+from b_asic.operation import AbstractOperation, ResultKey, DelayMap, MutableResultMap, MutableDelayMap
from b_asic.graph_component import Name, TypeName
from b_asic.port import SignalSourceProvider
@@ -17,13 +17,13 @@ class Input(AbstractOperation):
"""
def __init__(self, name: Name = ""):
- super().__init__(input_count = 0, output_count = 1, name = name)
+ super().__init__(input_count=0, output_count=1, name=name)
self.set_param("value", 0)
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "in"
-
+
def evaluate(self):
return self.param("value")
@@ -44,48 +44,62 @@ class Output(AbstractOperation):
"""
def __init__(self, src0: Optional[SignalSourceProvider] = None, name: Name = ""):
- super().__init__(input_count = 1, output_count = 0, name = name, input_sources = [src0])
+ super().__init__(input_count=1, output_count=0,
+ name=name, input_sources=[src0])
- @property
- def type_name(self) -> TypeName:
+ @classmethod
+ def type_name(cls) -> TypeName:
return "out"
def evaluate(self, _):
return None
-class Register(AbstractOperation):
+class Delay(AbstractOperation):
"""Unit delay operation.
TODO: More info.
"""
def __init__(self, src0: Optional[SignalSourceProvider] = None, initial_value: Number = 0, name: Name = ""):
- super().__init__(input_count = 1, output_count = 1, name = name, input_sources = [src0])
+ super().__init__(input_count=1, output_count=1,
+ name=name, input_sources=[src0])
self.set_param("initial_value", initial_value)
- @property
- def type_name(self) -> TypeName:
- return "reg"
+ @classmethod
+ def type_name(cls) -> TypeName:
+ return "t"
def evaluate(self, a):
return self.param("initial_value")
- def current_output(self, index: int, registers: Optional[RegisterMap] = None, prefix: str = "") -> Optional[Number]:
- if registers is not None:
- return registers.get(self.key(index, prefix), self.param("initial_value"))
+ def current_output(self, index: int, delays: Optional[DelayMap] = None, prefix: str = "") -> Optional[Number]:
+ if delays is not None:
+ return delays.get(self.key(index, prefix), self.param("initial_value"))
return self.param("initial_value")
- def evaluate_output(self, index: int, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, registers: Optional[MutableRegisterMap] = None, prefix: str = "") -> Number:
+ def evaluate_output(self, index: int, input_values: Sequence[Number], results: Optional[MutableResultMap] = None, delays: Optional[MutableDelayMap] = None, prefix: str = "", bits_override: Optional[int] = None, truncate: bool = True) -> Number:
if index != 0:
- raise IndexError(f"Output index out of range (expected 0-0, got {index})")
+ raise IndexError(
+ f"Output index out of range (expected 0-0, got {index})")
if len(input_values) != 1:
- raise ValueError(f"Wrong number of inputs supplied to SFG for evaluation (expected 1, got {len(input_values)})")
-
+ raise ValueError(
+ f"Wrong number of inputs supplied to SFG for evaluation (expected 1, got {len(input_values)})")
+
key = self.key(index, prefix)
value = self.param("initial_value")
- if registers is not None:
- value = registers.get(key, value)
- registers[key] = self.truncate_inputs(input_values)[0]
+ if delays is not None:
+ value = delays.get(key, value)
+ delays[key] = self.truncate_inputs(input_values, bits_override)[0] if truncate else input_values[0]
if results is not None:
results[key] = value
- return value
\ No newline at end of file
+ return value
+
+ @property
+ def initial_value(self) -> Number:
+ """Get the initial value of this delay."""
+ return self.param("initial_value")
+
+ @initial_value.setter
+ def initial_value(self, value: Number) -> None:
+ """Set the initial value of this delay."""
+ self.set_param("initial_value", value)
diff --git a/legacy/README.md b/legacy/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..746d1efdb57c04f4e52bb2ce7f0a7def99c744ed
--- /dev/null
+++ b/legacy/README.md
@@ -0,0 +1,11 @@
+# Legacy files
+
+This folder contains currently unused code that is kept for acedemic purposes,
+or to be used as a refererence for future development.
+
+## simulation_oop
+
+This folder contains a C++ implementation of the Simulation class designed
+using Object-Oriented Programming, as opposed to the current version that uses
+Data-Oriented Design. They are functionally identical, but use different
+styles of programming and have different performance characteristics.
\ No newline at end of file
diff --git a/legacy/simulation_oop/core_operations.h b/legacy/simulation_oop/core_operations.h
new file mode 100644
index 0000000000000000000000000000000000000000..0926572905053cdf5c762f73545642f1ffe3d4f8
--- /dev/null
+++ b/legacy/simulation_oop/core_operations.h
@@ -0,0 +1,236 @@
+#ifndef ASIC_SIMULATION_CORE_OPERATIONS_H
+#define ASIC_SIMULATION_CORE_OPERATIONS_H
+
+#define NOMINMAX
+#include "../debug.h"
+#include "../number.h"
+#include "operation.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <stdexcept>
+#include <utility>
+
+namespace asic {
+
+class constant_operation final : public abstract_operation {
+public:
+ constant_operation(result_key key, number value)
+ : abstract_operation(std::move(key))
+ , m_value(value) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const&) const final {
+ ASIC_DEBUG_MSG("Evaluating constant.");
+ return m_value;
+ }
+
+ number m_value;
+};
+
+class addition_operation final : public binary_operation {
+public:
+ explicit addition_operation(result_key key)
+ : binary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating addition.");
+ return this->evaluate_lhs(context) + this->evaluate_rhs(context);
+ }
+};
+
+class subtraction_operation final : public binary_operation {
+public:
+ explicit subtraction_operation(result_key key)
+ : binary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating subtraction.");
+ return this->evaluate_lhs(context) - this->evaluate_rhs(context);
+ }
+};
+
+class multiplication_operation final : public binary_operation {
+public:
+ explicit multiplication_operation(result_key key)
+ : binary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating multiplication.");
+ return this->evaluate_lhs(context) * this->evaluate_rhs(context);
+ }
+};
+
+class division_operation final : public binary_operation {
+public:
+ explicit division_operation(result_key key)
+ : binary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating division.");
+ return this->evaluate_lhs(context) / this->evaluate_rhs(context);
+ }
+};
+
+class min_operation final : public binary_operation {
+public:
+ explicit min_operation(result_key key)
+ : binary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating min.");
+ auto const lhs = this->evaluate_lhs(context);
+ if (lhs.imag() != 0) {
+ throw std::runtime_error{"Min does not support complex numbers."};
+ }
+ auto const rhs = this->evaluate_rhs(context);
+ if (rhs.imag() != 0) {
+ throw std::runtime_error{"Min does not support complex numbers."};
+ }
+ return std::min(lhs.real(), rhs.real());
+ }
+};
+
+class max_operation final : public binary_operation {
+public:
+ explicit max_operation(result_key key)
+ : binary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating max.");
+ auto const lhs = this->evaluate_lhs(context);
+ if (lhs.imag() != 0) {
+ throw std::runtime_error{"Max does not support complex numbers."};
+ }
+ auto const rhs = this->evaluate_rhs(context);
+ if (rhs.imag() != 0) {
+ throw std::runtime_error{"Max does not support complex numbers."};
+ }
+ return std::max(lhs.real(), rhs.real());
+ }
+};
+
+class square_root_operation final : public unary_operation {
+public:
+ explicit square_root_operation(result_key key)
+ : unary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating sqrt.");
+ return std::sqrt(this->evaluate_input(context));
+ }
+};
+
+class complex_conjugate_operation final : public unary_operation {
+public:
+ explicit complex_conjugate_operation(result_key key)
+ : unary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating conj.");
+ return std::conj(this->evaluate_input(context));
+ }
+};
+
+class absolute_operation final : public unary_operation {
+public:
+ explicit absolute_operation(result_key key)
+ : unary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating abs.");
+ return std::abs(this->evaluate_input(context));
+ }
+};
+
+class constant_multiplication_operation final : public unary_operation {
+public:
+ constant_multiplication_operation(result_key key, number value)
+ : unary_operation(std::move(key))
+ , m_value(value) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 1;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating cmul.");
+ return this->evaluate_input(context) * m_value;
+ }
+
+ number m_value;
+};
+
+class butterfly_operation final : public binary_operation {
+public:
+ explicit butterfly_operation(result_key key)
+ : binary_operation(std::move(key)) {}
+
+ [[nodiscard]] std::size_t output_count() const noexcept final {
+ return 2;
+ }
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t index, evaluation_context const& context) const final {
+ ASIC_DEBUG_MSG("Evaluating bfly.");
+ if (index == 0) {
+ return this->evaluate_lhs(context) + this->evaluate_rhs(context);
+ }
+ return this->evaluate_lhs(context) - this->evaluate_rhs(context);
+ }
+};
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_CORE_OPERATIONS_H
\ No newline at end of file
diff --git a/legacy/simulation_oop/custom_operation.cpp b/legacy/simulation_oop/custom_operation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9153eb5b651f3a481747f3b652f790ce581e70dc
--- /dev/null
+++ b/legacy/simulation_oop/custom_operation.cpp
@@ -0,0 +1,30 @@
+#include "custom_operation.h"
+
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+namespace asic {
+
+custom_operation::custom_operation(result_key key, pybind11::object evaluate_output, pybind11::object truncate_input,
+ std::size_t output_count)
+ : nary_operation(std::move(key))
+ , m_evaluate_output(std::move(evaluate_output))
+ , m_truncate_input(std::move(truncate_input))
+ , m_output_count(output_count) {}
+
+std::size_t custom_operation::output_count() const noexcept {
+ return m_output_count;
+}
+
+number custom_operation::evaluate_output_impl(std::size_t index, evaluation_context const& context) const {
+ using namespace pybind11::literals;
+ auto input_values = this->evaluate_inputs(context);
+ return m_evaluate_output(index, std::move(input_values), "truncate"_a = false).cast<number>();
+}
+
+number custom_operation::truncate_input(std::size_t index, number value, std::size_t bits) const {
+ return m_truncate_input(index, value, bits).cast<number>();
+}
+
+} // namespace asic
\ No newline at end of file
diff --git a/legacy/simulation_oop/custom_operation.h b/legacy/simulation_oop/custom_operation.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a11aaacbc8c17500069522d9d8f56d9c416d804
--- /dev/null
+++ b/legacy/simulation_oop/custom_operation.h
@@ -0,0 +1,35 @@
+#ifndef ASIC_SIMULATION_CUSTOM_OPERATION_H
+#define ASIC_SIMULATION_CUSTOM_OPERATION_H
+
+#include "../algorithm.h"
+#include "../debug.h"
+#include "../number.h"
+#include "operation.h"
+
+#include <cstddef>
+#include <fmt/format.h>
+#include <functional>
+#include <pybind11/pybind11.h>
+#include <stdexcept>
+#include <utility>
+
+namespace asic {
+
+class custom_operation final : public nary_operation {
+public:
+ custom_operation(result_key key, pybind11::object evaluate_output, pybind11::object truncate_input, std::size_t output_count);
+
+ [[nodiscard]] std::size_t output_count() const noexcept final;
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t index, evaluation_context const& context) const final;
+ [[nodiscard]] number truncate_input(std::size_t index, number value, std::size_t bits) const final;
+
+ pybind11::object m_evaluate_output;
+ pybind11::object m_truncate_input;
+ std::size_t m_output_count;
+};
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_CUSTOM_OPERATION_H
\ No newline at end of file
diff --git a/legacy/simulation_oop/operation.cpp b/legacy/simulation_oop/operation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a9738a0a05287f6ab2d430d4c73560a4c6bd57c5
--- /dev/null
+++ b/legacy/simulation_oop/operation.cpp
@@ -0,0 +1,156 @@
+#include "operation.h"
+
+#include "../debug.h"
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+namespace asic {
+
+signal_source::signal_source(std::shared_ptr<const operation> op, std::size_t index, std::optional<std::size_t> bits)
+ : m_operation(std::move(op))
+ , m_index(index)
+ , m_bits(std::move(bits)) {}
+
+signal_source::operator bool() const noexcept {
+ return static_cast<bool>(m_operation);
+}
+
+std::optional<number> signal_source::current_output(delay_map const& delays) const {
+ ASIC_ASSERT(m_operation);
+ return m_operation->current_output(m_index, delays);
+}
+
+number signal_source::evaluate_output(evaluation_context const& context) const {
+ ASIC_ASSERT(m_operation);
+ return m_operation->evaluate_output(m_index, context);
+}
+
+std::optional<std::size_t> signal_source::bits() const noexcept {
+ return m_bits;
+}
+
+abstract_operation::abstract_operation(result_key key)
+ : m_key(std::move(key)) {}
+
+std::optional<number> abstract_operation::current_output(std::size_t, delay_map const&) const {
+ return std::nullopt;
+}
+
+number abstract_operation::evaluate_output(std::size_t index, evaluation_context const& context) const {
+ ASIC_ASSERT(index < this->output_count());
+ ASIC_ASSERT(context.results);
+ auto const key = this->key_of_output(index);
+ if (auto const it = context.results->find(key); it != context.results->end()) {
+ if (it->second) {
+ return *it->second;
+ }
+ throw std::runtime_error{"Direct feedback loop detected when evaluating simulation operation."};
+ }
+ auto& result = context.results->try_emplace(key, this->current_output(index, *context.delays))
+ .first->second; // Use a reference to avoid potential iterator invalidation caused by evaluate_output_impl.
+ auto const value = this->evaluate_output_impl(index, context);
+ ASIC_ASSERT(&context.results->at(key) == &result);
+ result = value;
+ return value;
+}
+
+number abstract_operation::truncate_input(std::size_t index, number value, std::size_t bits) const {
+ if (value.imag() != 0) {
+ throw py::type_error{
+ fmt::format("Complex value cannot be truncated to {} bits as requested by the signal connected to input #{}", bits, index)};
+ }
+ if (bits > 64) {
+ throw py::value_error{
+ fmt::format("Cannot truncate to {} (more than 64) bits as requested by the singal connected to input #{}", bits, index)};
+ }
+ return number{static_cast<number::value_type>(static_cast<std::int64_t>(value.real()) & ((std::int64_t{1} << bits) - 1))};
+}
+
+result_key const& abstract_operation::key_base() const {
+ return m_key;
+}
+
+result_key abstract_operation::key_of_output(std::size_t index) const {
+ if (m_key.empty()) {
+ return fmt::to_string(index);
+ }
+ if (this->output_count() == 1) {
+ return m_key;
+ }
+ return fmt::format("{}.{}", m_key, index);
+}
+
+unary_operation::unary_operation(result_key key)
+ : abstract_operation(std::move(key)) {}
+
+void unary_operation::connect(signal_source in) {
+ m_in = std::move(in);
+}
+
+bool unary_operation::connected() const noexcept {
+ return static_cast<bool>(m_in);
+}
+
+signal_source const& unary_operation::input() const noexcept {
+ return m_in;
+}
+
+number unary_operation::evaluate_input(evaluation_context const& context) const {
+ auto const value = m_in.evaluate_output(context);
+ auto const bits = context.bits_override.value_or(m_in.bits().value_or(0));
+ return (context.truncate && bits) ? this->truncate_input(0, value, bits) : value;
+}
+
+binary_operation::binary_operation(result_key key)
+ : abstract_operation(std::move(key)) {}
+
+void binary_operation::connect(signal_source lhs, signal_source rhs) {
+ m_lhs = std::move(lhs);
+ m_rhs = std::move(rhs);
+}
+
+signal_source const& binary_operation::lhs() const noexcept {
+ return m_lhs;
+}
+
+signal_source const& binary_operation::rhs() const noexcept {
+ return m_rhs;
+}
+
+number binary_operation::evaluate_lhs(evaluation_context const& context) const {
+ auto const value = m_lhs.evaluate_output(context);
+ auto const bits = context.bits_override.value_or(m_lhs.bits().value_or(0));
+ return (context.truncate && bits) ? this->truncate_input(0, value, bits) : value;
+}
+
+number binary_operation::evaluate_rhs(evaluation_context const& context) const {
+ auto const value = m_rhs.evaluate_output(context);
+ auto const bits = context.bits_override.value_or(m_rhs.bits().value_or(0));
+ return (context.truncate && bits) ? this->truncate_input(0, value, bits) : value;
+}
+
+nary_operation::nary_operation(result_key key)
+ : abstract_operation(std::move(key)) {}
+
+void nary_operation::connect(std::vector<signal_source> inputs) {
+ m_inputs = std::move(inputs);
+}
+
+span<signal_source const> nary_operation::inputs() const noexcept {
+ return m_inputs;
+}
+
+std::vector<number> nary_operation::evaluate_inputs(evaluation_context const& context) const {
+ auto values = std::vector<number>{};
+ values.reserve(m_inputs.size());
+ for (auto const& input : m_inputs) {
+ auto const value = input.evaluate_output(context);
+ auto const bits = context.bits_override.value_or(input.bits().value_or(0));
+ values.push_back((context.truncate && bits) ? this->truncate_input(0, value, bits) : value);
+ }
+ return values;
+}
+
+} // namespace asic
\ No newline at end of file
diff --git a/legacy/simulation_oop/operation.h b/legacy/simulation_oop/operation.h
new file mode 100644
index 0000000000000000000000000000000000000000..344eacc1482c40021b3d0ff686cbef5c71085f58
--- /dev/null
+++ b/legacy/simulation_oop/operation.h
@@ -0,0 +1,132 @@
+#ifndef ASIC_SIMULATION_OPERATION_H
+#define ASIC_SIMULATION_OPERATION_H
+
+#include "../number.h"
+#include "../span.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <fmt/format.h>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace asic {
+
+class operation;
+class signal_source;
+
+using result_key = std::string;
+using result_map = std::unordered_map<result_key, std::optional<number>>;
+using delay_map = std::unordered_map<result_key, number>;
+using delay_queue = std::vector<std::pair<result_key, signal_source const*>>;
+
+struct evaluation_context final {
+ result_map* results;
+ delay_map* delays;
+ delay_queue* deferred_delays;
+ std::optional<std::size_t> bits_override;
+ bool truncate;
+};
+
+class signal_source final {
+public:
+ signal_source() noexcept = default;
+ signal_source(std::shared_ptr<const operation> op, std::size_t index, std::optional<std::size_t> bits);
+
+ [[nodiscard]] explicit operator bool() const noexcept;
+
+ [[nodiscard]] std::optional<number> current_output(delay_map const& delays) const;
+ [[nodiscard]] number evaluate_output(evaluation_context const& context) const;
+
+ [[nodiscard]] std::optional<std::size_t> bits() const noexcept;
+
+private:
+ std::shared_ptr<const operation> m_operation;
+ std::size_t m_index = 0;
+ std::optional<std::size_t> m_bits;
+};
+
+class operation {
+public:
+ virtual ~operation() = default;
+ [[nodiscard]] virtual std::size_t output_count() const noexcept = 0;
+ [[nodiscard]] virtual std::optional<number> current_output(std::size_t index, delay_map const& delays) const = 0;
+ [[nodiscard]] virtual number evaluate_output(std::size_t index, evaluation_context const& context) const = 0;
+};
+
+class abstract_operation : public operation {
+public:
+ explicit abstract_operation(result_key key);
+ virtual ~abstract_operation() = default;
+
+ [[nodiscard]] std::optional<number> current_output(std::size_t, delay_map const&) const override;
+ [[nodiscard]] number evaluate_output(std::size_t index, evaluation_context const& context) const override;
+
+protected:
+ [[nodiscard]] virtual number evaluate_output_impl(std::size_t index, evaluation_context const& context) const = 0;
+ [[nodiscard]] virtual number truncate_input(std::size_t index, number value, std::size_t bits) const;
+
+ [[nodiscard]] result_key const& key_base() const;
+ [[nodiscard]] result_key key_of_output(std::size_t index) const;
+
+private:
+ result_key m_key;
+};
+
+class unary_operation : public abstract_operation {
+public:
+ explicit unary_operation(result_key key);
+ virtual ~unary_operation() = default;
+
+ void connect(signal_source in);
+
+protected:
+ [[nodiscard]] bool connected() const noexcept;
+ [[nodiscard]] signal_source const& input() const noexcept;
+ [[nodiscard]] number evaluate_input(evaluation_context const& context) const;
+
+private:
+ signal_source m_in;
+};
+
+class binary_operation : public abstract_operation {
+public:
+ explicit binary_operation(result_key key);
+ virtual ~binary_operation() = default;
+
+ void connect(signal_source lhs, signal_source rhs);
+
+protected:
+ [[nodiscard]] signal_source const& lhs() const noexcept;
+ [[nodiscard]] signal_source const& rhs() const noexcept;
+ [[nodiscard]] number evaluate_lhs(evaluation_context const& context) const;
+ [[nodiscard]] number evaluate_rhs(evaluation_context const& context) const;
+
+private:
+ signal_source m_lhs;
+ signal_source m_rhs;
+};
+
+class nary_operation : public abstract_operation {
+public:
+ explicit nary_operation(result_key key);
+ virtual ~nary_operation() = default;
+
+ void connect(std::vector<signal_source> inputs);
+
+protected:
+ [[nodiscard]] span<signal_source const> inputs() const noexcept;
+ [[nodiscard]] std::vector<number> evaluate_inputs(evaluation_context const& context) const;
+
+private:
+ std::vector<signal_source> m_inputs;
+};
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_OPERATION_H
\ No newline at end of file
diff --git a/legacy/simulation_oop/signal_flow_graph.cpp b/legacy/simulation_oop/signal_flow_graph.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c3763c81e8f97f22caf42a47d88c1186b9a874d
--- /dev/null
+++ b/legacy/simulation_oop/signal_flow_graph.cpp
@@ -0,0 +1,144 @@
+#include "signal_flow_graph.h"
+
+#include "../debug.h"
+
+namespace py = pybind11;
+
+namespace asic {
+
+signal_flow_graph_operation::signal_flow_graph_operation(result_key key)
+ : abstract_operation(std::move(key)) {}
+
+void signal_flow_graph_operation::create(pybind11::handle sfg, added_operation_cache& added) {
+ ASIC_DEBUG_MSG("Creating SFG.");
+ for (auto const& [i, op] : enumerate(sfg.attr("output_operations"))) {
+ ASIC_DEBUG_MSG("Adding output op.");
+ m_output_operations.emplace_back(this->key_of_output(i)).connect(make_source(op, 0, added, this->key_base()));
+ }
+ for (auto const& op : sfg.attr("input_operations")) {
+ ASIC_DEBUG_MSG("Adding input op.");
+ if (!m_input_operations.emplace_back(std::dynamic_pointer_cast<input_operation>(make_operation(op, added, this->key_base())))) {
+ throw py::value_error{"Invalid input operation in SFG."};
+ }
+ }
+}
+
+std::vector<std::shared_ptr<input_operation>> const& signal_flow_graph_operation::inputs() noexcept {
+ return m_input_operations;
+}
+
+std::size_t signal_flow_graph_operation::output_count() const noexcept {
+ return m_output_operations.size();
+}
+
+number signal_flow_graph_operation::evaluate_output(std::size_t index, evaluation_context const& context) const {
+ ASIC_DEBUG_MSG("Evaluating SFG.");
+ return m_output_operations.at(index).evaluate_output(0, context);
+}
+
+number signal_flow_graph_operation::evaluate_output_impl(std::size_t, evaluation_context const&) const {
+ return number{};
+}
+
+signal_source signal_flow_graph_operation::make_source(pybind11::handle op, std::size_t input_index, added_operation_cache& added,
+ std::string_view prefix) {
+ auto const signal = py::object{op.attr("inputs")[py::int_{input_index}].attr("signals")[py::int_{0}]};
+ auto const src = py::handle{signal.attr("source")};
+ auto const operation = py::handle{src.attr("operation")};
+ auto const index = src.attr("index").cast<std::size_t>();
+ auto bits = std::optional<std::size_t>{};
+ if (!signal.attr("bits").is_none()) {
+ bits = signal.attr("bits").cast<std::size_t>();
+ }
+ return signal_source{make_operation(operation, added, prefix), index, bits};
+}
+
+std::shared_ptr<operation> signal_flow_graph_operation::add_signal_flow_graph_operation(pybind11::handle sfg, added_operation_cache& added,
+ std::string_view prefix, result_key key) {
+ auto const new_op = add_operation<signal_flow_graph_operation>(sfg, added, std::move(key));
+ new_op->create(sfg, added);
+ for (auto&& [i, input] : enumerate(new_op->inputs())) {
+ input->connect(make_source(sfg, i, added, prefix));
+ }
+ return new_op;
+}
+
+std::shared_ptr<custom_operation> signal_flow_graph_operation::add_custom_operation(pybind11::handle op, added_operation_cache& added,
+ std::string_view prefix, result_key key) {
+ auto const input_count = op.attr("input_count").cast<std::size_t>();
+ auto const output_count = op.attr("output_count").cast<std::size_t>();
+ auto const new_op = add_operation<custom_operation>(
+ op, added, key, op.attr("evaluate_output"), op.attr("truncate_input"), output_count);
+ auto inputs = std::vector<signal_source>{};
+ inputs.reserve(input_count);
+ for (auto const i : range(input_count)) {
+ inputs.push_back(make_source(op, i, added, prefix));
+ }
+ new_op->connect(std::move(inputs));
+ return new_op;
+}
+
+std::shared_ptr<operation> signal_flow_graph_operation::make_operation(pybind11::handle op, added_operation_cache& added,
+ std::string_view prefix) {
+ if (auto const it = added.find(op.ptr()); it != added.end()) {
+ ASIC_ASSERT(it->second);
+ return it->second;
+ }
+ auto const graph_id = op.attr("graph_id").cast<std::string_view>();
+ auto const type_name = op.attr("type_name")().cast<std::string_view>();
+ auto key = (prefix.empty()) ? result_key{graph_id} : fmt::format("{}.{}", prefix, graph_id);
+ if (type_name == "c") {
+ auto const value = op.attr("value").cast<number>();
+ return add_operation<constant_operation>(op, added, std::move(key), value);
+ }
+ if (type_name == "add") {
+ return add_binary_operation<addition_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "sub") {
+ return add_binary_operation<subtraction_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "mul") {
+ return add_binary_operation<multiplication_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "div") {
+ return add_binary_operation<division_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "min") {
+ return add_binary_operation<min_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "max") {
+ return add_binary_operation<max_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "sqrt") {
+ return add_unary_operation<square_root_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "conj") {
+ return add_unary_operation<complex_conjugate_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "abs") {
+ return add_unary_operation<absolute_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "cmul") {
+ auto const value = op.attr("value").cast<number>();
+ return add_unary_operation<constant_multiplication_operation>(op, added, prefix, std::move(key), value);
+ }
+ if (type_name == "bfly") {
+ return add_binary_operation<butterfly_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "in") {
+ return add_operation<input_operation>(op, added, std::move(key));
+ }
+ if (type_name == "out") {
+ return add_unary_operation<output_operation>(op, added, prefix, std::move(key));
+ }
+ if (type_name == "t") {
+ auto const initial_value = op.attr("initial_value").cast<number>();
+ return add_unary_operation<delay_operation>(op, added, prefix, std::move(key), initial_value);
+ }
+ if (type_name == "sfg") {
+ return add_signal_flow_graph_operation(op, added, prefix, std::move(key));
+ }
+ return add_custom_operation(op, added, prefix, std::move(key));
+}
+
+} // namespace asic
\ No newline at end of file
diff --git a/legacy/simulation_oop/signal_flow_graph.h b/legacy/simulation_oop/signal_flow_graph.h
new file mode 100644
index 0000000000000000000000000000000000000000..f06788249e367d3e8e0602f04c6dcf91c71b7a96
--- /dev/null
+++ b/legacy/simulation_oop/signal_flow_graph.h
@@ -0,0 +1,82 @@
+#ifndef ASIC_SIMULATION_SIGNAL_FLOW_GRAPH_H
+#define ASIC_SIMULATION_SIGNAL_FLOW_GRAPH_H
+
+#include "../algorithm.h"
+#include "../debug.h"
+#include "../number.h"
+#include "core_operations.h"
+#include "custom_operation.h"
+#include "operation.h"
+#include "special_operations.h"
+
+#include <Python.h>
+#include <cstddef>
+#include <fmt/format.h>
+#include <functional>
+#include <memory>
+#include <pybind11/pybind11.h>
+#include <stdexcept>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace asic {
+
+class signal_flow_graph_operation final : public abstract_operation {
+public:
+ using added_operation_cache = std::unordered_map<PyObject const*, std::shared_ptr<operation>>;
+
+ signal_flow_graph_operation(result_key key);
+
+ void create(pybind11::handle sfg, added_operation_cache& added);
+
+ [[nodiscard]] std::vector<std::shared_ptr<input_operation>> const& inputs() noexcept;
+ [[nodiscard]] std::size_t output_count() const noexcept final;
+
+ [[nodiscard]] number evaluate_output(std::size_t index, evaluation_context const& context) const final;
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t index, evaluation_context const& context) const final;
+
+ [[nodiscard]] static signal_source make_source(pybind11::handle op, std::size_t input_index, added_operation_cache& added,
+ std::string_view prefix);
+
+ template <typename Operation, typename... Args>
+ [[nodiscard]] static std::shared_ptr<Operation> add_operation(pybind11::handle op, added_operation_cache& added, Args&&... args) {
+ return std::static_pointer_cast<Operation>(
+ added.try_emplace(op.ptr(), std::make_shared<Operation>(std::forward<Args>(args)...)).first->second);
+ }
+
+ template <typename Operation, typename... Args>
+ [[nodiscard]] static std::shared_ptr<Operation> add_unary_operation(pybind11::handle op, added_operation_cache& added,
+ std::string_view prefix, Args&&... args) {
+ auto const new_op = add_operation<Operation>(op, added, std::forward<Args>(args)...);
+ new_op->connect(make_source(op, 0, added, prefix));
+ return new_op;
+ }
+
+ template <typename Operation, typename... Args>
+ [[nodiscard]] static std::shared_ptr<Operation> add_binary_operation(pybind11::handle op, added_operation_cache& added,
+ std::string_view prefix, Args&&... args) {
+ auto const new_op = add_operation<Operation>(op, added, std::forward<Args>(args)...);
+ new_op->connect(make_source(op, 0, added, prefix), make_source(op, 1, added, prefix));
+ return new_op;
+ }
+
+ [[nodiscard]] static std::shared_ptr<operation> add_signal_flow_graph_operation(pybind11::handle sfg, added_operation_cache& added,
+ std::string_view prefix, result_key key);
+
+ [[nodiscard]] static std::shared_ptr<custom_operation> add_custom_operation(pybind11::handle op, added_operation_cache& added,
+ std::string_view prefix, result_key key);
+
+ [[nodiscard]] static std::shared_ptr<operation> make_operation(pybind11::handle op, added_operation_cache& added,
+ std::string_view prefix);
+
+ std::vector<output_operation> m_output_operations;
+ std::vector<std::shared_ptr<input_operation>> m_input_operations;
+};
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_SIGNAL_FLOW_GRAPH_H
\ No newline at end of file
diff --git a/legacy/simulation_oop/simulation.cpp b/legacy/simulation_oop/simulation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4d6ff83337a6dade0a0d476e5942ee3b14178195
--- /dev/null
+++ b/legacy/simulation_oop/simulation.cpp
@@ -0,0 +1,138 @@
+#define NOMINMAX
+#include "simulation.h"
+
+#include "../debug.h"
+
+namespace py = pybind11;
+
+namespace asic {
+
+simulation::simulation(pybind11::handle sfg, std::optional<std::vector<std::optional<input_provider_t>>> input_providers)
+ : m_sfg("")
+ , m_input_functions(sfg.attr("input_count").cast<std::size_t>(), [](iteration_t) -> number { return number{}; }) {
+ if (input_providers) {
+ this->set_inputs(std::move(*input_providers));
+ }
+ auto added = signal_flow_graph_operation::added_operation_cache{};
+ m_sfg.create(sfg, added);
+}
+
+void simulation::set_input(std::size_t index, input_provider_t input_provider) {
+ if (index >= m_input_functions.size()) {
+ throw py::index_error{fmt::format("Input index out of range (expected 0-{}, got {})", m_input_functions.size() - 1, index)};
+ }
+ if (auto* const callable = std::get_if<input_function_t>(&input_provider)) {
+ m_input_functions[index] = std::move(*callable);
+ } else if (auto* const numeric = std::get_if<number>(&input_provider)) {
+ m_input_functions[index] = [value = *numeric](iteration_t) -> number {
+ return value;
+ };
+ } else if (auto* const list = std::get_if<std::vector<number>>(&input_provider)) {
+ if (!m_input_length) {
+ m_input_length = static_cast<iteration_t>(list->size());
+ } else if (*m_input_length != static_cast<iteration_t>(list->size())) {
+ throw py::value_error{fmt::format("Inconsistent input length for simulation (was {}, got {})", *m_input_length, list->size())};
+ }
+ m_input_functions[index] = [values = std::move(*list)](iteration_t n) -> number {
+ return values.at(n);
+ };
+ }
+}
+
+void simulation::set_inputs(std::vector<std::optional<input_provider_t>> input_providers) {
+ if (input_providers.size() != m_input_functions.size()) {
+ throw py::value_error{fmt::format(
+ "Wrong number of inputs supplied to simulation (expected {}, got {})", m_input_functions.size(), input_providers.size())};
+ }
+ for (auto&& [i, input_provider] : enumerate(input_providers)) {
+ if (input_provider) {
+ this->set_input(i, std::move(*input_provider));
+ }
+ }
+}
+
+std::vector<number> simulation::step(bool save_results, std::optional<std::size_t> bits_override, bool truncate) {
+ return this->run_for(1, save_results, bits_override, truncate);
+}
+
+std::vector<number> simulation::run_until(iteration_t iteration, bool save_results, std::optional<std::size_t> bits_override,
+ bool truncate) {
+ auto result = std::vector<number>{};
+ while (m_iteration < iteration) {
+ ASIC_DEBUG_MSG("Running simulation iteration.");
+ for (auto&& [input, function] : zip(m_sfg.inputs(), m_input_functions)) {
+ input->value(function(m_iteration));
+ }
+
+ result.clear();
+ result.reserve(m_sfg.output_count());
+
+ auto results = result_map{};
+ auto deferred_delays = delay_queue{};
+ auto context = evaluation_context{};
+ context.results = &results;
+ context.delays = &m_delays;
+ context.deferred_delays = &deferred_delays;
+ context.bits_override = bits_override;
+ context.truncate = truncate;
+
+ for (auto const i : range(m_sfg.output_count())) {
+ result.push_back(m_sfg.evaluate_output(i, context));
+ }
+
+ while (!deferred_delays.empty()) {
+ auto new_deferred_delays = delay_queue{};
+ context.deferred_delays = &new_deferred_delays;
+ for (auto const& [key, src] : deferred_delays) {
+ ASIC_ASSERT(src);
+ m_delays[key] = src->evaluate_output(context);
+ }
+ deferred_delays = std::move(new_deferred_delays);
+ }
+
+ if (save_results) {
+ for (auto const& [key, value] : results) {
+ m_results[key].push_back(value.value());
+ }
+ }
+ ++m_iteration;
+ }
+ return result;
+}
+
+std::vector<number> simulation::run_for(iteration_t iterations, bool save_results, std::optional<std::size_t> bits_override,
+ bool truncate) {
+ if (iterations > std::numeric_limits<iteration_t>::max() - m_iteration) {
+ throw py::value_error("Simulation iteration type overflow!");
+ }
+ return this->run_until(m_iteration + iterations, save_results, bits_override, truncate);
+}
+
+std::vector<number> simulation::run(bool save_results, std::optional<std::size_t> bits_override, bool truncate) {
+ if (m_input_length) {
+ return this->run_until(*m_input_length, save_results, bits_override, truncate);
+ }
+ throw py::index_error{"Tried to run unlimited simulation"};
+}
+
+iteration_t simulation::iteration() const noexcept {
+ return m_iteration;
+}
+
+pybind11::dict simulation::results() const noexcept {
+ auto results = py::dict{};
+ for (auto const& [key, values] : m_results) {
+ results[py::str{key}] = py::array{static_cast<py::ssize_t>(values.size()), values.data()};
+ }
+ return results;
+}
+
+void simulation::clear_results() noexcept {
+ m_results.clear();
+}
+
+void simulation::clear_state() noexcept {
+ m_delays.clear();
+}
+
+} // namespace asic
diff --git a/legacy/simulation_oop/simulation.h b/legacy/simulation_oop/simulation.h
new file mode 100644
index 0000000000000000000000000000000000000000..38e2771b877772bd28048cae16d791bb4e0b45e3
--- /dev/null
+++ b/legacy/simulation_oop/simulation.h
@@ -0,0 +1,66 @@
+#ifndef ASIC_SIMULATION_OOP_H
+#define ASIC_SIMULATION_OOP_H
+
+#include "../number.h"
+#include "core_operations.h"
+#include "custom_operation.h"
+#include "operation.h"
+#include "signal_flow_graph.h"
+#include "special_operations.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <fmt/format.h>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <pybind11/functional.h>
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+#include <vector>
+
+namespace asic {
+
+using iteration_t = std::uint32_t;
+using result_array_map = std::unordered_map<std::string, std::vector<number>>;
+using input_function_t = std::function<number(iteration_t)>;
+using input_provider_t = std::variant<number, std::vector<number>, input_function_t>;
+
+class simulation final {
+public:
+ simulation(pybind11::handle sfg, std::optional<std::vector<std::optional<input_provider_t>>> input_providers = std::nullopt);
+
+ void set_input(std::size_t index, input_provider_t input_provider);
+ void set_inputs(std::vector<std::optional<input_provider_t>> input_providers);
+
+ [[nodiscard]] std::vector<number> step(bool save_results, std::optional<std::size_t> bits_override, bool truncate);
+ [[nodiscard]] std::vector<number> run_until(iteration_t iteration, bool save_results, std::optional<std::size_t> bits_override,
+ bool truncate);
+ [[nodiscard]] std::vector<number> run_for(iteration_t iterations, bool save_results, std::optional<std::size_t> bits_override,
+ bool truncate);
+ [[nodiscard]] std::vector<number> run(bool save_results, std::optional<std::size_t> bits_override, bool truncate);
+
+ [[nodiscard]] iteration_t iteration() const noexcept;
+ [[nodiscard]] pybind11::dict results() const noexcept;
+
+ void clear_results() noexcept;
+ void clear_state() noexcept;
+
+private:
+ signal_flow_graph_operation m_sfg;
+ result_array_map m_results;
+ delay_map m_delays;
+ iteration_t m_iteration = 0;
+ std::vector<input_function_t> m_input_functions;
+ std::optional<iteration_t> m_input_length;
+};
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_OOP_H
\ No newline at end of file
diff --git a/legacy/simulation_oop/special_operations.cpp b/legacy/simulation_oop/special_operations.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1f7a6519a90ba08224585e36093694becf495c4d
--- /dev/null
+++ b/legacy/simulation_oop/special_operations.cpp
@@ -0,0 +1,78 @@
+#include "special_operations.h"
+
+#include "../debug.h"
+
+namespace asic {
+
+input_operation::input_operation(result_key key)
+ : unary_operation(std::move(key)) {}
+
+std::size_t input_operation::output_count() const noexcept {
+ return 1;
+}
+
+number input_operation::value() const noexcept {
+ return m_value;
+}
+
+void input_operation::value(number value) noexcept {
+ m_value = value;
+}
+
+number input_operation::evaluate_output_impl(std::size_t, evaluation_context const& context) const {
+ ASIC_DEBUG_MSG("Evaluating input.");
+ if (this->connected()) {
+ return this->evaluate_input(context);
+ }
+ return m_value;
+}
+
+output_operation::output_operation(result_key key)
+ : unary_operation(std::move(key)) {}
+
+std::size_t output_operation::output_count() const noexcept {
+ return 1;
+}
+
+number output_operation::evaluate_output_impl(std::size_t, evaluation_context const& context) const {
+ ASIC_DEBUG_MSG("Evaluating output.");
+ return this->evaluate_input(context);
+}
+
+delay_operation::delay_operation(result_key key, number initial_value)
+ : unary_operation(std::move(key))
+ , m_initial_value(initial_value) {}
+
+std::size_t delay_operation::output_count() const noexcept {
+ return 1;
+}
+
+std::optional<number> delay_operation::current_output(std::size_t index, delay_map const& delays) const {
+ auto const key = this->key_of_output(index);
+ if (auto const it = delays.find(key); it != delays.end()) {
+ return it->second;
+ }
+ return m_initial_value;
+}
+
+number delay_operation::evaluate_output(std::size_t index, evaluation_context const& context) const {
+ ASIC_DEBUG_MSG("Evaluating delay.");
+ ASIC_ASSERT(index == 0);
+ ASIC_ASSERT(context.results);
+ ASIC_ASSERT(context.delays);
+ ASIC_ASSERT(context.deferred_delays);
+ auto key = this->key_of_output(index);
+ auto const value = context.delays->try_emplace(key, m_initial_value).first->second;
+ auto const& [it, inserted] = context.results->try_emplace(key, value);
+ if (inserted) {
+ context.deferred_delays->emplace_back(std::move(key), &this->input());
+ return value;
+ }
+ return it->second.value();
+}
+
+[[nodiscard]] number delay_operation::evaluate_output_impl(std::size_t, evaluation_context const&) const {
+ return number{};
+}
+
+} // namespace asic
diff --git a/legacy/simulation_oop/special_operations.h b/legacy/simulation_oop/special_operations.h
new file mode 100644
index 0000000000000000000000000000000000000000..88fb087e84378e36f423364d2c7d83a083828784
--- /dev/null
+++ b/legacy/simulation_oop/special_operations.h
@@ -0,0 +1,55 @@
+#ifndef ASIC_SIMULATION_SPECIAL_OPERATIONS_H
+#define ASIC_SIMULATION_SPECIAL_OPERATIONS_H
+
+#include "../debug.h"
+#include "../number.h"
+#include "operation.h"
+
+#include <cassert>
+#include <cstddef>
+#include <utility>
+
+namespace asic {
+
+class input_operation final : public unary_operation {
+public:
+ explicit input_operation(result_key key);
+
+ [[nodiscard]] std::size_t output_count() const noexcept final;
+ [[nodiscard]] number value() const noexcept;
+ void value(number value) noexcept;
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t index, evaluation_context const& context) const final;
+
+ number m_value{};
+};
+
+class output_operation final : public unary_operation {
+public:
+ explicit output_operation(result_key key);
+
+ [[nodiscard]] std::size_t output_count() const noexcept final;
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t index, evaluation_context const& context) const final;
+};
+
+class delay_operation final : public unary_operation {
+public:
+ delay_operation(result_key key, number initial_value);
+
+ [[nodiscard]] std::size_t output_count() const noexcept final;
+
+ [[nodiscard]] std::optional<number> current_output(std::size_t index, delay_map const& delays) const final;
+ [[nodiscard]] number evaluate_output(std::size_t index, evaluation_context const& context) const final;
+
+private:
+ [[nodiscard]] number evaluate_output_impl(std::size_t index, evaluation_context const& context) const final;
+
+ number m_initial_value;
+};
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_SPECIAL_OPERATIONS_H
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 43d55d40a95212196facb973ebc97a1bdc5e7f42..0568514756180c02b81a7b323789fb72a6e5bf26 100644
--- a/setup.py
+++ b/setup.py
@@ -6,7 +6,7 @@ import setuptools
from setuptools import Extension
from setuptools.command.build_ext import build_ext
-CMAKE_EXE = os.environ.get('CMAKE_EXE', shutil.which('cmake'))
+CMAKE_EXE = os.environ.get("CMAKE_EXE", shutil.which("cmake"))
class CMakeExtension(Extension):
def __init__(self, name, sourcedir = ""):
@@ -25,6 +25,7 @@ class CMakeBuild(build_ext):
cmake_output_dir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
cmake_configure_argv = [
CMAKE_EXE, ext.sourcedir,
+ "-DASIC_BUILDING_PYTHON_DISTRIBUTION=true",
"-DCMAKE_BUILD_TYPE=" + cmake_build_type,
"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=" + cmake_output_dir,
"-DPYTHON_EXECUTABLE=" + sys.executable,
@@ -36,9 +37,9 @@ class CMakeBuild(build_ext):
if not os.path.exists(self.build_temp):
os.makedirs(self.build_temp)
-
+
env = os.environ.copy()
-
+
print(f"=== Configuring {ext.name} ===")
print(f"Temp dir: {self.build_temp}")
print(f"Output dir: {cmake_output_dir}")
@@ -71,10 +72,12 @@ setuptools.setup(
install_requires = [
"pybind11>=2.3.0",
"numpy",
- "install_qt_binding"
+ "pyside2",
+ "graphviz",
+ "matplotlib"
],
packages = ["b_asic"],
ext_modules = [CMakeExtension("b_asic")],
cmdclass = {"build_ext": CMakeBuild},
zip_safe = False
-)
\ No newline at end of file
+)
diff --git a/src/algorithm.h b/src/algorithm.h
new file mode 100644
index 0000000000000000000000000000000000000000..c86275d1c4ef09a525372d38a4c07a0beb11e8c4
--- /dev/null
+++ b/src/algorithm.h
@@ -0,0 +1,325 @@
+#ifndef ASIC_ALGORITHM_H
+#define ASIC_ALGORITHM_H
+
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace asic {
+namespace detail {
+
+template <typename Reference>
+class arrow_proxy final {
+public:
+ template <typename Ref>
+ constexpr explicit arrow_proxy(Ref&& r) : m_r(std::forward<Ref>(r)) {}
+
+ Reference* operator->() {
+ return std::addressof(m_r);
+ }
+
+private:
+ Reference m_r;
+};
+
+template <typename T>
+struct range_view final {
+ class iterator final {
+ public:
+ using difference_type = std::ptrdiff_t;
+ using value_type = T const;
+ using reference = value_type&;
+ using pointer = value_type*;
+ using iterator_category = std::random_access_iterator_tag;
+
+ constexpr iterator() noexcept = default;
+ constexpr explicit iterator(T value) noexcept : m_value(value) {}
+
+ [[nodiscard]] constexpr bool operator==(iterator const& other) const noexcept {
+ return m_value == other.m_value;
+ }
+
+ [[nodiscard]] constexpr bool operator!=(iterator const& other) const noexcept {
+ return m_value != other.m_value;
+ }
+
+ [[nodiscard]] constexpr bool operator<(iterator const& other) const noexcept {
+ return m_value < other.m_value;
+ }
+
+ [[nodiscard]] constexpr bool operator>(iterator const& other) const noexcept {
+ return m_value > other.m_value;
+ }
+
+ [[nodiscard]] constexpr bool operator<=(iterator const& other) const noexcept {
+ return m_value <= other.m_value;
+ }
+
+ [[nodiscard]] constexpr bool operator>=(iterator const& other) const noexcept {
+ return m_value >= other.m_value;
+ }
+
+ [[nodiscard]] constexpr reference operator*() const noexcept {
+ return m_value;
+ }
+
+ [[nodiscard]] constexpr pointer operator->() const noexcept {
+ return std::addressof(**this);
+ }
+
+ constexpr iterator& operator++() noexcept {
+ ++m_value;
+ return *this;
+ }
+
+ constexpr iterator operator++(int) noexcept {
+ return iterator{m_value++};
+ }
+
+ constexpr iterator& operator--() noexcept {
+ --m_value;
+ return *this;
+ }
+
+ constexpr iterator operator--(int) noexcept {
+ return iterator{m_value--};
+ }
+
+ constexpr iterator& operator+=(difference_type n) noexcept {
+ m_value += n;
+ return *this;
+ }
+
+ constexpr iterator& operator-=(difference_type n) noexcept {
+ m_value -= n;
+ return *this;
+ }
+
+ [[nodiscard]] constexpr T operator[](difference_type n) noexcept {
+ return m_value + static_cast<T>(n);
+ }
+
+ [[nodiscard]] constexpr friend iterator operator+(iterator const& lhs, difference_type rhs) noexcept {
+ return iterator{lhs.m_value + rhs};
+ }
+
+ [[nodiscard]] constexpr friend iterator operator+(difference_type lhs, iterator const& rhs) noexcept {
+ return iterator{lhs + rhs.m_value};
+ }
+
+ [[nodiscard]] constexpr friend iterator operator-(iterator const& lhs, difference_type rhs) noexcept {
+ return iterator{lhs.m_value - rhs};
+ }
+
+ [[nodiscard]] constexpr friend difference_type operator-(iterator const& lhs, iterator const& rhs) noexcept {
+ return static_cast<difference_type>(lhs.m_value - rhs.m_value);
+ }
+
+ private:
+ T m_value{};
+ };
+
+ using sentinel = iterator;
+
+ template <typename First, typename Last>
+ constexpr range_view(First&& first, Last&& last) noexcept : m_begin(std::forward<First>(first)), m_end(std::forward<Last>(last)) {}
+
+ [[nodiscard]] constexpr iterator begin() const noexcept {
+ return m_begin;
+ }
+ [[nodiscard]] constexpr sentinel end() const noexcept {
+ return m_end;
+ }
+
+ iterator m_begin;
+ sentinel m_end;
+};
+
+template <typename Range, typename Iterator, typename Sentinel>
+struct enumerate_view final {
+ using sentinel = Sentinel;
+
+ class iterator final {
+ public:
+ using difference_type = typename std::iterator_traits<Iterator>::difference_type;
+ using value_type = typename std::iterator_traits<Iterator>::value_type;
+ using reference = std::pair<std::size_t const&, decltype(*std::declval<Iterator const>())>;
+ using pointer = arrow_proxy<reference>;
+ using iterator_category =
+ std::common_type_t<typename std::iterator_traits<Iterator>::iterator_category, std::bidirectional_iterator_tag>;
+
+ constexpr iterator() = default;
+
+ constexpr iterator(Iterator it, std::size_t index) : m_it(std::move(it)), m_index(index) {}
+
+ [[nodiscard]] constexpr bool operator==(iterator const& other) const {
+ return m_it == other.m_it;
+ }
+
+ [[nodiscard]] constexpr bool operator!=(iterator const& other) const {
+ return m_it != other.m_it;
+ }
+
+ [[nodiscard]] constexpr bool operator==(sentinel const& other) const {
+ return m_it == other;
+ }
+
+ [[nodiscard]] constexpr bool operator!=(sentinel const& other) const {
+ return m_it != other;
+ }
+
+ [[nodiscard]] constexpr reference operator*() const {
+ return reference{m_index, *m_it};
+ }
+
+ [[nodiscard]] constexpr pointer operator->() const {
+ return pointer{**this};
+ }
+
+ constexpr iterator& operator++() {
+ ++m_it;
+ ++m_index;
+ return *this;
+ }
+
+ constexpr iterator operator++(int) {
+ return iterator{m_it++, m_index++};
+ }
+
+ constexpr iterator& operator--() {
+ --m_it;
+ --m_index;
+ return *this;
+ }
+
+ constexpr iterator operator--(int) {
+ return iterator{m_it--, m_index--};
+ }
+
+ private:
+ Iterator m_it;
+ std::size_t m_index = 0;
+ };
+
+ constexpr iterator begin() const {
+ return iterator{std::begin(m_range), 0};
+ }
+
+ constexpr sentinel end() const {
+ return std::end(m_range);
+ }
+
+ Range m_range;
+};
+
+template <typename Range1, typename Range2, typename Iterator1, typename Iterator2, typename Sentinel1, typename Sentinel2>
+struct zip_view final {
+ using sentinel = std::pair<Sentinel1, Sentinel2>;
+
+ class iterator final {
+ public:
+ using difference_type = std::common_type_t<typename std::iterator_traits<Iterator1>::difference_type,
+ typename std::iterator_traits<Iterator2>::difference_type>;
+ using value_type =
+ std::pair<typename std::iterator_traits<Iterator1>::value_type, typename std::iterator_traits<Iterator2>::value_type>;
+ using reference = std::pair<decltype(*std::declval<Iterator1 const>()), decltype(*std::declval<Iterator2 const>())>;
+ using pointer = arrow_proxy<reference>;
+ using iterator_category = std::common_type_t<typename std::iterator_traits<Iterator1>::iterator_category,
+ typename std::iterator_traits<Iterator2>::iterator_category, std::bidirectional_iterator_tag>;
+
+ constexpr iterator() = default;
+
+ constexpr iterator(Iterator1 it1, Iterator2 it2) : m_it1(std::move(it1)), m_it2(std::move(it2)) {}
+
+ [[nodiscard]] constexpr bool operator==(iterator const& other) const {
+ return m_it1 == other.m_it1 && m_it2 == other.m_it2;
+ }
+
+ [[nodiscard]] constexpr bool operator!=(iterator const& other) const {
+ return !(*this == other);
+ }
+
+ [[nodiscard]] constexpr bool operator==(sentinel const& other) const {
+ return m_it1 == other.first || m_it2 == other.second;
+ }
+
+ [[nodiscard]] constexpr bool operator!=(sentinel const& other) const {
+ return !(*this == other);
+ }
+
+ [[nodiscard]] constexpr reference operator*() const {
+ return reference{*m_it1, *m_it2};
+ }
+
+ [[nodiscard]] constexpr pointer operator->() const {
+ return pointer{**this};
+ }
+
+ constexpr iterator& operator++() {
+ ++m_it1;
+ ++m_it2;
+ return *this;
+ }
+
+ constexpr iterator operator++(int) {
+ return iterator{m_it1++, m_it2++};
+ }
+
+ constexpr iterator& operator--() {
+ --m_it1;
+ --m_it2;
+ return *this;
+ }
+
+ constexpr iterator operator--(int) {
+ return iterator{m_it1--, m_it2--};
+ }
+
+ private:
+ Iterator1 m_it1;
+ Iterator2 m_it2;
+ };
+
+ constexpr iterator begin() const {
+ return iterator{std::begin(m_range1), std::begin(m_range2)};
+ }
+
+ constexpr sentinel end() const {
+ return sentinel{std::end(m_range1), std::end(m_range2)};
+ }
+
+ Range1 m_range1;
+ Range2 m_range2;
+};
+
+} // namespace detail
+
+template <typename First, typename Last, typename T = std::remove_cv_t<std::remove_reference_t<First>>>
+[[nodiscard]] constexpr auto range(First&& first, Last&& last) {
+ return detail::range_view<T>{std::forward<First>(first), std::forward<Last>(last)};
+}
+
+template <typename Last, typename T = std::remove_cv_t<std::remove_reference_t<Last>>>
+[[nodiscard]] constexpr auto range(Last&& last) {
+ return detail::range_view<T>{T{}, std::forward<Last>(last)};
+}
+
+template <typename Range, typename Iterator = decltype(std::begin(std::declval<Range>())),
+ typename Sentinel = decltype(std::end(std::declval<Range>()))>
+[[nodiscard]] constexpr auto enumerate(Range&& range) {
+ return detail::enumerate_view<Range, Iterator, Sentinel>{std::forward<Range>(range)};
+}
+
+template <typename Range1, typename Range2, typename Iterator1 = decltype(std::begin(std::declval<Range1>())),
+ typename Iterator2 = decltype(std::begin(std::declval<Range2>())), typename Sentinel1 = decltype(std::end(std::declval<Range1>())),
+ typename Sentinel2 = decltype(std::end(std::declval<Range2>()))>
+[[nodiscard]] constexpr auto zip(Range1&& range1, Range2&& range2) {
+ return detail::zip_view<Range1, Range2, Iterator1, Iterator2, Sentinel1, Sentinel2>{
+ std::forward<Range1>(range1), std::forward<Range2>(range2)};
+}
+
+} // namespace asic
+
+#endif // ASIC_ALGORITHM_H
\ No newline at end of file
diff --git a/src/debug.h b/src/debug.h
new file mode 100644
index 0000000000000000000000000000000000000000..a11aa057db644dbe2d29399398a1f48ca599876f
--- /dev/null
+++ b/src/debug.h
@@ -0,0 +1,80 @@
+#ifndef ASIC_DEBUG_H
+#define ASIC_DEBUG_H
+
+#ifndef NDEBUG
+#define ASIC_ENABLE_DEBUG_LOGGING 1
+#define ASIC_ENABLE_ASSERTS 1
+#else
+#define ASIC_ENABLE_DEBUG_LOGGING 0
+#define ASIC_ENABLE_ASSERTS 0
+#endif // NDEBUG
+
+#if ASIC_ENABLE_DEBUG_LOGGING
+#include <filesystem>
+#include <fmt/format.h>
+#include <fstream>
+#include <ostream>
+#include <string_view>
+#include <utility>
+#endif // ASIC_ENABLE_DEBUG_LOGGING
+
+#if ASIC_ENABLE_ASSERTS
+#include <filesystem>
+#include <cstdlib>
+#include <cstdio>
+#include <string_view>
+#include <fmt/format.h>
+#endif // ASIC_ENABLE_ASSERTS
+
+namespace asic {
+
+constexpr auto debug_log_filename = "_b_asic_debug_log.txt";
+
+namespace detail {
+
+#if ASIC_ENABLE_DEBUG_LOGGING
+inline void log_debug_msg_string(std::string_view file, int line, std::string_view string) {
+ static auto log_file = std::ofstream{debug_log_filename, std::ios::trunc};
+ log_file << fmt::format("{:<40}: {}", fmt::format("{}:{}", std::filesystem::path{file}.filename().generic_string(), line), string)
+ << std::endl;
+}
+
+template <typename Format, typename... Args>
+inline void log_debug_msg(std::string_view file, int line, Format&& format, Args&&... args) {
+ log_debug_msg_string(file, line, fmt::format(std::forward<Format>(format), std::forward<Args>(args)...));
+}
+#endif // ASIC_ENABLE_DEBUG_LOGGING
+
+#if ASIC_ENABLE_ASSERTS
+inline void fail_assert(std::string_view file, int line, std::string_view condition_string) {
+#if ASIC_ENABLE_DEBUG_LOGGING
+ log_debug_msg(file, line, "Assertion failed: {}", condition_string);
+#endif // ASIC_ENABLE_DEBUG_LOGGING
+ fmt::print(stderr, "{}:{}: Assertion failed: {}\n", std::filesystem::path{file}.filename().generic_string(), line, condition_string);
+ std::abort();
+}
+
+template <typename BoolConvertible>
+inline void check_assert(std::string_view file, int line, std::string_view condition_string, BoolConvertible&& condition) {
+ if (!static_cast<bool>(condition)) {
+ fail_assert(file, line, condition_string);
+ }
+}
+#endif // ASIC_ENABLE_ASSERTS
+
+} // namespace detail
+} // namespace asic
+
+#if ASIC_ENABLE_DEBUG_LOGGING
+#define ASIC_DEBUG_MSG(...) (asic::detail::log_debug_msg(__FILE__, __LINE__, __VA_ARGS__))
+#else
+#define ASIC_DEBUG_MSG(...) ((void)0)
+#endif // ASIC_ENABLE_DEBUG_LOGGING
+
+#if ASIC_ENABLE_ASSERTS
+#define ASIC_ASSERT(condition) (asic::detail::check_assert(__FILE__, __LINE__, #condition, (condition)))
+#else
+#define ASIC_ASSERT(condition) ((void)0)
+#endif
+
+#endif // ASIC_DEBUG_H
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index bc4e83c69e7d331bbacfa37d8b22baec35833682..f5c4be532aa47468592e2e2f008308d1724e41b8 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,21 +1,9 @@
+#include "simulation.h"
#include <pybind11/pybind11.h>
namespace py = pybind11;
-namespace asic {
-
-int add(int a, int b) {
- return a + b;
-}
-
-int sub(int a, int b) {
- return a - b;
-}
-
-} // namespace asic
-
-PYBIND11_MODULE(_b_asic, m) {
- m.doc() = "Better ASIC Toolbox Extension Module.";
- m.def("add", &asic::add, "A function which adds two numbers.", py::arg("a"), py::arg("b"));
- m.def("sub", &asic::sub, "A function which subtracts two numbers.", py::arg("a"), py::arg("b"));
+PYBIND11_MODULE(_b_asic, module) {
+ module.doc() = "Better ASIC Toolbox Extension Module.";
+ asic::define_simulation_class(module);
}
\ No newline at end of file
diff --git a/src/number.h b/src/number.h
new file mode 100644
index 0000000000000000000000000000000000000000..9cb5b42f53be4eb0cfcc86d00be65005147384e2
--- /dev/null
+++ b/src/number.h
@@ -0,0 +1,13 @@
+#ifndef ASIC_NUMBER_H
+#define ASIC_NUMBER_H
+
+#include <complex>
+#include <pybind11/complex.h>
+
+namespace asic {
+
+using number = std::complex<double>;
+
+} // namespace asic
+
+#endif // ASIC_NUMBER_H
\ No newline at end of file
diff --git a/src/simulation.cpp b/src/simulation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..33280f604be77614f7eadf1ad40d868177dd6e95
--- /dev/null
+++ b/src/simulation.cpp
@@ -0,0 +1,61 @@
+#include "simulation.h"
+#include "simulation/simulation.h"
+
+namespace py = pybind11;
+
+namespace asic {
+
+void define_simulation_class(pybind11::module& module) {
+ // clang-format off
+ py::class_<simulation>(module, "FastSimulation")
+ .def(py::init<py::handle>(),
+ py::arg("sfg"),
+ "SFG Constructor.")
+
+ .def(py::init<py::handle, std::optional<std::vector<std::optional<input_provider_t>>>>(),
+ py::arg("sfg"), py::arg("input_providers"),
+ "SFG Constructor.")
+
+ .def("set_input", &simulation::set_input,
+ py::arg("index"), py::arg("input_provider"),
+ "Set the input function used to get values for the specific input at the given index to the internal SFG.")
+
+ .def("set_inputs", &simulation::set_inputs,
+ py::arg("input_providers"),
+ "Set the input functions used to get values for the inputs to the internal SFG.")
+
+ .def("step", &simulation::step,
+ py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("truncate") = true,
+ "Run one iteration of the simulation and return the resulting output values.")
+
+ .def("run_until", &simulation::run_until,
+ py::arg("iteration"), py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("truncate") = true,
+ "Run the simulation until its iteration is greater than or equal to the given iteration\n"
+ "and return the output values of the last iteration.")
+
+ .def("run_for", &simulation::run_for,
+ py::arg("iterations"), py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("truncate") = true,
+ "Run a given number of iterations of the simulation and return the output values of the last iteration.")
+
+ .def("run", &simulation::run,
+ py::arg("save_results") = true, py::arg("bits_override") = py::none{}, py::arg("truncate") = true,
+ "Run the simulation until the end of its input arrays and return the output values of the last iteration.")
+
+ .def_property_readonly("iteration", &simulation::iteration,
+ "Get the current iteration number of the simulation.")
+
+ .def_property_readonly("results", &simulation::results,
+ "Get a mapping from result keys to numpy arrays containing all results, including intermediate values,\n"
+ "calculated for each iteration up until now that was run with save_results enabled.\n"
+ "The mapping is indexed using the key() method of Operation with the appropriate output index.\n"
+ "Example result after 3 iterations: {\"c1\": [3, 6, 7], \"c2\": [4, 5, 5], \"bfly1.0\": [7, 0, 0], \"bfly1.1\": [-1, 0, 2], \"0\": [7, -2, -1]}")
+
+ .def("clear_results", &simulation::clear_results,
+ "Clear all results that were saved until now.")
+
+ .def("clear_state", &simulation::clear_state,
+ "Clear all current state of the simulation, except for the results and iteration.");
+ // clang-format on
+}
+
+} // namespace asic
\ No newline at end of file
diff --git a/src/simulation.h b/src/simulation.h
new file mode 100644
index 0000000000000000000000000000000000000000..aefa3a4e92b861b9c7b795c7301f900dc54ace6f
--- /dev/null
+++ b/src/simulation.h
@@ -0,0 +1,12 @@
+#ifndef ASIC_SIMULATION_H
+#define ASIC_SIMULATION_H
+
+#include <pybind11/pybind11.h>
+
+namespace asic {
+
+void define_simulation_class(pybind11::module& module);
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_H
\ No newline at end of file
diff --git a/src/simulation/compile.cpp b/src/simulation/compile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1f93b921b4000b3c776284714cbe9a07e49fc504
--- /dev/null
+++ b/src/simulation/compile.cpp
@@ -0,0 +1,313 @@
+#define NOMINMAX
+#include "compile.h"
+
+#include "../algorithm.h"
+#include "../debug.h"
+#include "../span.h"
+#include "format_code.h"
+
+#include <Python.h>
+#include <fmt/format.h>
+#include <limits>
+#include <optional>
+#include <string_view>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+
+namespace py = pybind11;
+
+namespace asic {
+
+[[nodiscard]] static result_key key_base(py::handle op, std::string_view prefix) {
+ auto const graph_id = op.attr("graph_id").cast<std::string_view>();
+ return (prefix.empty()) ? result_key{graph_id} : fmt::format("{}.{}", prefix, graph_id);
+}
+
+[[nodiscard]] static result_key key_of_output(py::handle op, std::size_t output_index, std::string_view prefix) {
+ auto const base = key_base(op, prefix);
+ if (base.empty()) {
+ return fmt::to_string(output_index);
+ }
+ if (op.attr("output_count").cast<std::size_t>() == 1) {
+ return base;
+ }
+ return fmt::format("{}.{}", base, output_index);
+}
+
+class compiler final {
+public:
+ simulation_code compile(py::handle sfg) {
+ ASIC_DEBUG_MSG("Compiling code...");
+ this->initialize_code(sfg.attr("input_count").cast<std::size_t>(), sfg.attr("output_count").cast<std::size_t>());
+ auto deferred_delays = delay_queue{};
+ this->add_outputs(sfg, deferred_delays);
+ this->add_deferred_delays(std::move(deferred_delays));
+ this->resolve_invalid_result_indices();
+ ASIC_DEBUG_MSG("Compiled code:\n{}\n", format_compiled_simulation_code(m_code));
+ return std::move(m_code);
+ }
+
+private:
+ struct sfg_info final {
+ py::handle sfg;
+ std::size_t prefix_length;
+
+ sfg_info(py::handle sfg, std::size_t prefix_length)
+ : sfg(sfg)
+ , prefix_length(prefix_length) {}
+
+ [[nodiscard]] std::size_t find_input_operation_index(py::handle op) const {
+ for (auto const& [i, in] : enumerate(sfg.attr("input_operations"))) {
+ if (in.is(op)) {
+ return i;
+ }
+ }
+ throw py::value_error{"Stray Input operation in simulation SFG"};
+ }
+ };
+
+ using sfg_info_stack = std::vector<sfg_info>;
+ using delay_queue = std::vector<std::tuple<std::size_t, py::handle, std::string, sfg_info_stack>>;
+ using added_output_cache = std::unordered_set<PyObject const*>;
+ using added_result_cache = std::unordered_map<PyObject const*, result_index_t>;
+ using added_custom_operation_cache = std::unordered_map<PyObject const*, std::size_t>;
+
+ static constexpr auto no_result_index = std::numeric_limits<result_index_t>::max();
+
+ void initialize_code(std::size_t input_count, std::size_t output_count) {
+ m_code.required_stack_size = 0;
+ m_code.input_count = input_count;
+ m_code.output_count = output_count;
+ }
+
+ void add_outputs(py::handle sfg, delay_queue& deferred_delays) {
+ for (auto const i : range(m_code.output_count)) {
+ this->add_operation_output(sfg, i, std::string_view{}, sfg_info_stack{}, deferred_delays);
+ }
+ }
+
+ void add_deferred_delays(delay_queue&& deferred_delays) {
+ while (!deferred_delays.empty()) {
+ auto new_deferred_delays = delay_queue{};
+ for (auto const& [delay_index, op, prefix, sfg_stack] : deferred_delays) {
+ this->add_source(op, 0, prefix, sfg_stack, deferred_delays);
+ this->add_instruction(instruction_type::update_delay, no_result_index, -1).index = delay_index;
+ }
+ deferred_delays = new_deferred_delays;
+ }
+ }
+
+ void resolve_invalid_result_indices() {
+ for (auto& instruction : m_code.instructions) {
+ if (instruction.result_index == no_result_index) {
+ instruction.result_index = static_cast<result_index_t>(m_code.result_keys.size());
+ }
+ }
+ }
+
+ [[nodiscard]] static sfg_info_stack push_sfg(sfg_info_stack const& sfg_stack, py::handle sfg, std::size_t prefix_length) {
+ auto const new_size = static_cast<std::size_t>(sfg_stack.size() + 1);
+ auto new_sfg_stack = sfg_info_stack{};
+ new_sfg_stack.reserve(new_size);
+ for (auto const& info : sfg_stack) {
+ new_sfg_stack.push_back(info);
+ }
+ new_sfg_stack.emplace_back(sfg, prefix_length);
+ return new_sfg_stack;
+ }
+
+ [[nodiscard]] static sfg_info_stack pop_sfg(sfg_info_stack const& sfg_stack) {
+ ASIC_ASSERT(!sfg_stack.empty());
+ auto const new_size = static_cast<std::size_t>(sfg_stack.size() - 1);
+ auto new_sfg_stack = sfg_info_stack{};
+ new_sfg_stack.reserve(new_size);
+ for (auto const& info : span{sfg_stack}.first(new_size)) {
+ new_sfg_stack.push_back(info);
+ }
+ return new_sfg_stack;
+ }
+
+ instruction& add_instruction(instruction_type type, result_index_t result_index, std::ptrdiff_t stack_diff) {
+ m_stack_depth += stack_diff;
+ if (m_stack_depth < 0) {
+ throw py::value_error{"Detected input/output count mismatch in simulation SFG"};
+ }
+ if (auto const stack_size = static_cast<std::size_t>(m_stack_depth); stack_size > m_code.required_stack_size) {
+ m_code.required_stack_size = stack_size;
+ }
+ auto& instruction = m_code.instructions.emplace_back();
+ instruction.type = type;
+ instruction.result_index = result_index;
+ return instruction;
+ }
+
+ [[nodiscard]] std::optional<result_index_t> begin_operation_output(py::handle op, std::size_t output_index, std::string_view prefix) {
+ auto const pointer = op.attr("outputs")[py::int_{output_index}].ptr();
+ if (m_incomplete_outputs.count(pointer) != 0) {
+ // Make sure the output doesn't depend on its own value, unless it's a delay operation.
+ if (op.attr("type_name")().cast<std::string_view>() != "t") {
+ throw py::value_error{"Direct feedback loop detected in simulation SFG"};
+ }
+ }
+ // Try to add a new result.
+ auto const [it, inserted] = m_added_results.try_emplace(pointer, static_cast<result_index_t>(m_code.result_keys.size()));
+ if (inserted) {
+ if (m_code.result_keys.size() >= static_cast<std::size_t>(std::numeric_limits<result_index_t>::max())) {
+ throw py::value_error{fmt::format("Simulation SFG requires too many outputs to be stored (limit: {})",
+ std::numeric_limits<result_index_t>::max())};
+ }
+ m_code.result_keys.push_back(key_of_output(op, output_index, prefix));
+ m_incomplete_outputs.insert(pointer);
+ return it->second;
+ }
+ // If the result has already been added, we re-use the old result and
+ // return std::nullopt to indicate that we don't need to add all the required instructions again.
+ this->add_instruction(instruction_type::push_result, it->second, 1).index = static_cast<std::size_t>(it->second);
+ return std::nullopt;
+ }
+
+ void end_operation_output(py::handle op, std::size_t output_index) {
+ auto const pointer = op.attr("outputs")[py::int_{output_index}].ptr();
+ [[maybe_unused]] auto const erased = m_incomplete_outputs.erase(pointer);
+ ASIC_ASSERT(erased == 1);
+ }
+
+ [[nodiscard]] std::size_t try_add_custom_operation(py::handle op) {
+ auto const [it, inserted] = m_added_custom_operations.try_emplace(op.ptr(), m_added_custom_operations.size());
+ if (inserted) {
+ auto& custom_operation = m_code.custom_operations.emplace_back();
+ custom_operation.evaluate_output = op.attr("evaluate_output");
+ custom_operation.input_count = op.attr("input_count").cast<std::size_t>();
+ custom_operation.output_count = op.attr("output_count").cast<std::size_t>();
+ }
+ return it->second;
+ }
+
+ [[nodiscard]] std::size_t add_delay_info(number initial_value, result_index_t result_index) {
+ auto const delay_index = m_code.delays.size();
+ auto& delay = m_code.delays.emplace_back();
+ delay.initial_value = initial_value;
+ delay.result_index = result_index;
+ return delay_index;
+ }
+
+ void add_source(py::handle op, std::size_t input_index, std::string_view prefix, sfg_info_stack const& sfg_stack,
+ delay_queue& deferred_delays) {
+ auto const signal = py::object{op.attr("inputs")[py::int_{input_index}].attr("signals")[py::int_{0}]};
+ auto const src = py::handle{signal.attr("source")};
+ auto const operation = py::handle{src.attr("operation")};
+ auto const index = src.attr("index").cast<std::size_t>();
+ this->add_operation_output(operation, index, prefix, sfg_stack, deferred_delays);
+ if (!signal.attr("bits").is_none()) {
+ auto const bits = signal.attr("bits").cast<std::size_t>();
+ if (bits > 64) {
+ throw py::value_error{"Cannot truncate to more than 64 bits"};
+ }
+ this->add_instruction(instruction_type::truncate, no_result_index, 0).bit_mask = static_cast<std::int64_t>(std::int64_t{1}
+ << bits);
+ }
+ }
+
+ void add_unary_operation_output(py::handle op, result_index_t result_index, std::string_view prefix, sfg_info_stack const& sfg_stack,
+ delay_queue& deferred_delays, instruction_type type) {
+ this->add_source(op, 0, prefix, sfg_stack, deferred_delays);
+ this->add_instruction(type, result_index, 0);
+ }
+
+ void add_binary_operation_output(py::handle op, result_index_t result_index, std::string_view prefix, sfg_info_stack const& sfg_stack,
+ delay_queue& deferred_delays, instruction_type type) {
+ this->add_source(op, 0, prefix, sfg_stack, deferred_delays);
+ this->add_source(op, 1, prefix, sfg_stack, deferred_delays);
+ this->add_instruction(type, result_index, -1);
+ }
+
+ void add_operation_output(py::handle op, std::size_t output_index, std::string_view prefix, sfg_info_stack const& sfg_stack,
+ delay_queue& deferred_delays) {
+ auto const type_name = op.attr("type_name")().cast<std::string_view>();
+ if (type_name == "out") {
+ this->add_source(op, 0, prefix, sfg_stack, deferred_delays);
+ } else if (auto const result_index = this->begin_operation_output(op, output_index, prefix)) {
+ if (type_name == "c") {
+ this->add_instruction(instruction_type::push_constant, *result_index, 1).value = op.attr("value").cast<number>();
+ } else if (type_name == "add") {
+ this->add_binary_operation_output(op, *result_index, prefix, sfg_stack, deferred_delays, instruction_type::addition);
+ } else if (type_name == "sub") {
+ this->add_binary_operation_output(op, *result_index, prefix, sfg_stack, deferred_delays, instruction_type::subtraction);
+ } else if (type_name == "mul") {
+ this->add_binary_operation_output(op, *result_index, prefix, sfg_stack, deferred_delays, instruction_type::multiplication);
+ } else if (type_name == "div") {
+ this->add_binary_operation_output(op, *result_index, prefix, sfg_stack, deferred_delays, instruction_type::division);
+ } else if (type_name == "min") {
+ this->add_binary_operation_output(op, *result_index, prefix, sfg_stack, deferred_delays, instruction_type::min);
+ } else if (type_name == "max") {
+ this->add_binary_operation_output(op, *result_index, prefix, sfg_stack, deferred_delays, instruction_type::max);
+ } else if (type_name == "sqrt") {
+ this->add_unary_operation_output(op, *result_index, prefix, sfg_stack, deferred_delays, instruction_type::square_root);
+ } else if (type_name == "conj") {
+ this->add_unary_operation_output(
+ op, *result_index, prefix, sfg_stack, deferred_delays, instruction_type::complex_conjugate);
+ } else if (type_name == "abs") {
+ this->add_unary_operation_output(op, *result_index, prefix, sfg_stack, deferred_delays, instruction_type::absolute);
+ } else if (type_name == "cmul") {
+ this->add_source(op, 0, prefix, sfg_stack, deferred_delays);
+ this->add_instruction(instruction_type::constant_multiplication, *result_index, 0).value = op.attr("value").cast<number>();
+ } else if (type_name == "bfly") {
+ if (output_index == 0) {
+ this->add_source(op, 0, prefix, sfg_stack, deferred_delays);
+ this->add_source(op, 1, prefix, sfg_stack, deferred_delays);
+ this->add_instruction(instruction_type::addition, *result_index, -1);
+ } else {
+ this->add_source(op, 0, prefix, sfg_stack, deferred_delays);
+ this->add_source(op, 1, prefix, sfg_stack, deferred_delays);
+ this->add_instruction(instruction_type::subtraction, *result_index, -1);
+ }
+ } else if (type_name == "in") {
+ if (sfg_stack.empty()) {
+ throw py::value_error{"Encountered Input operation outside SFG in simulation"};
+ }
+ auto const& info = sfg_stack.back();
+ auto const input_index = info.find_input_operation_index(op);
+ if (sfg_stack.size() == 1) {
+ this->add_instruction(instruction_type::push_input, *result_index, 1).index = input_index;
+ } else {
+ this->add_source(info.sfg, input_index, prefix.substr(0, info.prefix_length), pop_sfg(sfg_stack), deferred_delays);
+ this->add_instruction(instruction_type::forward_value, *result_index, 0);
+ }
+ } else if (type_name == "t") {
+ auto const delay_index = this->add_delay_info(op.attr("initial_value").cast<number>(), *result_index);
+ deferred_delays.emplace_back(delay_index, op, std::string{prefix}, sfg_stack);
+ this->add_instruction(instruction_type::push_delay, *result_index, 1).index = delay_index;
+ } else if (type_name == "sfg") {
+ auto const output_op = py::handle{op.attr("output_operations")[py::int_{output_index}]};
+ this->add_source(output_op, 0, key_base(op, prefix), push_sfg(sfg_stack, op, prefix.size()), deferred_delays);
+ this->add_instruction(instruction_type::forward_value, *result_index, 0);
+ } else {
+ auto const custom_operation_index = this->try_add_custom_operation(op);
+ auto const& custom_operation = m_code.custom_operations[custom_operation_index];
+ for (auto const i : range(custom_operation.input_count)) {
+ this->add_source(op, i, prefix, sfg_stack, deferred_delays);
+ }
+ auto const custom_source_index = m_code.custom_sources.size();
+ auto& custom_source = m_code.custom_sources.emplace_back();
+ custom_source.custom_operation_index = custom_operation_index;
+ custom_source.output_index = output_index;
+ auto const stack_diff = std::ptrdiff_t{1} - static_cast<std::ptrdiff_t>(custom_operation.input_count);
+ this->add_instruction(instruction_type::custom, *result_index, stack_diff).index = custom_source_index;
+ }
+ this->end_operation_output(op, output_index);
+ }
+ }
+
+ simulation_code m_code;
+ added_output_cache m_incomplete_outputs;
+ added_result_cache m_added_results;
+ added_custom_operation_cache m_added_custom_operations;
+ std::ptrdiff_t m_stack_depth = 0;
+};
+
+simulation_code compile_simulation(pybind11::handle sfg) {
+ return compiler{}.compile(sfg);
+}
+
+} // namespace asic
\ No newline at end of file
diff --git a/src/simulation/compile.h b/src/simulation/compile.h
new file mode 100644
index 0000000000000000000000000000000000000000..883f4c5832978ea1bfd33c767fc947c1efde718e
--- /dev/null
+++ b/src/simulation/compile.h
@@ -0,0 +1,61 @@
+#ifndef ASIC_SIMULATION_COMPILE_H
+#define ASIC_SIMULATION_COMPILE_H
+
+#include "instruction.h"
+
+#include <cstddef>
+#include <pybind11/pybind11.h>
+#include <string>
+#include <vector>
+
+namespace asic {
+
+using result_key = std::string;
+
+struct simulation_code final {
+ struct custom_operation final {
+ // Python function used to evaluate the custom operation.
+ pybind11::object evaluate_output;
+ // Number of inputs that the custom operation takes.
+ std::size_t input_count;
+ // Number of outputs that the custom operation gives.
+ std::size_t output_count;
+ };
+
+ struct custom_source final {
+ // Index into custom_operations where the custom_operation corresponding to this custom_source is located.
+ std::size_t custom_operation_index;
+ // Output index of the custom_operation that this source gets it value from.
+ std::size_t output_index;
+ };
+
+ struct delay_info final {
+ // Initial value to set at the start of the simulation.
+ number initial_value;
+ // The result index where the current value should be stored at the start of each iteration.
+ result_index_t result_index;
+ };
+
+ // Instructions to execute for one full iteration of the simulation.
+ std::vector<instruction> instructions;
+ // Custom operations used by the simulation.
+ std::vector<custom_operation> custom_operations;
+ // Signal sources that use custom operations.
+ std::vector<custom_source> custom_sources;
+ // Info about the delay operations used in the simulation.
+ std::vector<delay_info> delays;
+ // Keys for each result produced by the simulation. The index of the key matches the index of the result in the simulation state.
+ std::vector<result_key> result_keys;
+ // Number of values expected as input to the simulation.
+ std::size_t input_count;
+ // Number of values given as output from the simulation. This will be the number of values left on the stack after a full iteration of the simulation has been run.
+ std::size_t output_count;
+ // Maximum number of values that need to be able to fit on the stack in order to run a full iteration of the simulation.
+ std::size_t required_stack_size;
+};
+
+[[nodiscard]] simulation_code compile_simulation(pybind11::handle sfg);
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_COMPILE_H
\ No newline at end of file
diff --git a/src/simulation/format_code.h b/src/simulation/format_code.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ebbb95d1f11eb18b915dbab9fbccbb82d83304c
--- /dev/null
+++ b/src/simulation/format_code.h
@@ -0,0 +1,129 @@
+#ifndef ASIC_SIMULATION_FORMAT_CODE_H
+#define ASIC_SIMULATION_FORMAT_CODE_H
+
+#include "../algorithm.h"
+#include "../debug.h"
+#include "../number.h"
+#include "compile.h"
+#include "instruction.h"
+
+#include <fmt/format.h>
+#include <string>
+
+namespace asic {
+
+[[nodiscard]] inline std::string format_number(number const& value) {
+ if (value.imag() == 0) {
+ return fmt::to_string(value.real());
+ }
+ if (value.real() == 0) {
+ return fmt::format("{}j", value.imag());
+ }
+ if (value.imag() < 0) {
+ return fmt::format("{}-{}j", value.real(), -value.imag());
+ }
+ return fmt::format("{}+{}j", value.real(), value.imag());
+}
+
+[[nodiscard]] inline std::string format_compiled_simulation_code_result_keys(simulation_code const& code) {
+ auto result = std::string{};
+ for (auto const& [i, result_key] : enumerate(code.result_keys)) {
+ result += fmt::format("{:>2}: \"{}\"\n", i, result_key);
+ }
+ return result;
+}
+
+[[nodiscard]] inline std::string format_compiled_simulation_code_delays(simulation_code const& code) {
+ auto result = std::string{};
+ for (auto const& [i, delay] : enumerate(code.delays)) {
+ ASIC_ASSERT(delay.result_index < code.result_keys.size());
+ result += fmt::format("{:>2}: Initial value: {}, Result: {}: \"{}\"\n",
+ i,
+ format_number(delay.initial_value),
+ delay.result_index,
+ code.result_keys[delay.result_index]);
+ }
+ return result;
+}
+
+[[nodiscard]] inline std::string format_compiled_simulation_code_instruction(instruction const& instruction) {
+ switch (instruction.type) {
+ // clang-format off
+ case instruction_type::push_input: return fmt::format("push_input inputs[{}]", instruction.index);
+ case instruction_type::push_result: return fmt::format("push_result results[{}]", instruction.index);
+ case instruction_type::push_delay: return fmt::format("push_delay delays[{}]", instruction.index);
+ case instruction_type::push_constant: return fmt::format("push_constant {}", format_number(instruction.value));
+ case instruction_type::truncate: return fmt::format("truncate {:#018x}", instruction.bit_mask);
+ case instruction_type::addition: return "addition";
+ case instruction_type::subtraction: return "subtraction";
+ case instruction_type::multiplication: return "multiplication";
+ case instruction_type::division: return "division";
+ case instruction_type::min: return "min";
+ case instruction_type::max: return "max";
+ case instruction_type::square_root: return "square_root";
+ case instruction_type::complex_conjugate: return "complex_conjugate";
+ case instruction_type::absolute: return "absolute";
+ case instruction_type::constant_multiplication: return fmt::format("constant_multiplication {}", format_number(instruction.value));
+ case instruction_type::update_delay: return fmt::format("update_delay delays[{}]", instruction.index);
+ case instruction_type::custom: return fmt::format("custom custom_sources[{}]", instruction.index);
+ case instruction_type::forward_value: return "forward_value";
+ // clang-format on
+ }
+ return std::string{};
+}
+
+[[nodiscard]] inline std::string format_compiled_simulation_code_instructions(simulation_code const& code) {
+ auto result = std::string{};
+ for (auto const& [i, instruction] : enumerate(code.instructions)) {
+ auto instruction_string = format_compiled_simulation_code_instruction(instruction);
+ if (instruction.result_index < code.result_keys.size()) {
+ instruction_string = fmt::format(
+ "{:<26} -> {}: \"{}\"", instruction_string, instruction.result_index, code.result_keys[instruction.result_index]);
+ }
+ result += fmt::format("{:>2}: {}\n", i, instruction_string);
+ }
+ return result;
+}
+
+[[nodiscard]] inline std::string format_compiled_simulation_code(simulation_code const& code) {
+ return fmt::format(
+ "==============================================\n"
+ "> Code stats\n"
+ "==============================================\n"
+ "Input count: {}\n"
+ "Output count: {}\n"
+ "Instruction count: {}\n"
+ "Required stack size: {}\n"
+ "Delay count: {}\n"
+ "Result count: {}\n"
+ "Custom operation count: {}\n"
+ "Custom source count: {}\n"
+ "==============================================\n"
+ "> Delays\n"
+ "==============================================\n"
+ "{}"
+ "==============================================\n"
+ "> Result keys\n"
+ "==============================================\n"
+ "{}"
+ "==============================================\n"
+ "> Instructions\n"
+ "==============================================\n"
+ "{}"
+ "==============================================",
+ code.input_count,
+ code.output_count,
+ code.instructions.size(),
+ code.required_stack_size,
+ code.delays.size(),
+ code.result_keys.size(),
+ code.custom_operations.size(),
+ code.custom_sources.size(),
+ format_compiled_simulation_code_delays(code),
+ format_compiled_simulation_code_result_keys(code),
+ format_compiled_simulation_code_instructions(code));
+}
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_FORMAT_CODE
\ No newline at end of file
diff --git a/src/simulation/instruction.h b/src/simulation/instruction.h
new file mode 100644
index 0000000000000000000000000000000000000000..d650c651394a243c52eee7e5ad2fe463f96bdad7
--- /dev/null
+++ b/src/simulation/instruction.h
@@ -0,0 +1,57 @@
+#ifndef ASIC_SIMULATION_INSTRUCTION_H
+#define ASIC_SIMULATION_INSTRUCTION_H
+
+#include "../number.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+
+namespace asic {
+
+enum class instruction_type : std::uint8_t {
+ push_input, // push(inputs[index])
+ push_result, // push(results[index])
+ push_delay, // push(delays[index])
+ push_constant, // push(value)
+ truncate, // push(trunc(pop(), bit_mask))
+ addition, // push(pop() + pop())
+ subtraction, // push(pop() - pop())
+ multiplication, // push(pop() * pop())
+ division, // push(pop() / pop())
+ min, // push(min(pop(), pop()))
+ max, // push(max(pop(), pop()))
+ square_root, // push(sqrt(pop()))
+ complex_conjugate, // push(conj(pop()))
+ absolute, // push(abs(pop()))
+ constant_multiplication, // push(pop() * value)
+ update_delay, // delays[index] = pop()
+ custom, // Custom operation. Uses custom_source[index].
+ forward_value // Forward the current value on the stack (push(pop()), i.e. do nothing).
+};
+
+using result_index_t = std::uint16_t;
+
+struct instruction final {
+ constexpr instruction() noexcept
+ : index(0)
+ , result_index(0)
+ , type(instruction_type::forward_value) {}
+
+ union {
+ // Index used by push_input, push_result, delay and custom.
+ std::size_t index;
+ // Bit mask used by truncate.
+ std::int64_t bit_mask;
+ // Constant value used by push_constant and constant_multiplication.
+ number value;
+ };
+ // Index into where the result of the instruction will be stored. If the result should be ignored, this index will be one past the last valid result index.
+ result_index_t result_index;
+ // Specifies what kind of operation the instruction should execute.
+ instruction_type type;
+};
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_INSTRUCTION_H
\ No newline at end of file
diff --git a/src/simulation/run.cpp b/src/simulation/run.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1f27b0c70e4d70ec057953caded37a4f40ab1b10
--- /dev/null
+++ b/src/simulation/run.cpp
@@ -0,0 +1,176 @@
+#define NOMINMAX
+#include "run.h"
+
+#include "../algorithm.h"
+#include "../debug.h"
+#include "format_code.h"
+
+#include <algorithm>
+#include <complex>
+#include <cstddef>
+#include <fmt/format.h>
+#include <iterator>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <stdexcept>
+
+namespace py = pybind11;
+
+namespace asic {
+
+[[nodiscard]] static number truncate_value(number value, std::int64_t bit_mask) {
+ if (value.imag() != 0) {
+ throw py::type_error{"Complex value cannot be truncated"};
+ }
+ return number{static_cast<number::value_type>(static_cast<std::int64_t>(value.real()) & bit_mask)};
+}
+
+[[nodiscard]] static std::int64_t setup_truncation_parameters(bool& truncate, std::optional<std::uint8_t>& bits_override) {
+ if (truncate && bits_override) {
+ truncate = false; // Ignore truncate instructions, they will be truncated using bits_override instead.
+ if (*bits_override > 64) {
+ throw py::value_error{"Cannot truncate to more than 64 bits"};
+ }
+ return static_cast<std::int64_t>(std::int64_t{1} << *bits_override); // Return the bit mask override to use.
+ }
+ bits_override.reset(); // Don't use bits_override if truncate is false.
+ return std::int64_t{};
+}
+
+simulation_state run_simulation(simulation_code const& code, span<number const> inputs, span<number> delays,
+ std::optional<std::uint8_t> bits_override, bool truncate) {
+ ASIC_ASSERT(inputs.size() == code.input_count);
+ ASIC_ASSERT(delays.size() == code.delays.size());
+ ASIC_ASSERT(code.output_count <= code.required_stack_size);
+
+ auto state = simulation_state{};
+
+ // Setup results.
+ state.results.resize(code.result_keys.size() + 1); // Add one space to store ignored results.
+ // Initialize delay results to their current values.
+ for (auto const& [i, delay] : enumerate(code.delays)) {
+ state.results[delay.result_index] = delays[i];
+ }
+
+ // Setup stack.
+ state.stack.resize(code.required_stack_size);
+ auto stack_pointer = state.stack.data();
+
+ // Utility functions to make the stack manipulation code below more readable.
+ // Should hopefully be inlined by the compiler.
+ auto const push = [&](number value) -> void {
+ ASIC_ASSERT(std::distance(state.stack.data(), stack_pointer) < static_cast<std::ptrdiff_t>(state.stack.size()));
+ *stack_pointer++ = value;
+ };
+ auto const pop = [&]() -> number {
+ ASIC_ASSERT(std::distance(state.stack.data(), stack_pointer) > std::ptrdiff_t{0});
+ return *--stack_pointer;
+ };
+ auto const peek = [&]() -> number {
+ ASIC_ASSERT(std::distance(state.stack.data(), stack_pointer) > std::ptrdiff_t{0});
+ ASIC_ASSERT(std::distance(state.stack.data(), stack_pointer) <= static_cast<std::ptrdiff_t>(state.stack.size()));
+ return *(stack_pointer - 1);
+ };
+
+ // Check if results should be truncated.
+ auto const bit_mask_override = setup_truncation_parameters(truncate, bits_override);
+
+ // Hot instruction evaluation loop.
+ for (auto const& instruction : code.instructions) {
+ ASIC_DEBUG_MSG("Evaluating {}.", format_compiled_simulation_code_instruction(instruction));
+ // Execute the instruction.
+ switch (instruction.type) {
+ case instruction_type::push_input:
+ push(inputs[instruction.index]);
+ break;
+ case instruction_type::push_result:
+ push(state.results[instruction.index]);
+ break;
+ case instruction_type::push_delay:
+ push(delays[instruction.index]);
+ break;
+ case instruction_type::push_constant:
+ push(instruction.value);
+ break;
+ case instruction_type::truncate:
+ if (truncate) {
+ push(truncate_value(pop(), instruction.bit_mask));
+ }
+ break;
+ case instruction_type::addition:
+ push(pop() + pop());
+ break;
+ case instruction_type::subtraction:
+ push(pop() - pop());
+ break;
+ case instruction_type::multiplication:
+ push(pop() * pop());
+ break;
+ case instruction_type::division:
+ push(pop() / pop());
+ break;
+ case instruction_type::min: {
+ auto const lhs = pop();
+ auto const rhs = pop();
+ if (lhs.imag() != 0 || rhs.imag() != 0) {
+ throw std::runtime_error{"Min does not support complex numbers."};
+ }
+ push(std::min(lhs.real(), rhs.real()));
+ break;
+ }
+ case instruction_type::max: {
+ auto const lhs = pop();
+ auto const rhs = pop();
+ if (lhs.imag() != 0 || rhs.imag() != 0) {
+ throw std::runtime_error{"Max does not support complex numbers."};
+ }
+ push(std::max(lhs.real(), rhs.real()));
+ break;
+ }
+ case instruction_type::square_root:
+ push(std::sqrt(pop()));
+ break;
+ case instruction_type::complex_conjugate:
+ push(std::conj(pop()));
+ break;
+ case instruction_type::absolute:
+ push(number{std::abs(pop())});
+ break;
+ case instruction_type::constant_multiplication:
+ push(pop() * instruction.value);
+ break;
+ case instruction_type::update_delay:
+ delays[instruction.index] = pop();
+ break;
+ case instruction_type::custom: {
+ using namespace pybind11::literals;
+ auto const& src = code.custom_sources[instruction.index];
+ auto const& op = code.custom_operations[src.custom_operation_index];
+ auto input_values = std::vector<number>{};
+ input_values.reserve(op.input_count);
+ for (auto i = std::size_t{0}; i < op.input_count; ++i) {
+ input_values.push_back(pop());
+ }
+ push(op.evaluate_output(src.output_index, std::move(input_values), "truncate"_a = truncate).cast<number>());
+ break;
+ }
+ case instruction_type::forward_value:
+ // Do nothing, since doing push(pop()) would be pointless.
+ break;
+ }
+ // If we've been given a global override for how many bits to use, always truncate the result.
+ if (bits_override) {
+ push(truncate_value(pop(), bit_mask_override));
+ }
+ // Store the result.
+ state.results[instruction.result_index] = peek();
+ }
+
+ // Remove the space that we used for ignored results.
+ state.results.pop_back();
+ // Erase the portion of the stack that does not contain the output values.
+ state.stack.erase(state.stack.begin() + static_cast<std::ptrdiff_t>(code.output_count), state.stack.end());
+ return state;
+}
+
+} // namespace asic
\ No newline at end of file
diff --git a/src/simulation/run.h b/src/simulation/run.h
new file mode 100644
index 0000000000000000000000000000000000000000..2174c571ef59f3e12236471e3e064f2619c38a60
--- /dev/null
+++ b/src/simulation/run.h
@@ -0,0 +1,23 @@
+#ifndef ASIC_SIMULATION_RUN_H
+#define ASIC_SIMULATION_RUN_H
+
+#include "../number.h"
+#include "../span.h"
+#include "compile.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace asic {
+
+struct simulation_state final {
+ std::vector<number> stack;
+ std::vector<number> results;
+};
+
+simulation_state run_simulation(simulation_code const& code, span<number const> inputs, span<number> delays,
+ std::optional<std::uint8_t> bits_override, bool truncate);
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_RUN_H
\ No newline at end of file
diff --git a/src/simulation/simulation.cpp b/src/simulation/simulation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3af24c10e62bfe09590a05153abd25468d6bee4c
--- /dev/null
+++ b/src/simulation/simulation.cpp
@@ -0,0 +1,129 @@
+#define NOMINMAX
+#include "simulation.h"
+
+#include "../algorithm.h"
+#include "../debug.h"
+#include "compile.h"
+#include "run.h"
+
+#include <fmt/format.h>
+#include <limits>
+#include <pybind11/numpy.h>
+#include <utility>
+
+namespace py = pybind11;
+
+namespace asic {
+
+simulation::simulation(pybind11::handle sfg, std::optional<std::vector<std::optional<input_provider_t>>> input_providers)
+ : m_code(compile_simulation(sfg))
+ , m_input_functions(sfg.attr("input_count").cast<std::size_t>(), [](iteration_t) -> number { return number{}; }) {
+ m_delays.reserve(m_code.delays.size());
+ for (auto const& delay : m_code.delays) {
+ m_delays.push_back(delay.initial_value);
+ }
+ if (input_providers) {
+ this->set_inputs(std::move(*input_providers));
+ }
+}
+
+void simulation::set_input(std::size_t index, input_provider_t input_provider) {
+ if (index >= m_input_functions.size()) {
+ throw py::index_error{fmt::format("Input index out of range (expected 0-{}, got {})", m_input_functions.size() - 1, index)};
+ }
+ if (auto* const callable = std::get_if<input_function_t>(&input_provider)) {
+ m_input_functions[index] = std::move(*callable);
+ } else if (auto* const numeric = std::get_if<number>(&input_provider)) {
+ m_input_functions[index] = [value = *numeric](iteration_t) -> number {
+ return value;
+ };
+ } else if (auto* const list = std::get_if<std::vector<number>>(&input_provider)) {
+ if (!m_input_length) {
+ m_input_length = static_cast<iteration_t>(list->size());
+ } else if (*m_input_length != static_cast<iteration_t>(list->size())) {
+ throw py::value_error{fmt::format("Inconsistent input length for simulation (was {}, got {})", *m_input_length, list->size())};
+ }
+ m_input_functions[index] = [values = std::move(*list)](iteration_t n) -> number {
+ return values.at(n);
+ };
+ }
+}
+
+void simulation::set_inputs(std::vector<std::optional<input_provider_t>> input_providers) {
+ if (input_providers.size() != m_input_functions.size()) {
+ throw py::value_error{fmt::format(
+ "Wrong number of inputs supplied to simulation (expected {}, got {})", m_input_functions.size(), input_providers.size())};
+ }
+ for (auto&& [i, input_provider] : enumerate(input_providers)) {
+ if (input_provider) {
+ this->set_input(i, std::move(*input_provider));
+ }
+ }
+}
+
+std::vector<number> simulation::step(bool save_results, std::optional<std::uint8_t> bits_override, bool truncate) {
+ return this->run_for(1, save_results, bits_override, truncate);
+}
+
+std::vector<number> simulation::run_until(iteration_t iteration, bool save_results, std::optional<std::uint8_t> bits_override,
+ bool truncate) {
+ auto result = std::vector<number>{};
+ while (m_iteration < iteration) {
+ ASIC_DEBUG_MSG("Running simulation iteration.");
+ auto inputs = std::vector<number>(m_code.input_count);
+ for (auto&& [input, function] : zip(inputs, m_input_functions)) {
+ input = function(m_iteration);
+ }
+ auto state = run_simulation(m_code, inputs, m_delays, bits_override, truncate);
+ result = std::move(state.stack);
+ if (save_results) {
+ m_results.push_back(std::move(state.results));
+ }
+ ++m_iteration;
+ }
+ return result;
+}
+
+std::vector<number> simulation::run_for(iteration_t iterations, bool save_results, std::optional<std::uint8_t> bits_override,
+ bool truncate) {
+ if (iterations > std::numeric_limits<iteration_t>::max() - m_iteration) {
+ throw py::value_error("Simulation iteration type overflow!");
+ }
+ return this->run_until(m_iteration + iterations, save_results, bits_override, truncate);
+}
+
+std::vector<number> simulation::run(bool save_results, std::optional<std::uint8_t> bits_override, bool truncate) {
+ if (m_input_length) {
+ return this->run_until(*m_input_length, save_results, bits_override, truncate);
+ }
+ throw py::index_error{"Tried to run unlimited simulation"};
+}
+
+iteration_t simulation::iteration() const noexcept {
+ return m_iteration;
+}
+
+pybind11::dict simulation::results() const noexcept {
+ auto results = py::dict{};
+ if (!m_results.empty()) {
+ for (auto const& [i, key] : enumerate(m_code.result_keys)) {
+ auto values = std::vector<number>{};
+ values.reserve(m_results.size());
+ for (auto const& result : m_results) {
+ values.push_back(result[i]);
+ }
+ results[py::str{key}] = py::array{static_cast<py::ssize_t>(values.size()), values.data()};
+ }
+ }
+ return results;
+}
+
+void simulation::clear_results() noexcept {
+ m_results.clear();
+}
+
+void simulation::clear_state() noexcept {
+ m_delays.clear();
+}
+
+} // namespace asic
diff --git a/src/simulation/simulation.h b/src/simulation/simulation.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1a36cbc93492494af14a198c970a6a534477794
--- /dev/null
+++ b/src/simulation/simulation.h
@@ -0,0 +1,54 @@
+#ifndef ASIC_SIMULATION_DOD_H
+#define ASIC_SIMULATION_DOD_H
+
+#include "../number.h"
+#include "compile.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <variant>
+#include <vector>
+
+namespace asic {
+
+using iteration_t = std::uint32_t;
+using input_function_t = std::function<number(iteration_t)>;
+using input_provider_t = std::variant<number, std::vector<number>, input_function_t>;
+
+class simulation final {
+public:
+ simulation(pybind11::handle sfg, std::optional<std::vector<std::optional<input_provider_t>>> input_providers = std::nullopt);
+
+ void set_input(std::size_t index, input_provider_t input_provider);
+ void set_inputs(std::vector<std::optional<input_provider_t>> input_providers);
+
+ [[nodiscard]] std::vector<number> step(bool save_results, std::optional<std::uint8_t> bits_override, bool truncate);
+ [[nodiscard]] std::vector<number> run_until(iteration_t iteration, bool save_results, std::optional<std::uint8_t> bits_override,
+ bool truncate);
+ [[nodiscard]] std::vector<number> run_for(iteration_t iterations, bool save_results, std::optional<std::uint8_t> bits_override,
+ bool truncate);
+ [[nodiscard]] std::vector<number> run(bool save_results, std::optional<std::uint8_t> bits_override, bool truncate);
+
+ [[nodiscard]] iteration_t iteration() const noexcept;
+ [[nodiscard]] pybind11::dict results() const noexcept;
+
+ void clear_results() noexcept;
+ void clear_state() noexcept;
+
+private:
+ simulation_code m_code;
+ std::vector<number> m_delays;
+ std::vector<input_function_t> m_input_functions;
+ std::optional<iteration_t> m_input_length;
+ iteration_t m_iteration = 0;
+ std::vector<std::vector<number>> m_results;
+};
+
+} // namespace asic
+
+#endif // ASIC_SIMULATION_DOD_H
\ No newline at end of file
diff --git a/src/span.h b/src/span.h
new file mode 100644
index 0000000000000000000000000000000000000000..2ad454e13e3978c74355ae3ca0f955fad1bb9753
--- /dev/null
+++ b/src/span.h
@@ -0,0 +1,314 @@
+#ifndef ASIC_SPAN_H
+#define ASIC_SPAN_H
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <iterator>
+#include <limits>
+#include <array>
+#include <algorithm>
+#include <cassert>
+
+namespace asic {
+
+constexpr auto dynamic_size = static_cast<std::size_t>(-1);
+
+// C++17-compatible std::span substitute.
+template <typename T, std::size_t Size = dynamic_size>
+class span;
+
+namespace detail {
+
+template <typename T>
+struct is_span_impl : std::false_type {};
+
+template <typename T, std::size_t Size>
+struct is_span_impl<span<T, Size>> : std::true_type {};
+
+template <typename T>
+struct is_span : is_span_impl<std::remove_cv_t<T>> {};
+
+template <typename T>
+constexpr auto is_span_v = is_span<T>::value;
+
+template <typename T>
+struct is_std_array_impl : std::false_type {};
+
+template <typename T, std::size_t Size>
+struct is_std_array_impl<std::array<T, Size>> : std::true_type {};
+
+template <typename T>
+struct is_std_array : is_std_array_impl<std::remove_cv_t<T>> {};
+
+template <typename T>
+constexpr auto is_std_array_v = is_std_array<T>::value;
+
+template <std::size_t From, std::size_t To>
+struct is_size_convertible : std::bool_constant<From == To || From == dynamic_size || To == dynamic_size> {};
+
+template <std::size_t From, std::size_t To>
+constexpr auto is_size_convertible_v = is_size_convertible<From, To>::value;
+
+template <typename From, typename To>
+struct is_element_type_convertible : std::bool_constant<std::is_convertible_v<From(*)[], To(*)[]>> {};
+
+template <typename From, typename To>
+constexpr auto is_element_type_convertible_v = is_element_type_convertible<From, To>::value;
+
+template <typename T, std::size_t Size>
+struct span_base {
+ using element_type = T;
+ using pointer = element_type*;
+ using size_type = std::size_t;
+
+ constexpr span_base() noexcept = default;
+ constexpr span_base(pointer data, [[maybe_unused]] size_type size) : m_data(data) { assert(size == Size); }
+
+ template <size_type N>
+ constexpr span_base(span_base<T, N> other) : m_data(other.data()) {
+ static_assert(N == Size || N == dynamic_size);
+ assert(other.size() == Size);
+ }
+
+ [[nodiscard]] constexpr pointer data() const noexcept { return m_data; }
+ [[nodiscard]] constexpr size_type size() const noexcept { return Size; }
+
+private:
+ pointer m_data = nullptr;
+};
+
+template <typename T>
+struct span_base<T, dynamic_size> {
+ using element_type = T;
+ using pointer = element_type*;
+ using size_type = std::size_t;
+
+ constexpr span_base() noexcept = default;
+ constexpr span_base(pointer data, size_type size) : m_data(data), m_size(size) {}
+
+ template <size_type N>
+ explicit constexpr span_base(span_base<T, N> other) : m_data(other.data()), m_size(other.size()) {}
+
+ [[nodiscard]] constexpr pointer data() const noexcept { return m_data; }
+ [[nodiscard]] constexpr size_type size() const noexcept { return m_size; }
+
+private:
+ pointer m_data = nullptr;
+ size_type m_size = 0;
+};
+
+template <typename T, std::size_t Size, std::size_t Offset, std::size_t N>
+struct subspan_type {
+ using type = span<
+ T,
+ (N != dynamic_size) ?
+ N :
+ (Size != dynamic_size) ?
+ Size - Offset :
+ Size
+ >;
+};
+
+template <typename T, std::size_t Size, std::size_t Offset, std::size_t Count>
+using subspan_type_t = typename subspan_type<T, Size, Offset, Count>::type;
+
+} // namespace detail
+
+template <typename T, std::size_t Size>
+class span final : public detail::span_base<T, Size> {
+public:
+ using element_type = typename detail::span_base<T, Size>::element_type;
+ using pointer = typename detail::span_base<T, Size>::pointer;
+ using size_type = typename detail::span_base<T, Size>::size_type;
+ using value_type = std::remove_cv_t<element_type>;
+ using reference = element_type&;
+ using iterator = element_type*;
+ using const_iterator = const element_type*;
+ using reverse_iterator = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+ // Default constructor.
+ constexpr span() noexcept = default;
+
+ // Construct from pointer, size.
+ constexpr span(pointer data, size_type size) : detail::span_base<T, Size>(data, size) {}
+
+ // Copy constructor.
+ template <
+ typename U, std::size_t N,
+ typename = std::enable_if_t<detail::is_size_convertible_v<N, Size>>,
+ typename = std::enable_if_t<detail::is_element_type_convertible_v<U, T>>
+ >
+ constexpr span(span<U, N> const& other) : span(other.data(), other.size()) {}
+
+ // Copy assignment.
+ constexpr span& operator=(span const&) noexcept = default;
+
+ // Destructor.
+ ~span() = default;
+
+ // Construct from begin, end.
+ constexpr span(pointer begin, pointer end) : span(begin, end - begin) {}
+
+ // Construct from C array.
+ template <std::size_t N>
+ constexpr span(element_type(&arr)[N]) noexcept : span(std::data(arr), N) {}
+
+ // Construct from std::array.
+ template <
+ std::size_t N,
+ typename = std::enable_if_t<N != 0>
+ >
+ constexpr span(std::array<value_type, N>& arr) noexcept : span(std::data(arr), N) {}
+
+ // Construct from empty std::array.
+ constexpr span(std::array<value_type, 0>&) noexcept : span() {}
+
+ // Construct from const std::array.
+ template <
+ std::size_t N,
+ typename = std::enable_if_t<N != 0>
+ >
+ constexpr span(std::array<value_type, N> const& arr) noexcept : span(std::data(arr), N) {}
+
+ // Construct from empty const std::array.
+ constexpr span(std::array<value_type, 0> const&) noexcept : span() {}
+
+ // Construct from other container.
+ template <
+ typename Container,
+ typename = std::enable_if_t<!detail::is_span_v<Container>>,
+ typename = std::enable_if_t<!detail::is_std_array_v<Container>>,
+ typename = decltype(std::data(std::declval<Container>())),
+ typename = decltype(std::size(std::declval<Container>())),
+ typename = std::enable_if_t<std::is_convertible_v<typename Container::pointer, pointer>>,
+ typename = std::enable_if_t<std::is_convertible_v<typename Container::pointer, decltype(std::data(std::declval<Container>()))>>
+ >
+ constexpr span(Container& container) : span(std::data(container), std::size(container)) {}
+
+ // Construct from other const container.
+ template <
+ typename Container,
+ typename Element = element_type,
+ typename = std::enable_if_t<std::is_const_v<Element>>,
+ typename = std::enable_if_t<!detail::is_span_v<Container>>,
+ typename = std::enable_if_t<!detail::is_std_array_v<Container>>,
+ typename = decltype(std::data(std::declval<Container>())),
+ typename = decltype(std::size(std::declval<Container>())),
+ typename = std::enable_if_t<std::is_convertible_v<typename Container::pointer, pointer>>,
+ typename = std::enable_if_t<std::is_convertible_v<typename Container::pointer, decltype(std::data(std::declval<Container>()))>>
+ >
+ constexpr span(Container const& container) : span(std::data(container), std::size(container)) {}
+
+ [[nodiscard]] constexpr iterator begin() const noexcept { return this->data(); }
+ [[nodiscard]] constexpr const_iterator cbegin() const noexcept { return this->data(); }
+ [[nodiscard]] constexpr iterator end() const noexcept { return this->data() + this->size(); }
+ [[nodiscard]] constexpr const_iterator cend() const noexcept { return this->data() + this->size(); }
+ [[nodiscard]] constexpr reverse_iterator rbegin() const noexcept { return std::make_reverse_iterator(this->end()); }
+ [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept { return std::make_reverse_iterator(this->cend()); }
+ [[nodiscard]] constexpr reverse_iterator rend() const noexcept { return std::make_reverse_iterator(this->begin()); }
+ [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept { return std::make_reverse_iterator(this->cbegin()); }
+
+ [[nodiscard]] constexpr reference operator[](size_type i) const noexcept { assert(i < this->size()); return this->data()[i]; }
+ [[nodiscard]] constexpr reference operator()(size_type i) const noexcept { assert(i < this->size()); return this->data()[i]; }
+
+ [[nodiscard]] constexpr size_type size_bytes() const noexcept { return this->size() * sizeof(element_type); }
+ [[nodiscard]] constexpr bool empty() const noexcept { return this->size() == 0; }
+
+ [[nodiscard]] constexpr reference front() const noexcept { assert(!this->empty()); return this->data()[0]; }
+ [[nodiscard]] constexpr reference back() const noexcept { assert(!this->empty()); return this->data()[this->size() - 1]; }
+
+ template <std::size_t N>
+ [[nodiscard]] constexpr span<T, N> first() const {
+ static_assert(N != dynamic_size && N <= Size);
+ return {this->data(), N};
+ }
+
+ template <std::size_t N>
+ [[nodiscard]] constexpr span<T, N> last() const {
+ static_assert(N != dynamic_size && N <= Size);
+ return {this->data() + (Size - N), N};
+ }
+
+ template <std::size_t Offset, std::size_t N = dynamic_size>
+ [[nodiscard]] constexpr auto subspan() const -> detail::subspan_type_t<T, Size, Offset, N> {
+ static_assert(Offset <= Size);
+ return {this->data() + Offset, (N == dynamic_size) ? this->size() - Offset : N};
+ }
+
+ [[nodiscard]] constexpr span<T, dynamic_size> first(size_type n) const {
+ assert(n <= this->size());
+ return { this->data(), n };
+ }
+
+ [[nodiscard]] constexpr span<T, dynamic_size> last(size_type n) const {
+ return this->subspan(this->size() - n);
+ }
+
+ [[nodiscard]] constexpr span<T, dynamic_size> subspan(size_type offset, size_type n = dynamic_size) const {
+ if constexpr (Size == dynamic_size) {
+ assert(offset <= this->size());
+ if (n == dynamic_size) {
+ return { this->data() + offset, this->size() - offset };
+ }
+ assert(n <= this->size());
+ assert(offset + n <= this->size());
+ return {this->data() + offset, n};
+ } else {
+ return span<T, dynamic_size>{*this}.subspan(offset, n);
+ }
+ }
+};
+
+template <typename T, std::size_t LhsSize, std::size_t RhsSize>
+[[nodiscard]] constexpr bool operator==(span<T, LhsSize> lhs, span<T, RhsSize> rhs) {
+ return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+template <typename T, std::size_t LhsSize, std::size_t RhsSize>
+[[nodiscard]] constexpr bool operator!=(span<T, LhsSize> lhs, span<T, RhsSize> rhs) {
+ return !(lhs == rhs);
+}
+
+template <typename T, std::size_t LhsSize, std::size_t RhsSize>
+[[nodiscard]] constexpr bool operator<(span<T, LhsSize> lhs, span<T, RhsSize> rhs) {
+ return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+template <typename T, std::size_t LhsSize, std::size_t RhsSize>
+[[nodiscard]] constexpr bool operator<=(span<T, LhsSize> lhs, span<T, RhsSize> rhs) {
+ return !(lhs > rhs);
+}
+
+template <typename T, std::size_t LhsSize, std::size_t RhsSize>
+[[nodiscard]] constexpr bool operator>(span<T, LhsSize> lhs, span<T, RhsSize> rhs) {
+ return rhs < lhs;
+}
+
+template <typename T, std::size_t LhsSize, std::size_t RhsSize>
+[[nodiscard]] constexpr bool operator>=(span<T, LhsSize> lhs, span<T, RhsSize> rhs) {
+ return !(lhs < rhs);
+}
+
+template <typename Container>
+span(Container&) -> span<typename Container::value_type>;
+
+template <typename Container>
+span(Container const&) -> span<typename Container::value_type const>;
+
+template <typename T, std::size_t N>
+span(T(&)[N]) -> span<T, N>;
+
+template <typename T, std::size_t N>
+span(std::array<T, N>&) -> span<T, N>;
+
+template <typename T, std::size_t N>
+span(std::array<T, N> const&) -> span<T const, N>;
+
+template <typename T, typename Dummy>
+span(T, Dummy&&) -> span<std::remove_reference_t<decltype(std::declval<T>()[0])>>;
+
+} // namespace asic
+
+#endif // ASIC_SPAN_H
\ No newline at end of file
diff --git a/test/conftest.py b/test/conftest.py
index 48b49489424817e1439f6b2b6eb3d7cd63b29a75..63cf5ce1d0eb3d6652dc4eee14113aba98a3f2fc 100644
--- a/test/conftest.py
+++ b/test/conftest.py
@@ -2,4 +2,4 @@ from test.fixtures.signal import signal, signals
from test.fixtures.operation_tree import *
from test.fixtures.port import *
from test.fixtures.signal_flow_graph import *
-import pytest
+import pytest
\ No newline at end of file
diff --git a/test/fixtures/operation_tree.py b/test/fixtures/operation_tree.py
index fc8008fa4098ca488e23766f5ff7d05711300685..695979c65ab56eda3baf992b3b99963ee1fe7c9a 100644
--- a/test/fixtures/operation_tree.py
+++ b/test/fixtures/operation_tree.py
@@ -1,6 +1,6 @@
import pytest
-from b_asic import Addition, Constant, Signal
+from b_asic import Addition, Constant, Signal, Butterfly
@pytest.fixture
@@ -41,6 +41,41 @@ def large_operation_tree():
"""
return Addition(Addition(Constant(2), Constant(3)), Addition(Constant(4), Constant(5)))
+@pytest.fixture
+def large_operation_tree_names():
+ """Valid addition operation connected with a large operation tree with 2 other additions and 4 constants.
+ With names.
+ 2---+
+ |
+ v
+ add---+
+ ^ |
+ | |
+ 3---+ v
+ add = (2 + 3) + (4 + 5) = 14
+ 4---+ ^
+ | |
+ v |
+ add---+
+ ^
+ |
+ 5---+
+ """
+ return Addition(Addition(Constant(2, name="constant2"), Constant(3, name="constant3")), Addition(Constant(4, name="constant4"), Constant(5, name="constant5")))
+
+@pytest.fixture
+def butterfly_operation_tree():
+ """Valid butterfly operations connected to eachother with 3 butterfly operations and 2 constants as inputs and 2 outputs.
+ 2 ---+ +--- (2 + 4) ---+ +--- (6 + (-2)) ---+ +--- (4 + 8) ---> out1 = 12
+ | | | | | |
+ v ^ v ^ v ^
+ butterfly butterfly butterfly
+ ^ v ^ v ^ v
+ | | | | | |
+ 4 ---+ +--- (2 - 4) ---+ +--- (6 - (-2)) ---+ +--- (4 - 8) ---> out2 = -4
+ """
+ return Butterfly(*(Butterfly(*(Butterfly(Constant(2), Constant(4), name="bfly3").outputs), name="bfly2").outputs), name="bfly1")
+
@pytest.fixture
def operation_graph_with_cycle():
"""Invalid addition operation connected with an operation graph containing a cycle.
diff --git a/test/fixtures/signal_flow_graph.py b/test/fixtures/signal_flow_graph.py
index 7a8c4a73a62cf248c98993f5cf8c831bc986b8a7..a2c25ec9b10083b08c46543c7a5bfc30607560ef 100644
--- a/test/fixtures/signal_flow_graph.py
+++ b/test/fixtures/signal_flow_graph.py
@@ -1,12 +1,13 @@
import pytest
-from b_asic import SFG, Input, Output, Constant, Register, ConstantMultiplication
+from b_asic import SFG, Input, Output, Constant, Delay, Addition, ConstantMultiplication, Butterfly, AbstractOperation, Name, TypeName, SignalSourceProvider
+from typing import Optional
@pytest.fixture
def sfg_two_inputs_two_outputs():
"""Valid SFG with two inputs and two outputs.
- . .
+ . .
in1-------+ +--------->out1
. | | .
. v | .
@@ -17,17 +18,72 @@ def sfg_two_inputs_two_outputs():
| . ^ .
| . | .
+------------+ .
- . .
+ . .
out1 = in1 + in2
- out2 = in1 + 2 * in2
+ out2 = in1 + 2 * in2
"""
- in1 = Input()
- in2 = Input()
- add1 = in1 + in2
- add2 = add1 + in2
- out1 = Output(add1)
- out2 = Output(add2)
- return SFG(inputs = [in1, in2], outputs = [out1, out2])
+ in1 = Input("IN1")
+ in2 = Input("IN2")
+ add1 = Addition(in1, in2, "ADD1")
+ add2 = Addition(add1, in2, "ADD2")
+ out1 = Output(add1, "OUT1")
+ out2 = Output(add2, "OUT2")
+ return SFG(inputs=[in1, in2], outputs=[out1, out2])
+
+
+@pytest.fixture
+def sfg_two_inputs_two_outputs_independent():
+ """Valid SFG with two inputs and two outputs, where the first output only depends
+ on the first input and the second output only depends on the second input.
+ . .
+ in1-------------------->out1
+ . .
+ . .
+ . c1--+ .
+ . | .
+ . v .
+ in2------+ add1---->out2
+ . | ^ .
+ . | | .
+ . +------+ .
+ . .
+ out1 = in1
+ out2 = in2 + 3
+ """
+ in1 = Input("IN1")
+ in2 = Input("IN2")
+ c1 = Constant(3, "C1")
+ add1 = Addition(in2, c1, "ADD1")
+ out1 = Output(in1, "OUT1")
+ out2 = Output(add1, "OUT2")
+ return SFG(inputs=[in1, in2], outputs=[out1, out2])
+
+
+@pytest.fixture
+def sfg_two_inputs_two_outputs_independent_with_cmul():
+ """Valid SFG with two inputs and two outputs, where the first output only depends
+ on the first input and the second output only depends on the second input.
+ . .
+ in1--->cmul1--->cmul2--->out1
+ . .
+ . .
+ . c1 .
+ . | .
+ . v .
+ in2--->add1---->cmul3--->out2
+ . .
+ """
+ in1 = Input("IN1")
+ in2 = Input("IN2")
+ c1 = Constant(3, "C1")
+ add1 = Addition(in2, c1, "ADD1", 7)
+ cmul3 = ConstantMultiplication(2, add1, "CMUL3", 3)
+ cmul1 = ConstantMultiplication(5, in1, "CMUL1", 5)
+ cmul2 = ConstantMultiplication(4, cmul1, "CMUL2", 4)
+ out1 = Output(cmul2, "OUT1")
+ out2 = Output(cmul3, "OUT2")
+ return SFG(inputs=[in1, in2], outputs=[out1, out2])
+
@pytest.fixture
def sfg_nested():
@@ -38,7 +94,7 @@ def sfg_nested():
mac_in2 = Input()
mac_in3 = Input()
mac_out1 = Output(mac_in1 + mac_in2 * mac_in3)
- MAC = SFG(inputs = [mac_in1, mac_in2, mac_in3], outputs = [mac_out1])
+ MAC = SFG(inputs=[mac_in1, mac_in2, mac_in3], outputs=[mac_out1])
in1 = Input()
in2 = Input()
@@ -46,7 +102,8 @@ def sfg_nested():
mac2 = MAC(in1, in2, mac1)
mac3 = MAC(in1, mac1, mac2)
out1 = Output(mac3)
- return SFG(inputs = [in1, in2], outputs = [out1])
+ return SFG(inputs=[in1, in2], outputs=[out1])
+
@pytest.fixture
def sfg_delay():
@@ -54,8 +111,8 @@ def sfg_delay():
out1 = in1'
"""
in1 = Input()
- reg1 = Register(in1)
- out1 = Output(reg1)
+ t1 = Delay(in1)
+ out1 = Output(t1)
return SFG(inputs = [in1], outputs = [out1])
@pytest.fixture
@@ -65,24 +122,124 @@ def sfg_accumulator():
"""
data_in = Input()
reset = Input()
- reg = Register()
- reg.input(0).connect((reg + data_in) * (1 - reset))
- data_out = Output(reg)
+ t = Delay()
+ t << (t + data_in) * (1 - reset)
+ data_out = Output(t)
return SFG(inputs = [data_in, reset], outputs = [data_out])
+
+@pytest.fixture
+def sfg_simple_accumulator():
+ """Valid SFG with two inputs and one output.
+ . .
+ in1----->add1-----+----->out1
+ . ^ | .
+ . | | .
+ . +--t1<--+ .
+ . .
+ """
+ in1 = Input()
+ t1 = Delay()
+ add1 = in1 + t1
+ t1 << add1
+ out1 = Output(add1)
+ return SFG(inputs = [in1], outputs = [out1])
+
@pytest.fixture
-def simple_filter():
+def sfg_simple_filter():
"""A valid SFG that is used as a filter in the first lab for TSTE87.
- +----<constmul1----+
- | |
- | |
- in1>------add1>------reg>------+------out1>
+ . .
+ . +--cmul1<--+ .
+ . | | .
+ . v | .
+ in1---->add1----->t1+---->out1
+ . .
"""
+ in1 = Input("IN1")
+ cmul1 = ConstantMultiplication(0.5, name="CMUL1")
+ add1 = Addition(in1, cmul1, "ADD1")
+ add1.input(1).signals[0].name = "S2"
+ t1 = Delay(add1, name="T1")
+ cmul1.input(0).connect(t1, "S1")
+ out1 = Output(t1, "OUT1")
+ return SFG(inputs=[in1], outputs=[out1], name="simple_filter")
+
+@pytest.fixture
+def sfg_custom_operation():
+ """A valid SFG containing a custom operation."""
+ class CustomOperation(AbstractOperation):
+ def __init__(self, src0: Optional[SignalSourceProvider] = None, name: Name = ""):
+ super().__init__(input_count = 1, output_count = 2, name = name, input_sources = [src0])
+
+ @classmethod
+ def type_name(self) -> TypeName:
+ return "custom"
+
+ def evaluate(self, a):
+ return a * 2, 2 ** a
+
in1 = Input()
- reg = Register()
- constmul1 = ConstantMultiplication(0.5)
- add1 = in1 + constmul1
- reg.input(0).connect(add1)
- constmul1.input(0).connect(reg)
- out1 = Output(reg)
- return SFG(inputs=[in1], outputs=[out1])
+ custom1 = CustomOperation(in1)
+ out1 = Output(custom1.output(0))
+ out2 = Output(custom1.output(1))
+ return SFG(inputs=[in1], outputs=[out1, out2])
+
+
+@pytest.fixture
+def precedence_sfg_delays():
+ """A sfg with delays and interesting layout for precednce list generation.
+ . .
+ IN1>--->C0>--->ADD1>--->Q1>---+--->A0>--->ADD4>--->OUT1
+ . ^ | ^ .
+ . | T1 | .
+ . | | | .
+ . ADD2<---<B1<---+--->A1>--->ADD3 .
+ . ^ | ^ .
+ . | T2 | .
+ . | | | .
+ . +-----<B2<---+--->A2>-----+ .
+ """
+ in1 = Input("IN1")
+ c0 = ConstantMultiplication(5, in1, "C0")
+ add1 = Addition(c0, None, "ADD1")
+ # Not sure what operation "Q" is supposed to be in the example
+ Q1 = ConstantMultiplication(1, add1, "Q1")
+ T1 = Delay(Q1, 0, "T1")
+ T2 = Delay(T1, 0, "T2")
+ b2 = ConstantMultiplication(2, T2, "B2")
+ b1 = ConstantMultiplication(3, T1, "B1")
+ add2 = Addition(b1, b2, "ADD2")
+ add1.input(1).connect(add2)
+ a1 = ConstantMultiplication(4, T1, "A1")
+ a2 = ConstantMultiplication(6, T2, "A2")
+ add3 = Addition(a1, a2, "ADD3")
+ a0 = ConstantMultiplication(7, Q1, "A0")
+ add4 = Addition(a0, add3, "ADD4")
+ out1 = Output(add4, "OUT1")
+
+ return SFG(inputs=[in1], outputs=[out1], name="SFG")
+
+
+@pytest.fixture
+def precedence_sfg_delays_and_constants():
+ in1 = Input("IN1")
+ c0 = ConstantMultiplication(5, in1, "C0")
+ add1 = Addition(c0, None, "ADD1")
+ # Not sure what operation "Q" is supposed to be in the example
+ Q1 = ConstantMultiplication(1, add1, "Q1")
+ T1 = Delay(Q1, 0, "T1")
+ const1 = Constant(10, "CONST1") # Replace T2 delay with a constant
+ b2 = ConstantMultiplication(2, const1, "B2")
+ b1 = ConstantMultiplication(3, T1, "B1")
+ add2 = Addition(b1, b2, "ADD2")
+ add1.input(1).connect(add2)
+ a1 = ConstantMultiplication(4, T1, "A1")
+ a2 = ConstantMultiplication(10, const1, "A2")
+ add3 = Addition(a1, a2, "ADD3")
+ a0 = ConstantMultiplication(7, Q1, "A0")
+ # Replace ADD4 with a butterfly to test multiple output ports
+ bfly1 = Butterfly(a0, add3, "BFLY1")
+ out1 = Output(bfly1.output(0), "OUT1")
+ Output(bfly1.output(1), "OUT2")
+
+ return SFG(inputs=[in1], outputs=[out1], name="SFG")
diff --git a/test/test_abstract_operation.py b/test/test_abstract_operation.py
deleted file mode 100644
index 5423ecdf08c420df5dccc6393c3ad6637961172b..0000000000000000000000000000000000000000
--- a/test/test_abstract_operation.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""
-B-ASIC test suite for the AbstractOperation class.
-"""
-
-import pytest
-
-from b_asic import Addition, Subtraction, Multiplication, ConstantMultiplication, Division
-
-
-def test_addition_overload():
- """Tests addition overloading for both operation and number argument."""
- add1 = Addition(None, None, "add1")
- add2 = Addition(None, None, "add2")
-
- add3 = add1 + add2
- assert isinstance(add3, Addition)
- assert add3.input(0).signals == add1.output(0).signals
- assert add3.input(1).signals == add2.output(0).signals
-
- add4 = add3 + 5
- assert isinstance(add4, Addition)
- assert add4.input(0).signals == add3.output(0).signals
- assert add4.input(1).signals[0].source.operation.value == 5
-
- add5 = 5 + add4
- assert isinstance(add5, Addition)
- assert add5.input(0).signals[0].source.operation.value == 5
- assert add5.input(1).signals == add4.output(0).signals
-
-
-def test_subtraction_overload():
- """Tests subtraction overloading for both operation and number argument."""
- add1 = Addition(None, None, "add1")
- add2 = Addition(None, None, "add2")
-
- sub1 = add1 - add2
- assert isinstance(sub1, Subtraction)
- assert sub1.input(0).signals == add1.output(0).signals
- assert sub1.input(1).signals == add2.output(0).signals
-
- sub2 = sub1 - 5
- assert isinstance(sub2, Subtraction)
- assert sub2.input(0).signals == sub1.output(0).signals
- assert sub2.input(1).signals[0].source.operation.value == 5
-
- sub3 = 5 - sub2
- assert isinstance(sub3, Subtraction)
- assert sub3.input(0).signals[0].source.operation.value == 5
- assert sub3.input(1).signals == sub2.output(0).signals
-
-
-def test_multiplication_overload():
- """Tests multiplication overloading for both operation and number argument."""
- add1 = Addition(None, None, "add1")
- add2 = Addition(None, None, "add2")
-
- mul1 = add1 * add2
- assert isinstance(mul1, Multiplication)
- assert mul1.input(0).signals == add1.output(0).signals
- assert mul1.input(1).signals == add2.output(0).signals
-
- mul2 = mul1 * 5
- assert isinstance(mul2, ConstantMultiplication)
- assert mul2.input(0).signals == mul1.output(0).signals
- assert mul2.value == 5
-
- mul3 = 5 * mul2
- assert isinstance(mul3, ConstantMultiplication)
- assert mul3.input(0).signals == mul2.output(0).signals
- assert mul3.value == 5
-
-
-def test_division_overload():
- """Tests division overloading for both operation and number argument."""
- add1 = Addition(None, None, "add1")
- add2 = Addition(None, None, "add2")
-
- div1 = add1 / add2
- assert isinstance(div1, Division)
- assert div1.input(0).signals == add1.output(0).signals
- assert div1.input(1).signals == add2.output(0).signals
-
- div2 = div1 / 5
- assert isinstance(div2, Division)
- assert div2.input(0).signals == div1.output(0).signals
- assert div2.input(1).signals[0].source.operation.value == 5
-
- div3 = 5 / div2
- assert isinstance(div3, Division)
- assert div3.input(0).signals[0].source.operation.value == 5
- assert div3.input(1).signals == div2.output(0).signals
-
diff --git a/test/test_core_operations.py b/test/test_core_operations.py
index 4d0039b558e81c5cd74f151f93f0bc0194a702d5..6a0493c60965579bd843e0b514bd7f9b9a0e4707 100644
--- a/test/test_core_operations.py
+++ b/test/test_core_operations.py
@@ -6,7 +6,6 @@ from b_asic import \
Constant, Addition, Subtraction, Multiplication, ConstantMultiplication, Division, \
SquareRoot, ComplexConjugate, Max, Min, Absolute, Butterfly
-
class TestConstant:
def test_constant_positive(self):
test_operation = Constant(3)
@@ -164,3 +163,14 @@ class TestButterfly:
test_operation = Butterfly()
assert test_operation.evaluate_output(0, [2+1j, 3-2j]) == 5-1j
assert test_operation.evaluate_output(1, [2+1j, 3-2j]) == -1+3j
+
+
+class TestDepends:
+ def test_depends_addition(self):
+ add1 = Addition()
+ assert set(add1.inputs_required_for_output(0)) == {0, 1}
+
+ def test_depends_butterfly(self):
+ bfly1 = Butterfly()
+ assert set(bfly1.inputs_required_for_output(0)) == {0, 1}
+ assert set(bfly1.inputs_required_for_output(1)) == {0, 1}
diff --git a/test/test_fast_simulation.py b/test/test_fast_simulation.py
new file mode 100644
index 0000000000000000000000000000000000000000..6eb3b251bec6a2c556230dbedcb8f712c9f56d48
--- /dev/null
+++ b/test/test_fast_simulation.py
@@ -0,0 +1,226 @@
+import pytest
+import numpy as np
+
+from b_asic import SFG, Output, FastSimulation, Addition, Subtraction, Constant, Butterfly
+
+
+class TestRunFor:
+ def test_with_lambdas_as_input(self, sfg_two_inputs_two_outputs):
+ simulation = FastSimulation(sfg_two_inputs_two_outputs, [lambda n: n + 3, lambda n: 1 + n * 2])
+
+ output = simulation.run_for(101, save_results = True)
+
+ assert output[0] == 304
+ assert output[1] == 505
+
+ assert simulation.results["0"][100] == 304
+ assert simulation.results["1"][100] == 505
+
+ assert simulation.results["in1"][0] == 3
+ assert simulation.results["in2"][0] == 1
+ assert simulation.results["add1"][0] == 4
+ assert simulation.results["add2"][0] == 5
+ assert simulation.results["0"][0] == 4
+ assert simulation.results["1"][0] == 5
+
+ assert simulation.results["in1"][1] == 4
+ assert simulation.results["in2"][1] == 3
+ assert simulation.results["add1"][1] == 7
+ assert simulation.results["add2"][1] == 10
+ assert simulation.results["0"][1] == 7
+ assert simulation.results["1"][1] == 10
+
+ assert simulation.results["in1"][2] == 5
+ assert simulation.results["in2"][2] == 5
+ assert simulation.results["add1"][2] == 10
+ assert simulation.results["add2"][2] == 15
+ assert simulation.results["0"][2] == 10
+ assert simulation.results["1"][2] == 15
+
+ assert simulation.results["in1"][3] == 6
+ assert simulation.results["in2"][3] == 7
+ assert simulation.results["add1"][3] == 13
+ assert simulation.results["add2"][3] == 20
+ assert simulation.results["0"][3] == 13
+ assert simulation.results["1"][3] == 20
+
+ def test_with_numpy_arrays_as_input(self, sfg_two_inputs_two_outputs):
+ input0 = np.array([5, 9, 25, -5, 7])
+ input1 = np.array([7, 3, 3, 54, 2])
+ simulation = FastSimulation(sfg_two_inputs_two_outputs, [input0, input1])
+
+ output = simulation.run_for(5, save_results = True)
+
+ assert output[0] == 9
+ assert output[1] == 11
+
+ assert isinstance(simulation.results["in1"], np.ndarray)
+ assert isinstance(simulation.results["in2"], np.ndarray)
+ assert isinstance(simulation.results["add1"], np.ndarray)
+ assert isinstance(simulation.results["add2"], np.ndarray)
+ assert isinstance(simulation.results["0"], np.ndarray)
+ assert isinstance(simulation.results["1"], np.ndarray)
+
+ assert simulation.results["in1"][0] == 5
+ assert simulation.results["in2"][0] == 7
+ assert simulation.results["add1"][0] == 12
+ assert simulation.results["add2"][0] == 19
+ assert simulation.results["0"][0] == 12
+ assert simulation.results["1"][0] == 19
+
+ assert simulation.results["in1"][1] == 9
+ assert simulation.results["in2"][1] == 3
+ assert simulation.results["add1"][1] == 12
+ assert simulation.results["add2"][1] == 15
+ assert simulation.results["0"][1] == 12
+ assert simulation.results["1"][1] == 15
+
+ assert simulation.results["in1"][2] == 25
+ assert simulation.results["in2"][2] == 3
+ assert simulation.results["add1"][2] == 28
+ assert simulation.results["add2"][2] == 31
+ assert simulation.results["0"][2] == 28
+ assert simulation.results["1"][2] == 31
+
+ assert simulation.results["in1"][3] == -5
+ assert simulation.results["in2"][3] == 54
+ assert simulation.results["add1"][3] == 49
+ assert simulation.results["add2"][3] == 103
+ assert simulation.results["0"][3] == 49
+ assert simulation.results["1"][3] == 103
+
+ assert simulation.results["0"][4] == 9
+ assert simulation.results["1"][4] == 11
+
+ def test_with_numpy_array_overflow(self, sfg_two_inputs_two_outputs):
+ input0 = np.array([5, 9, 25, -5, 7])
+ input1 = np.array([7, 3, 3, 54, 2])
+ simulation = FastSimulation(sfg_two_inputs_two_outputs, [input0, input1])
+ simulation.run_for(5)
+ with pytest.raises(IndexError):
+ simulation.step()
+
+ def test_run_whole_numpy_array(self, sfg_two_inputs_two_outputs):
+ input0 = np.array([5, 9, 25, -5, 7])
+ input1 = np.array([7, 3, 3, 54, 2])
+ simulation = FastSimulation(sfg_two_inputs_two_outputs, [input0, input1])
+ simulation.run()
+ assert len(simulation.results["0"]) == 5
+ assert len(simulation.results["1"]) == 5
+ with pytest.raises(IndexError):
+ simulation.step()
+
+ def test_delay(self, sfg_delay):
+ simulation = FastSimulation(sfg_delay)
+ simulation.set_input(0, [5, -2, 25, -6, 7, 0])
+ simulation.run_for(6, save_results = True)
+
+ assert simulation.results["0"][0] == 0
+ assert simulation.results["0"][1] == 5
+ assert simulation.results["0"][2] == -2
+ assert simulation.results["0"][3] == 25
+ assert simulation.results["0"][4] == -6
+ assert simulation.results["0"][5] == 7
+
+class TestRun:
+ def test_save_results(self, sfg_two_inputs_two_outputs):
+ simulation = FastSimulation(sfg_two_inputs_two_outputs, [2, 3])
+ assert not simulation.results
+ simulation.run_for(10, save_results = False)
+ assert not simulation.results
+ simulation.run_for(10)
+ assert len(simulation.results["0"]) == 10
+ assert len(simulation.results["1"]) == 10
+ simulation.run_for(10, save_results = True)
+ assert len(simulation.results["0"]) == 20
+ assert len(simulation.results["1"]) == 20
+ simulation.run_for(10, save_results = False)
+ assert len(simulation.results["0"]) == 20
+ assert len(simulation.results["1"]) == 20
+ simulation.run_for(13, save_results = True)
+ assert len(simulation.results["0"]) == 33
+ assert len(simulation.results["1"]) == 33
+ simulation.step(save_results = False)
+ assert len(simulation.results["0"]) == 33
+ assert len(simulation.results["1"]) == 33
+ simulation.step()
+ assert len(simulation.results["0"]) == 34
+ assert len(simulation.results["1"]) == 34
+ simulation.clear_results()
+ assert not simulation.results
+
+ def test_nested(self, sfg_nested):
+ input0 = np.array([5, 9])
+ input1 = np.array([7, 3])
+ simulation = FastSimulation(sfg_nested, [input0, input1])
+
+ output0 = simulation.step()
+ output1 = simulation.step()
+
+ assert output0[0] == 11405
+ assert output1[0] == 4221
+
+ def test_accumulator(self, sfg_accumulator):
+ data_in = np.array([5, -2, 25, -6, 7, 0])
+ reset = np.array([0, 0, 0, 1, 0, 0])
+ simulation = FastSimulation(sfg_accumulator, [data_in, reset])
+ output0 = simulation.step()
+ output1 = simulation.step()
+ output2 = simulation.step()
+ output3 = simulation.step()
+ output4 = simulation.step()
+ output5 = simulation.step()
+ assert output0[0] == 0
+ assert output1[0] == 5
+ assert output2[0] == 3
+ assert output3[0] == 28
+ assert output4[0] == 0
+ assert output5[0] == 7
+
+ def test_simple_accumulator(self, sfg_simple_accumulator):
+ data_in = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ simulation = FastSimulation(sfg_simple_accumulator, [data_in])
+ simulation.run()
+ assert list(simulation.results["0"]) == [0, 1, 3, 6, 10, 15, 21, 28, 36, 45]
+
+ def test_simple_filter(self, sfg_simple_filter):
+ input0 = np.array([1, 2, 3, 4, 5])
+ simulation = FastSimulation(sfg_simple_filter, [input0])
+ simulation.run_for(len(input0), save_results = True)
+ assert all(simulation.results["0"] == np.array([0, 1.0, 2.5, 4.25, 6.125]))
+
+ def test_custom_operation(self, sfg_custom_operation):
+ simulation = FastSimulation(sfg_custom_operation, [lambda n: n + 1])
+ simulation.run_for(5)
+ assert all(simulation.results["0"] == np.array([2, 4, 6, 8, 10]))
+ assert all(simulation.results["1"] == np.array([2, 4, 8, 16, 32]))
+
+
+class TestLarge:
+ def test_1k_additions(self):
+ prev_op = Addition(Constant(1), Constant(1))
+ for _ in range(999):
+ prev_op = Addition(prev_op, Constant(2))
+ sfg = SFG(outputs=[Output(prev_op)])
+ simulation = FastSimulation(sfg, [])
+ assert simulation.step()[0] == 2000
+
+ def test_1k_subtractions(self):
+ prev_op = Subtraction(Constant(0), Constant(2))
+ for _ in range(999):
+ prev_op = Subtraction(prev_op, Constant(2))
+ sfg = SFG(outputs=[Output(prev_op)])
+ simulation = FastSimulation(sfg, [])
+ assert simulation.step()[0] == -2000
+
+ def test_1k_butterfly(self):
+ prev_op_add = Addition(Constant(1), Constant(1))
+ prev_op_sub = Subtraction(Constant(-1), Constant(1))
+ for _ in range(499):
+ prev_op_add = Addition(prev_op_add, Constant(2))
+ for _ in range(499):
+ prev_op_sub = Subtraction(prev_op_sub, Constant(2))
+ butterfly = Butterfly(prev_op_add, prev_op_sub)
+ sfg = SFG(outputs=[Output(butterfly.output(0)), Output(butterfly.output(1))])
+ simulation = FastSimulation(sfg, [])
+ assert list(simulation.step()) == [0, 2000]
\ No newline at end of file
diff --git a/test/test_operation.py b/test/test_operation.py
index b76ba16d11425c0ce868e4fa0b4c88d9f862e23f..f4af81b57b8d30fe71025ab82f75f57f195ce350 100644
--- a/test/test_operation.py
+++ b/test/test_operation.py
@@ -1,6 +1,94 @@
+"""
+B-ASIC test suite for the AbstractOperation class.
+"""
+
import pytest
-from b_asic import Constant, Addition
+from b_asic import Addition, Subtraction, Multiplication, ConstantMultiplication, Division, Constant, Butterfly, \
+ MAD, SquareRoot
+
+
+class TestOperationOverloading:
+ def test_addition_overload(self):
+ """Tests addition overloading for both operation and number argument."""
+ add1 = Addition(None, None, "add1")
+ add2 = Addition(None, None, "add2")
+
+ add3 = add1 + add2
+ assert isinstance(add3, Addition)
+ assert add3.input(0).signals == add1.output(0).signals
+ assert add3.input(1).signals == add2.output(0).signals
+
+ add4 = add3 + 5
+ assert isinstance(add4, Addition)
+ assert add4.input(0).signals == add3.output(0).signals
+ assert add4.input(1).signals[0].source.operation.value == 5
+
+ add5 = 5 + add4
+ assert isinstance(add5, Addition)
+ assert add5.input(0).signals[0].source.operation.value == 5
+ assert add5.input(1).signals == add4.output(0).signals
+
+ def test_subtraction_overload(self):
+ """Tests subtraction overloading for both operation and number argument."""
+ add1 = Addition(None, None, "add1")
+ add2 = Addition(None, None, "add2")
+
+ sub1 = add1 - add2
+ assert isinstance(sub1, Subtraction)
+ assert sub1.input(0).signals == add1.output(0).signals
+ assert sub1.input(1).signals == add2.output(0).signals
+
+ sub2 = sub1 - 5
+ assert isinstance(sub2, Subtraction)
+ assert sub2.input(0).signals == sub1.output(0).signals
+ assert sub2.input(1).signals[0].source.operation.value == 5
+
+ sub3 = 5 - sub2
+ assert isinstance(sub3, Subtraction)
+ assert sub3.input(0).signals[0].source.operation.value == 5
+ assert sub3.input(1).signals == sub2.output(0).signals
+
+ def test_multiplication_overload(self):
+ """Tests multiplication overloading for both operation and number argument."""
+ add1 = Addition(None, None, "add1")
+ add2 = Addition(None, None, "add2")
+
+ mul1 = add1 * add2
+ assert isinstance(mul1, Multiplication)
+ assert mul1.input(0).signals == add1.output(0).signals
+ assert mul1.input(1).signals == add2.output(0).signals
+
+ mul2 = mul1 * 5
+ assert isinstance(mul2, ConstantMultiplication)
+ assert mul2.input(0).signals == mul1.output(0).signals
+ assert mul2.value == 5
+
+ mul3 = 5 * mul2
+ assert isinstance(mul3, ConstantMultiplication)
+ assert mul3.input(0).signals == mul2.output(0).signals
+ assert mul3.value == 5
+
+ def test_division_overload(self):
+ """Tests division overloading for both operation and number argument."""
+ add1 = Addition(None, None, "add1")
+ add2 = Addition(None, None, "add2")
+
+ div1 = add1 / add2
+ assert isinstance(div1, Division)
+ assert div1.input(0).signals == add1.output(0).signals
+ assert div1.input(1).signals == add2.output(0).signals
+
+ div2 = div1 / 5
+ assert isinstance(div2, Division)
+ assert div2.input(0).signals == div1.output(0).signals
+ assert div2.input(1).signals[0].source.operation.value == 5
+
+ div3 = 5 / div2
+ assert isinstance(div3, Division)
+ assert div3.input(0).signals[0].source.operation.value == 5
+ assert div3.input(1).signals == div2.output(0).signals
+
class TestTraverse:
def test_traverse_single_tree(self, operation):
@@ -22,4 +110,77 @@ class TestTraverse:
assert len(list(filter(lambda type_: isinstance(type_, Constant), result))) == 4
def test_traverse_loop(self, operation_graph_with_cycle):
- assert len(list(operation_graph_with_cycle.traverse())) == 8
\ No newline at end of file
+ assert len(list(operation_graph_with_cycle.traverse())) == 8
+
+
+class TestToSfg:
+ def test_convert_mad_to_sfg(self):
+ mad1 = MAD()
+ mad1_sfg = mad1.to_sfg()
+
+ assert mad1.evaluate(1, 1, 1) == mad1_sfg.evaluate(1, 1, 1)
+ assert len(mad1_sfg.operations) == 6
+
+ def test_butterfly_to_sfg(self):
+ but1 = Butterfly()
+ but1_sfg = but1.to_sfg()
+
+ assert but1.evaluate(1, 1)[0] == but1_sfg.evaluate(1, 1)[0]
+ assert but1.evaluate(1, 1)[1] == but1_sfg.evaluate(1, 1)[1]
+ assert len(but1_sfg.operations) == 8
+
+ def test_add_to_sfg(self):
+ add1 = Addition()
+ add1_sfg = add1.to_sfg()
+
+ assert len(add1_sfg.operations) == 4
+
+ def test_sqrt_to_sfg(self):
+ sqrt1 = SquareRoot()
+ sqrt1_sfg = sqrt1.to_sfg()
+
+ assert len(sqrt1_sfg.operations) == 3
+
+
+class TestLatency:
+ def test_latency_constructor(self):
+ bfly = Butterfly(latency=5)
+
+ assert bfly.latency == 5
+ assert bfly.latency_offsets == {'in0': 0, 'in1': 0, 'out0': 5, 'out1': 5}
+
+ def test_latency_offsets_constructor(self):
+ bfly = Butterfly(latency_offsets={'in0': 2, 'in1': 3, 'out0': 5, 'out1': 10})
+
+ assert bfly.latency == 8
+ assert bfly.latency_offsets == {'in0': 2, 'in1': 3, 'out0': 5, 'out1': 10}
+
+ def test_latency_and_latency_offsets_constructor(self):
+ bfly = Butterfly(latency=5, latency_offsets={'in1': 2, 'out0': 9})
+
+ assert bfly.latency == 9
+ assert bfly.latency_offsets == {"in0": 0, "in1": 2, "out0": 9, "out1": 5}
+
+ def test_set_latency(self):
+ bfly = Butterfly()
+
+ bfly.set_latency(9)
+
+ assert bfly.latency == 9
+ assert bfly.latency_offsets == {"in0": 0, "in1": 0, "out0": 9, "out1": 9}
+
+ def test_set_latency_offsets(self):
+ bfly = Butterfly()
+
+ bfly.set_latency_offsets({'in0': 3, 'out1': 5})
+
+ assert bfly.latency_offsets == {'in0': 3, "in1": None, "out0": None, 'out1': 5}
+
+
+class TestCopyOperation:
+ def test_copy_buttefly_latency_offsets(self):
+ bfly = Butterfly(latency_offsets={'in0': 4, 'in1': 2, 'out0': 10, 'out1': 9})
+
+ bfly_copy = bfly.copy_component()
+
+ assert bfly_copy.latency_offsets == {'in0': 4, 'in1': 2, 'out0': 10, 'out1': 9}
diff --git a/test/test_schema.py b/test/test_schema.py
new file mode 100644
index 0000000000000000000000000000000000000000..78a713a9ceda574feede72f48bacf02e6a9c4025
--- /dev/null
+++ b/test/test_schema.py
@@ -0,0 +1,67 @@
+"""
+B-ASIC test suite for the schema module and Schema class.
+"""
+
+from b_asic import Schema, Addition, ConstantMultiplication
+
+
+class TestInit:
+ def test_simple_filter_normal_latency(self, sfg_simple_filter):
+ sfg_simple_filter.set_latency_of_type(Addition.type_name(), 5)
+ sfg_simple_filter.set_latency_of_type(ConstantMultiplication.type_name(), 4)
+
+ schema = Schema(sfg_simple_filter)
+
+ assert schema._start_times == {"add1": 4, "cmul1": 0}
+
+ def test_complicated_single_outputs_normal_latency(self, precedence_sfg_delays):
+ precedence_sfg_delays.set_latency_of_type(Addition.type_name(), 4)
+ precedence_sfg_delays.set_latency_of_type(ConstantMultiplication.type_name(), 3)
+
+ schema = Schema(precedence_sfg_delays, scheduling_alg="ASAP")
+
+ for op in schema._sfg.get_operations_topological_order():
+ print(op.latency_offsets)
+
+ start_times_names = dict()
+ for op_id, start_time in schema._start_times.items():
+ op_name = precedence_sfg_delays.find_by_id(op_id).name
+ start_times_names[op_name] = start_time
+
+ assert start_times_names == {"C0": 0, "B1": 0, "B2": 0, "ADD2": 3, "ADD1": 7, "Q1": 11,
+ "A0": 14, "A1": 0, "A2": 0, "ADD3": 3, "ADD4": 17}
+
+ def test_complicated_single_outputs_complex_latencies(self, precedence_sfg_delays):
+ precedence_sfg_delays.set_latency_offsets_of_type(ConstantMultiplication.type_name(), {'in0': 3, 'out0': 5})
+
+ precedence_sfg_delays.find_by_name("B1")[0].set_latency_offsets({'in0': 4, 'out0': 7})
+ precedence_sfg_delays.find_by_name("B2")[0].set_latency_offsets({'in0': 1, 'out0': 4})
+ precedence_sfg_delays.find_by_name("ADD2")[0].set_latency_offsets({'in0': 4, 'in1': 2, 'out0': 4})
+ precedence_sfg_delays.find_by_name("ADD1")[0].set_latency_offsets({'in0': 1, 'in1': 2, 'out0': 4})
+ precedence_sfg_delays.find_by_name("Q1")[0].set_latency_offsets({'in0': 3, 'out0': 6})
+ precedence_sfg_delays.find_by_name("A0")[0].set_latency_offsets({'in0': 0, 'out0': 2})
+
+ precedence_sfg_delays.find_by_name("A1")[0].set_latency_offsets({'in0': 0, 'out0': 5})
+ precedence_sfg_delays.find_by_name("A2")[0].set_latency_offsets({'in0': 2, 'out0': 3})
+ precedence_sfg_delays.find_by_name("ADD3")[0].set_latency_offsets({'in0': 2, 'in1': 1, 'out0': 4})
+ precedence_sfg_delays.find_by_name("ADD4")[0].set_latency_offsets({'in0': 6, 'in1': 7, 'out0': 9})
+
+ schema = Schema(precedence_sfg_delays, scheduling_alg="ASAP")
+
+ start_times_names = dict()
+ for op_id, start_time in schema._start_times.items():
+ op_name = precedence_sfg_delays.find_by_id(op_id).name
+ start_times_names[op_name] = start_time
+
+ assert start_times_names == {'C0': 0, 'B1': 0, 'B2': 0, 'ADD2': 3, 'ADD1': 5, 'Q1': 6, 'A0': 12,
+ 'A1': 0, 'A2': 0, 'ADD3': 3, 'ADD4': 8}
+
+ def test_independent_sfg(self, sfg_two_inputs_two_outputs_independent_with_cmul):
+ schema = Schema(sfg_two_inputs_two_outputs_independent_with_cmul, scheduling_alg="ASAP")
+
+ start_times_names = dict()
+ for op_id, start_time in schema._start_times.items():
+ op_name = sfg_two_inputs_two_outputs_independent_with_cmul.find_by_id(op_id).name
+ start_times_names[op_name] = start_time
+
+ assert start_times_names == {'CMUL1': 0, 'CMUL2': 5, "ADD1": 0, "CMUL3": 7}
diff --git a/test/test_sfg.py b/test/test_sfg.py
index 222bfe237d287891eaf72442e83cec5c4012178c..f534143bc83f7a0afdb000fd4563429490334b71 100644
--- a/test/test_sfg.py
+++ b/test/test_sfg.py
@@ -1,6 +1,15 @@
+from os import path, remove
import pytest
+import random
+import string
+import io
+import sys
-from b_asic import SFG, Signal, Input, Output, Constant, Addition, Multiplication
+
+from b_asic import SFG, Signal, Input, Output, Constant, ConstantMultiplication, Addition, Multiplication, Delay, \
+ Butterfly, Subtraction, SquareRoot
+
+from b_asic.save_load_structure import sfg_to_python, python_to_sfg
class TestInit:
@@ -9,7 +18,7 @@ class TestInit:
out1 = Output(None, "OUT1")
out1.input(0).connect(in1, "S1")
- sfg = SFG(inputs = [in1], outputs = [out1]) # in1 ---s1---> out1
+ sfg = SFG(inputs=[in1], outputs=[out1]) # in1 ---s1---> out1
assert len(list(sfg.components)) == 3
assert len(list(sfg.operations)) == 2
@@ -22,7 +31,8 @@ class TestInit:
s1 = add2.input(0).connect(add1, "S1")
- sfg = SFG(input_signals = [s1], output_signals = [s1]) # in1 ---s1---> out1
+ # in1 ---s1---> out1
+ sfg = SFG(input_signals=[s1], output_signals=[s1])
assert len(list(sfg.components)) == 3
assert len(list(sfg.operations)) == 2
@@ -30,7 +40,7 @@ class TestInit:
assert sfg.output_count == 1
def test_outputs_construction(self, operation_tree):
- sfg = SFG(outputs = [Output(operation_tree)])
+ sfg = SFG(outputs=[Output(operation_tree)])
assert len(list(sfg.components)) == 7
assert len(list(sfg.operations)) == 4
@@ -38,26 +48,31 @@ class TestInit:
assert sfg.output_count == 1
def test_signals_construction(self, operation_tree):
- sfg = SFG(output_signals = [Signal(source = operation_tree.output(0))])
+ sfg = SFG(output_signals=[Signal(source=operation_tree.output(0))])
assert len(list(sfg.components)) == 7
assert len(list(sfg.operations)) == 4
assert sfg.input_count == 0
assert sfg.output_count == 1
+
class TestPrintSfg:
def test_one_addition(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
add1 = Addition(inp1, inp2, "ADD1")
out1 = Output(add1, "OUT1")
- sfg = SFG(inputs=[inp1, inp2], outputs=[out1], name="sf1")
+ sfg = SFG(inputs=[inp1, inp2], outputs=[out1], name="SFG1")
assert sfg.__str__() == \
- "id: add1, name: ADD1, input: [s1, s2], output: [s3]\n" + \
- "id: in1, name: INP1, input: [], output: [s1]\n" + \
- "id: in2, name: INP2, input: [], output: [s2]\n" + \
- "id: out1, name: OUT1, input: [s3], output: []\n"
+ "id: no_id, \tname: SFG1, \tinputs: {0: '-'}, \toutputs: {0: '-'}\n" + \
+ "Internal Operations:\n" + \
+ "----------------------------------------------------------------------------------------------------\n" + \
+ str(sfg.find_by_name("INP1")[0]) + "\n" + \
+ str(sfg.find_by_name("INP2")[0]) + "\n" + \
+ str(sfg.find_by_name("ADD1")[0]) + "\n" + \
+ str(sfg.find_by_name("OUT1")[0]) + "\n" + \
+ "----------------------------------------------------------------------------------------------------\n"
def test_add_mul(self):
inp1 = Input("INP1")
@@ -69,12 +84,16 @@ class TestPrintSfg:
sfg = SFG(inputs=[inp1, inp2, inp3], outputs=[out1], name="mac_sfg")
assert sfg.__str__() == \
- "id: add1, name: ADD1, input: [s1, s2], output: [s5]\n" + \
- "id: in1, name: INP1, input: [], output: [s1]\n" + \
- "id: in2, name: INP2, input: [], output: [s2]\n" + \
- "id: mul1, name: MUL1, input: [s5, s3], output: [s4]\n" + \
- "id: in3, name: INP3, input: [], output: [s3]\n" + \
- "id: out1, name: OUT1, input: [s4], output: []\n"
+ "id: no_id, \tname: mac_sfg, \tinputs: {0: '-'}, \toutputs: {0: '-'}\n" + \
+ "Internal Operations:\n" + \
+ "----------------------------------------------------------------------------------------------------\n" + \
+ str(sfg.find_by_name("INP1")[0]) + "\n" + \
+ str(sfg.find_by_name("INP2")[0]) + "\n" + \
+ str(sfg.find_by_name("ADD1")[0]) + "\n" + \
+ str(sfg.find_by_name("INP3")[0]) + "\n" + \
+ str(sfg.find_by_name("MUL1")[0]) + "\n" + \
+ str(sfg.find_by_name("OUT1")[0]) + "\n" + \
+ "----------------------------------------------------------------------------------------------------\n"
def test_constant(self):
inp1 = Input("INP1")
@@ -85,18 +104,27 @@ class TestPrintSfg:
sfg = SFG(inputs=[inp1], outputs=[out1], name="sfg")
assert sfg.__str__() == \
- "id: add1, name: ADD1, input: [s3, s1], output: [s2]\n" + \
- "id: c1, name: CONST, value: 3, input: [], output: [s3]\n" + \
- "id: in1, name: INP1, input: [], output: [s1]\n" + \
- "id: out1, name: OUT1, input: [s2], output: []\n"
-
- def test_simple_filter(self, simple_filter):
- assert simple_filter.__str__() == \
- 'id: add1, name: , input: [s1, s3], output: [s4]\n' + \
- 'id: in1, name: , input: [], output: [s1]\n' + \
- 'id: cmul1, name: , input: [s5], output: [s3]\n' + \
- 'id: reg1, name: , input: [s4], output: [s5, s2]\n' + \
- 'id: out1, name: , input: [s2], output: []\n'
+ "id: no_id, \tname: sfg, \tinputs: {0: '-'}, \toutputs: {0: '-'}\n" + \
+ "Internal Operations:\n" + \
+ "----------------------------------------------------------------------------------------------------\n" + \
+ str(sfg.find_by_name("CONST")[0]) + "\n" + \
+ str(sfg.find_by_name("INP1")[0]) + "\n" + \
+ str(sfg.find_by_name("ADD1")[0]) + "\n" + \
+ str(sfg.find_by_name("OUT1")[0]) + "\n" + \
+ "----------------------------------------------------------------------------------------------------\n"
+
+ def test_simple_filter(self, sfg_simple_filter):
+ assert sfg_simple_filter.__str__() == \
+ "id: no_id, \tname: simple_filter, \tinputs: {0: '-'}, \toutputs: {0: '-'}\n" + \
+ "Internal Operations:\n" + \
+ "----------------------------------------------------------------------------------------------------\n" + \
+ str(sfg_simple_filter.find_by_name("IN1")[0]) + "\n" + \
+ str(sfg_simple_filter.find_by_name("ADD1")[0]) + "\n" + \
+ str(sfg_simple_filter.find_by_name("T1")[0]) + "\n" + \
+ str(sfg_simple_filter.find_by_name("CMUL1")[0]) + "\n" + \
+ str(sfg_simple_filter.find_by_name("OUT1")[0]) + "\n" + \
+ "----------------------------------------------------------------------------------------------------\n"
+
class TestDeepCopy:
def test_deep_copy_no_duplicates(self):
@@ -107,7 +135,7 @@ class TestDeepCopy:
mul1 = Multiplication(add1, inp3, "MUL1")
out1 = Output(mul1, "OUT1")
- mac_sfg = SFG(inputs = [inp1, inp2], outputs = [out1], name = "mac_sfg")
+ mac_sfg = SFG(inputs=[inp1, inp2], outputs=[out1], name="mac_sfg")
mac_sfg_new = mac_sfg()
assert mac_sfg.name == "mac_sfg"
@@ -134,8 +162,9 @@ class TestDeepCopy:
mul1.input(1).connect(add2, "S6")
out1.input(0).connect(mul1, "S7")
- mac_sfg = SFG(inputs = [inp1, inp2], outputs = [out1], id_number_offset = 100, name = "mac_sfg")
- mac_sfg_new = mac_sfg(name = "mac_sfg2")
+ mac_sfg = SFG(inputs=[inp1, inp2], outputs=[out1],
+ id_number_offset=100, name="mac_sfg")
+ mac_sfg_new = mac_sfg(name="mac_sfg2")
assert mac_sfg.name == "mac_sfg"
assert mac_sfg_new.name == "mac_sfg2"
@@ -145,7 +174,7 @@ class TestDeepCopy:
for g_id, component in mac_sfg._components_by_id.items():
component_copy = mac_sfg_new.find_by_id(g_id)
assert component.name == component_copy.name
-
+
def test_deep_copy_with_new_sources(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
@@ -154,7 +183,7 @@ class TestDeepCopy:
mul1 = Multiplication(add1, inp3, "MUL1")
out1 = Output(mul1, "OUT1")
- mac_sfg = SFG(inputs = [inp1, inp2], outputs = [out1], name = "mac_sfg")
+ mac_sfg = SFG(inputs=[inp1, inp2], outputs=[out1], name="mac_sfg")
a = Addition(Constant(3), Constant(5))
b = Constant(2)
@@ -162,20 +191,22 @@ class TestDeepCopy:
assert mac_sfg_new.input(0).signals[0].source.operation is a
assert mac_sfg_new.input(1).signals[0].source.operation is b
+
class TestEvaluateOutput:
def test_evaluate_output(self, operation_tree):
- sfg = SFG(outputs = [Output(operation_tree)])
+ sfg = SFG(outputs=[Output(operation_tree)])
assert sfg.evaluate_output(0, []) == 5
def test_evaluate_output_large(self, large_operation_tree):
- sfg = SFG(outputs = [Output(large_operation_tree)])
+ sfg = SFG(outputs=[Output(large_operation_tree)])
assert sfg.evaluate_output(0, []) == 14
def test_evaluate_output_cycle(self, operation_graph_with_cycle):
- sfg = SFG(outputs = [Output(operation_graph_with_cycle)])
+ sfg = SFG(outputs=[Output(operation_graph_with_cycle)])
with pytest.raises(Exception):
sfg.evaluate_output(0, [])
+
class TestComponents:
def test_advanced_components(self):
inp1 = Input("INP1")
@@ -194,9 +225,10 @@ class TestComponents:
mul1.input(1).connect(add2, "S6")
out1.input(0).connect(mul1, "S7")
- mac_sfg = SFG(inputs = [inp1, inp2], outputs = [out1], name = "mac_sfg")
+ mac_sfg = SFG(inputs=[inp1, inp2], outputs=[out1], name="mac_sfg")
- assert set([comp.name for comp in mac_sfg.components]) == {"INP1", "INP2", "INP3", "ADD1", "ADD2", "MUL1", "OUT1", "S1", "S2", "S3", "S4", "S5", "S6", "S7"}
+ assert set([comp.name for comp in mac_sfg.components]) == {
+ "INP1", "INP2", "INP3", "ADD1", "ADD2", "MUL1", "OUT1", "S1", "S2", "S3", "S4", "S5", "S6", "S7"}
class TestReplaceComponents:
@@ -204,16 +236,8 @@ class TestReplaceComponents:
sfg = SFG(outputs=[Output(operation_tree)])
component_id = "add1"
- sfg = sfg.replace_component(Multiplication(name="Multi"), _id=component_id)
- assert component_id not in sfg._components_by_id.keys()
- assert "Multi" in sfg._components_by_name.keys()
-
- def test_replace_addition_by_component(self, operation_tree):
- sfg = SFG(outputs=[Output(operation_tree)])
- component_id = "add1"
- component = sfg.find_by_id(component_id)
-
- sfg = sfg.replace_component(Multiplication(name="Multi"), _component=component)
+ sfg = sfg.replace_component(
+ Multiplication(name="Multi"), _id=component_id)
assert component_id not in sfg._components_by_id.keys()
assert "Multi" in sfg._components_by_name.keys()
@@ -221,15 +245,16 @@ class TestReplaceComponents:
sfg = SFG(outputs=[Output(large_operation_tree)])
component_id = "add3"
- sfg = sfg.replace_component(Multiplication(name="Multi"), _id=component_id)
+ sfg = sfg.replace_component(
+ Multiplication(name="Multi"), _id=component_id)
assert "Multi" in sfg._components_by_name.keys()
assert component_id not in sfg._components_by_id.keys()
-
+
def test_replace_no_input_component(self, operation_tree):
sfg = SFG(outputs=[Output(operation_tree)])
component_id = "c1"
_const = sfg.find_by_id(component_id)
-
+
sfg = sfg.replace_component(Constant(1), _id=component_id)
assert _const is not sfg.find_by_id(component_id)
@@ -238,7 +263,8 @@ class TestReplaceComponents:
component_id = "addd1"
try:
- sfg = sfg.replace_component(Multiplication(name="Multi"), _id=component_id)
+ sfg = sfg.replace_component(
+ Multiplication(name="Multi"), _id=component_id)
except AssertionError:
assert True
else:
@@ -249,8 +275,608 @@ class TestReplaceComponents:
component_id = "c1"
try:
- sfg = sfg.replace_component(Multiplication(name="Multi"), _id=component_id)
+ sfg = sfg.replace_component(
+ Multiplication(name="Multi"), _id=component_id)
except AssertionError:
assert True
else:
assert False
+
+
+class TestInsertComponent:
+
+ def test_insert_component_in_sfg(self, large_operation_tree_names):
+ sfg = SFG(outputs=[Output(large_operation_tree_names)])
+ sqrt = SquareRoot()
+
+ _sfg = sfg.insert_operation(sqrt, sfg.find_by_name("constant4")[0].graph_id)
+ assert _sfg.evaluate() != sfg.evaluate()
+
+ assert any([isinstance(comp, SquareRoot) for comp in _sfg.operations])
+ assert not any([isinstance(comp, SquareRoot) for comp in sfg.operations])
+
+ assert not isinstance(sfg.find_by_name("constant4")[0].output(0).signals[0].destination.operation, SquareRoot)
+ assert isinstance(_sfg.find_by_name("constant4")[0].output(0).signals[0].destination.operation, SquareRoot)
+
+ assert sfg.find_by_name("constant4")[0].output(0).signals[0].destination.operation is sfg.find_by_id("add3")
+ assert _sfg.find_by_name("constant4")[0].output(
+ 0).signals[0].destination.operation is not _sfg.find_by_id("add3")
+ assert _sfg.find_by_id("sqrt1").output(0).signals[0].destination.operation is _sfg.find_by_id("add3")
+
+ def test_insert_invalid_component_in_sfg(self, large_operation_tree):
+ sfg = SFG(outputs=[Output(large_operation_tree)])
+
+ # Should raise an exception for not matching input count to output count.
+ add4 = Addition()
+ with pytest.raises(Exception):
+ sfg.insert_operation(add4, "c1")
+
+ def test_insert_at_output(self, large_operation_tree):
+ sfg = SFG(outputs=[Output(large_operation_tree)])
+
+ # Should raise an exception for trying to insert an operation after an output.
+ sqrt = SquareRoot()
+ with pytest.raises(Exception):
+ _sfg = sfg.insert_operation(sqrt, "out1")
+
+ def test_insert_multiple_output_ports(self, butterfly_operation_tree):
+ sfg = SFG(outputs=list(map(Output, butterfly_operation_tree.outputs)))
+ _sfg = sfg.insert_operation(Butterfly(name="n_bfly"), "bfly3")
+
+ assert sfg.evaluate() != _sfg.evaluate()
+
+ assert len(sfg.find_by_name("n_bfly")) == 0
+ assert len(_sfg.find_by_name("n_bfly")) == 1
+
+ # Correctly connected old output -> new input
+ assert _sfg.find_by_name("bfly3")[0].output(
+ 0).signals[0].destination.operation is _sfg.find_by_name("n_bfly")[0]
+ assert _sfg.find_by_name("bfly3")[0].output(
+ 1).signals[0].destination.operation is _sfg.find_by_name("n_bfly")[0]
+
+ # Correctly connected new input -> old output
+ assert _sfg.find_by_name("n_bfly")[0].input(0).signals[0].source.operation is _sfg.find_by_name("bfly3")[0]
+ assert _sfg.find_by_name("n_bfly")[0].input(1).signals[0].source.operation is _sfg.find_by_name("bfly3")[0]
+
+ # Correctly connected new output -> next input
+ assert _sfg.find_by_name("n_bfly")[0].output(
+ 0).signals[0].destination.operation is _sfg.find_by_name("bfly2")[0]
+ assert _sfg.find_by_name("n_bfly")[0].output(
+ 1).signals[0].destination.operation is _sfg.find_by_name("bfly2")[0]
+
+ # Correctly connected next input -> new output
+ assert _sfg.find_by_name("bfly2")[0].input(0).signals[0].source.operation is _sfg.find_by_name("n_bfly")[0]
+ assert _sfg.find_by_name("bfly2")[0].input(1).signals[0].source.operation is _sfg.find_by_name("n_bfly")[0]
+
+
+class TestFindComponentsWithTypeName:
+ def test_mac_components(self):
+ inp1 = Input("INP1")
+ inp2 = Input("INP2")
+ inp3 = Input("INP3")
+ add1 = Addition(None, None, "ADD1")
+ add2 = Addition(None, None, "ADD2")
+ mul1 = Multiplication(None, None, "MUL1")
+ out1 = Output(None, "OUT1")
+
+ add1.input(0).connect(inp1, "S1")
+ add1.input(1).connect(inp2, "S2")
+ add2.input(0).connect(add1, "S4")
+ add2.input(1).connect(inp3, "S3")
+ mul1.input(0).connect(add1, "S5")
+ mul1.input(1).connect(add2, "S6")
+ out1.input(0).connect(mul1, "S7")
+
+ mac_sfg = SFG(inputs=[inp1, inp2], outputs=[out1], name="mac_sfg")
+
+ assert {comp.name for comp in mac_sfg.get_components_with_type_name(
+ inp1.type_name())} == {"INP1", "INP2", "INP3"}
+
+ assert {comp.name for comp in mac_sfg.get_components_with_type_name(
+ add1.type_name())} == {"ADD1", "ADD2"}
+
+ assert {comp.name for comp in mac_sfg.get_components_with_type_name(
+ mul1.type_name())} == {"MUL1"}
+
+ assert {comp.name for comp in mac_sfg.get_components_with_type_name(
+ out1.type_name())} == {"OUT1"}
+
+ assert {comp.name for comp in mac_sfg.get_components_with_type_name(
+ Signal.type_name())} == {"S1", "S2", "S3", "S4", "S5", "S6", "S7"}
+
+
+class TestGetPrecedenceList:
+
+ def test_inputs_delays(self, precedence_sfg_delays):
+
+ precedence_list = precedence_sfg_delays.get_precedence_list()
+
+ assert len(precedence_list) == 7
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[0]]) == {"IN1", "T1", "T2"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[1]]) == {"C0", "B1", "B2", "A1", "A2"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[2]]) == {"ADD2", "ADD3"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[3]]) == {"ADD1"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[4]]) == {"Q1"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[5]]) == {"A0"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[6]]) == {"ADD4"}
+
+ def test_inputs_constants_delays_multiple_outputs(self, precedence_sfg_delays_and_constants):
+
+ precedence_list = precedence_sfg_delays_and_constants.get_precedence_list()
+
+ assert len(precedence_list) == 7
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[0]]) == {"IN1", "T1", "CONST1"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[1]]) == {"C0", "B1", "B2", "A1", "A2"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[2]]) == {"ADD2", "ADD3"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[3]]) == {"ADD1"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[4]]) == {"Q1"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[5]]) == {"A0"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[6]]) == {"BFLY1.0", "BFLY1.1"}
+
+ def test_precedence_multiple_outputs_same_precedence(self, sfg_two_inputs_two_outputs):
+ sfg_two_inputs_two_outputs.name = "NESTED_SFG"
+
+ in1 = Input("IN1")
+ sfg_two_inputs_two_outputs.input(0).connect(in1, "S1")
+ in2 = Input("IN2")
+ cmul1 = ConstantMultiplication(10, None, "CMUL1")
+ cmul1.input(0).connect(in2, "S2")
+ sfg_two_inputs_two_outputs.input(1).connect(cmul1, "S3")
+
+ out1 = Output(sfg_two_inputs_two_outputs.output(0), "OUT1")
+ out2 = Output(sfg_two_inputs_two_outputs.output(1), "OUT2")
+
+ sfg = SFG(inputs=[in1, in2], outputs=[out1, out2])
+
+ precedence_list = sfg.get_precedence_list()
+
+ assert len(precedence_list) == 3
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[0]]) == {"IN1", "IN2"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[1]]) == {"CMUL1"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[2]]) == {"NESTED_SFG.0", "NESTED_SFG.1"}
+
+ def test_precedence_sfg_multiple_outputs_different_precedences(self, sfg_two_inputs_two_outputs_independent):
+ sfg_two_inputs_two_outputs_independent.name = "NESTED_SFG"
+
+ in1 = Input("IN1")
+ in2 = Input("IN2")
+ sfg_two_inputs_two_outputs_independent.input(0).connect(in1, "S1")
+ cmul1 = ConstantMultiplication(10, None, "CMUL1")
+ cmul1.input(0).connect(in2, "S2")
+ sfg_two_inputs_two_outputs_independent.input(1).connect(cmul1, "S3")
+ out1 = Output(sfg_two_inputs_two_outputs_independent.output(0), "OUT1")
+ out2 = Output(sfg_two_inputs_two_outputs_independent.output(1), "OUT2")
+
+ sfg = SFG(inputs=[in1, in2], outputs=[out1, out2])
+
+ precedence_list = sfg.get_precedence_list()
+
+ assert len(precedence_list) == 3
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[0]]) == {"IN1", "IN2"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[1]]) == {"CMUL1"}
+
+ assert set([port.operation.key(port.index, port.operation.name)
+ for port in precedence_list[2]]) == {"NESTED_SFG.0", "NESTED_SFG.1"}
+
+
+class TestPrintPrecedence:
+ def test_delays(self, precedence_sfg_delays):
+ sfg = precedence_sfg_delays
+
+ captured_output = io.StringIO()
+ sys.stdout = captured_output
+
+ sfg.print_precedence_graph()
+
+ sys.stdout = sys.__stdout__
+
+ captured_output = captured_output.getvalue()
+
+ assert captured_output == \
+ "-" * 120 + "\n" + \
+ "1.1 \t" + str(sfg.find_by_name("IN1")[0]) + "\n" + \
+ "1.2 \t" + str(sfg.find_by_name("T1")[0]) + "\n" + \
+ "1.3 \t" + str(sfg.find_by_name("T2")[0]) + "\n" + \
+ "-" * 120 + "\n" + \
+ "2.1 \t" + str(sfg.find_by_name("C0")[0]) + "\n" + \
+ "2.2 \t" + str(sfg.find_by_name("A1")[0]) + "\n" + \
+ "2.3 \t" + str(sfg.find_by_name("B1")[0]) + "\n" + \
+ "2.4 \t" + str(sfg.find_by_name("A2")[0]) + "\n" + \
+ "2.5 \t" + str(sfg.find_by_name("B2")[0]) + "\n" + \
+ "-" * 120 + "\n" + \
+ "3.1 \t" + str(sfg.find_by_name("ADD3")[0]) + "\n" + \
+ "3.2 \t" + str(sfg.find_by_name("ADD2")[0]) + "\n" + \
+ "-" * 120 + "\n" + \
+ "4.1 \t" + str(sfg.find_by_name("ADD1")[0]) + "\n" + \
+ "-" * 120 + "\n" + \
+ "5.1 \t" + str(sfg.find_by_name("Q1")[0]) + "\n" + \
+ "-" * 120 + "\n" + \
+ "6.1 \t" + str(sfg.find_by_name("A0")[0]) + "\n" + \
+ "-" * 120 + "\n" + \
+ "7.1 \t" + str(sfg.find_by_name("ADD4")[0]) + "\n" + \
+ "-" * 120 + "\n"
+
+
+class TestDepends:
+ def test_depends_sfg(self, sfg_two_inputs_two_outputs):
+ assert set(sfg_two_inputs_two_outputs.inputs_required_for_output(0)) == {
+ 0, 1}
+ assert set(sfg_two_inputs_two_outputs.inputs_required_for_output(1)) == {
+ 0, 1}
+
+ def test_depends_sfg_independent(self, sfg_two_inputs_two_outputs_independent):
+ assert set(
+ sfg_two_inputs_two_outputs_independent.inputs_required_for_output(0)) == {0}
+ assert set(
+ sfg_two_inputs_two_outputs_independent.inputs_required_for_output(1)) == {1}
+
+
+class TestConnectExternalSignalsToComponentsSoloComp:
+
+ def test_connect_external_signals_to_components_mac(self):
+ """ Replace a MAC with inner components in an SFG """
+ inp1 = Input("INP1")
+ inp2 = Input("INP2")
+ inp3 = Input("INP3")
+ add1 = Addition(None, None, "ADD1")
+ add2 = Addition(None, None, "ADD2")
+ mul1 = Multiplication(None, None, "MUL1")
+ out1 = Output(None, "OUT1")
+
+ add1.input(0).connect(inp1, "S1")
+ add1.input(1).connect(inp2, "S2")
+ add2.input(0).connect(add1, "S3")
+ add2.input(1).connect(inp3, "S4")
+ mul1.input(0).connect(add1, "S5")
+ mul1.input(1).connect(add2, "S6")
+ out1.input(0).connect(mul1, "S7")
+
+ mac_sfg = SFG(inputs=[inp1, inp2], outputs=[out1])
+
+ inp4 = Input("INP4")
+ inp5 = Input("INP5")
+ out2 = Output(None, "OUT2")
+
+ mac_sfg.input(0).connect(inp4, "S8")
+ mac_sfg.input(1).connect(inp5, "S9")
+ out2.input(0).connect(mac_sfg.outputs[0], "S10")
+
+ test_sfg = SFG(inputs=[inp4, inp5], outputs=[out2])
+ assert test_sfg.evaluate(1, 2) == 9
+ mac_sfg.connect_external_signals_to_components()
+ assert test_sfg.evaluate(1, 2) == 9
+ assert not test_sfg.connect_external_signals_to_components()
+
+ def test_connect_external_signals_to_components_operation_tree(self, operation_tree):
+ """ Replaces an SFG with only a operation_tree component with its inner components """
+ sfg1 = SFG(outputs=[Output(operation_tree)])
+ out1 = Output(None, "OUT1")
+ out1.input(0).connect(sfg1.outputs[0], "S1")
+ test_sfg = SFG(outputs=[out1])
+ assert test_sfg.evaluate_output(0, []) == 5
+ sfg1.connect_external_signals_to_components()
+ assert test_sfg.evaluate_output(0, []) == 5
+ assert not test_sfg.connect_external_signals_to_components()
+
+ def test_connect_external_signals_to_components_large_operation_tree(self, large_operation_tree):
+ """ Replaces an SFG with only a large_operation_tree component with its inner components """
+ sfg1 = SFG(outputs=[Output(large_operation_tree)])
+ out1 = Output(None, "OUT1")
+ out1.input(0).connect(sfg1.outputs[0], "S1")
+ test_sfg = SFG(outputs=[out1])
+ assert test_sfg.evaluate_output(0, []) == 14
+ sfg1.connect_external_signals_to_components()
+ assert test_sfg.evaluate_output(0, []) == 14
+ assert not test_sfg.connect_external_signals_to_components()
+
+
+class TestConnectExternalSignalsToComponentsMultipleComp:
+
+ def test_connect_external_signals_to_components_operation_tree(self, operation_tree):
+ """ Replaces a operation_tree in an SFG with other components """
+ sfg1 = SFG(outputs=[Output(operation_tree)])
+
+ inp1 = Input("INP1")
+ inp2 = Input("INP2")
+ out1 = Output(None, "OUT1")
+
+ add1 = Addition(None, None, "ADD1")
+ add2 = Addition(None, None, "ADD2")
+
+ add1.input(0).connect(inp1, "S1")
+ add1.input(1).connect(inp2, "S2")
+ add2.input(0).connect(add1, "S3")
+ add2.input(1).connect(sfg1.outputs[0], "S4")
+ out1.input(0).connect(add2, "S5")
+
+ test_sfg = SFG(inputs=[inp1, inp2], outputs=[out1])
+ assert test_sfg.evaluate(1, 2) == 8
+ sfg1.connect_external_signals_to_components()
+ assert test_sfg.evaluate(1, 2) == 8
+ assert not test_sfg.connect_external_signals_to_components()
+
+ def test_connect_external_signals_to_components_large_operation_tree(self, large_operation_tree):
+ """ Replaces a large_operation_tree in an SFG with other components """
+ sfg1 = SFG(outputs=[Output(large_operation_tree)])
+
+ inp1 = Input("INP1")
+ inp2 = Input("INP2")
+ out1 = Output(None, "OUT1")
+ add1 = Addition(None, None, "ADD1")
+ add2 = Addition(None, None, "ADD2")
+
+ add1.input(0).connect(inp1, "S1")
+ add1.input(1).connect(inp2, "S2")
+ add2.input(0).connect(add1, "S3")
+ add2.input(1).connect(sfg1.outputs[0], "S4")
+ out1.input(0).connect(add2, "S5")
+
+ test_sfg = SFG(inputs=[inp1, inp2], outputs=[out1])
+ assert test_sfg.evaluate(1, 2) == 17
+ sfg1.connect_external_signals_to_components()
+ assert test_sfg.evaluate(1, 2) == 17
+ assert not test_sfg.connect_external_signals_to_components()
+
+ def create_sfg(self, op_tree):
+ """ Create a simple SFG with either operation_tree or large_operation_tree """
+ sfg1 = SFG(outputs=[Output(op_tree)])
+
+ inp1 = Input("INP1")
+ inp2 = Input("INP2")
+ out1 = Output(None, "OUT1")
+ add1 = Addition(None, None, "ADD1")
+ add2 = Addition(None, None, "ADD2")
+
+ add1.input(0).connect(inp1, "S1")
+ add1.input(1).connect(inp2, "S2")
+ add2.input(0).connect(add1, "S3")
+ add2.input(1).connect(sfg1.outputs[0], "S4")
+ out1.input(0).connect(add2, "S5")
+
+ return SFG(inputs=[inp1, inp2], outputs=[out1])
+
+ def test_connect_external_signals_to_components_many_op(self, large_operation_tree):
+ """ Replaces an sfg component in a larger SFG with several component operations """
+ inp1 = Input("INP1")
+ inp2 = Input("INP2")
+ inp3 = Input("INP3")
+ inp4 = Input("INP4")
+ out1 = Output(None, "OUT1")
+ add1 = Addition(None, None, "ADD1")
+ sub1 = Subtraction(None, None, "SUB1")
+
+ add1.input(0).connect(inp1, "S1")
+ add1.input(1).connect(inp2, "S2")
+
+ sfg1 = self.create_sfg(large_operation_tree)
+
+ sfg1.input(0).connect(add1, "S3")
+ sfg1.input(1).connect(inp3, "S4")
+ sub1.input(0).connect(sfg1.outputs[0], "S5")
+ sub1.input(1).connect(inp4, "S6")
+ out1.input(0).connect(sub1, "S7")
+
+ test_sfg = SFG(inputs=[inp1, inp2, inp3, inp4], outputs=[out1])
+
+ assert test_sfg.evaluate(1, 2, 3, 4) == 16
+ sfg1.connect_external_signals_to_components()
+ assert test_sfg.evaluate(1, 2, 3, 4) == 16
+ assert not test_sfg.connect_external_signals_to_components()
+
+
+class TestTopologicalOrderOperations:
+ def test_feedback_sfg(self, sfg_simple_filter):
+ topological_order = sfg_simple_filter.get_operations_topological_order()
+
+ assert [comp.name for comp in topological_order] == ["IN1", "ADD1", "T1", "CMUL1", "OUT1"]
+
+ def test_multiple_independent_inputs(self, sfg_two_inputs_two_outputs_independent):
+ topological_order = sfg_two_inputs_two_outputs_independent.get_operations_topological_order()
+
+ assert [comp.name for comp in topological_order] == ["IN1", "OUT1", "IN2", "C1", "ADD1", "OUT2"]
+
+ def test_complex_graph(self, precedence_sfg_delays):
+ topological_order = precedence_sfg_delays.get_operations_topological_order()
+
+ assert [comp.name for comp in topological_order] == \
+ ['IN1', 'C0', 'ADD1', 'Q1', 'A0', 'T1', 'B1', 'A1', 'T2', 'B2', 'ADD2', 'A2', 'ADD3', 'ADD4', 'OUT1']
+
+
+class TestRemove:
+ def test_remove_single_input_outputs(self, sfg_simple_filter):
+ new_sfg = sfg_simple_filter.remove_operation("cmul1")
+
+ assert set(op.name for op in sfg_simple_filter.find_by_name("T1")[0].subsequent_operations) == {"CMUL1", "OUT1"}
+ assert set(op.name for op in new_sfg.find_by_name("T1")[0].subsequent_operations) == {"ADD1", "OUT1"}
+
+ assert set(op.name for op in sfg_simple_filter.find_by_name("ADD1")[0].preceding_operations) == {"CMUL1", "IN1"}
+ assert set(op.name for op in new_sfg.find_by_name("ADD1")[0].preceding_operations) == {"T1", "IN1"}
+
+ assert "S1" in set([sig.name for sig in sfg_simple_filter.find_by_name("T1")[0].output(0).signals])
+ assert "S2" in set([sig.name for sig in new_sfg.find_by_name("T1")[0].output(0).signals])
+
+ def test_remove_multiple_inputs_outputs(self, butterfly_operation_tree):
+ out1 = Output(butterfly_operation_tree.output(0), "OUT1")
+ out2 = Output(butterfly_operation_tree.output(1), "OUT2")
+
+ sfg = SFG(outputs=[out1, out2])
+
+ new_sfg = sfg.remove_operation(sfg.find_by_name("bfly2")[0].graph_id)
+
+ assert sfg.find_by_name("bfly3")[0].output(0).signal_count == 1
+ assert new_sfg.find_by_name("bfly3")[0].output(0).signal_count == 1
+
+ sfg_dest_0 = sfg.find_by_name("bfly3")[0].output(0).signals[0].destination
+ new_sfg_dest_0 = new_sfg.find_by_name("bfly3")[0].output(0).signals[0].destination
+
+ assert sfg_dest_0.index == 0
+ assert new_sfg_dest_0.index == 0
+ assert sfg_dest_0.operation.name == "bfly2"
+ assert new_sfg_dest_0.operation.name == "bfly1"
+
+ assert sfg.find_by_name("bfly3")[0].output(1).signal_count == 1
+ assert new_sfg.find_by_name("bfly3")[0].output(1).signal_count == 1
+
+ sfg_dest_1 = sfg.find_by_name("bfly3")[0].output(1).signals[0].destination
+ new_sfg_dest_1 = new_sfg.find_by_name("bfly3")[0].output(1).signals[0].destination
+
+ assert sfg_dest_1.index == 1
+ assert new_sfg_dest_1.index == 1
+ assert sfg_dest_1.operation.name == "bfly2"
+ assert new_sfg_dest_1.operation.name == "bfly1"
+
+ assert sfg.find_by_name("bfly1")[0].input(0).signal_count == 1
+ assert new_sfg.find_by_name("bfly1")[0].input(0).signal_count == 1
+
+ sfg_source_0 = sfg.find_by_name("bfly1")[0].input(0).signals[0].source
+ new_sfg_source_0 = new_sfg.find_by_name("bfly1")[0].input(0).signals[0].source
+
+ assert sfg_source_0.index == 0
+ assert new_sfg_source_0.index == 0
+ assert sfg_source_0.operation.name == "bfly2"
+ assert new_sfg_source_0.operation.name == "bfly3"
+
+ sfg_source_1 = sfg.find_by_name("bfly1")[0].input(1).signals[0].source
+ new_sfg_source_1 = new_sfg.find_by_name("bfly1")[0].input(1).signals[0].source
+
+ assert sfg_source_1.index == 1
+ assert new_sfg_source_1.index == 1
+ assert sfg_source_1.operation.name == "bfly2"
+ assert new_sfg_source_1.operation.name == "bfly3"
+
+ assert "bfly2" not in set(op.name for op in new_sfg.operations)
+
+ def remove_different_number_inputs_outputs(self, sfg_simple_filter):
+ with pytest.raises(ValueError):
+ sfg_simple_filter.remove_operation("add1")
+
+
+class TestSaveLoadSFG:
+ def get_path(self, existing=False):
+ path_ = "".join(random.choices(string.ascii_uppercase, k=4)) + ".py"
+ while path.exists(path_) if not existing else not path.exists(path_):
+ path_ = "".join(random.choices(string.ascii_uppercase, k=4)) + ".py"
+
+ return path_
+
+ def test_save_simple_sfg(self, sfg_simple_filter):
+ result = sfg_to_python(sfg_simple_filter)
+ path_ = self.get_path()
+
+ assert not path.exists(path_)
+ with open(path_, "w") as file_obj:
+ file_obj.write(result)
+
+ assert path.exists(path_)
+
+ with open(path_, "r") as file_obj:
+ assert file_obj.read() == result
+
+ remove(path_)
+
+ def test_save_complex_sfg(self, precedence_sfg_delays_and_constants):
+ result = sfg_to_python(precedence_sfg_delays_and_constants)
+ path_ = self.get_path()
+
+ assert not path.exists(path_)
+ with open(path_, "w") as file_obj:
+ file_obj.write(result)
+
+ assert path.exists(path_)
+
+ with open(path_, "r") as file_obj:
+ assert file_obj.read() == result
+
+ remove(path_)
+
+ def test_load_simple_sfg(self, sfg_simple_filter):
+ result = sfg_to_python(sfg_simple_filter)
+ path_ = self.get_path()
+
+ assert not path.exists(path_)
+ with open(path_, "w") as file_obj:
+ file_obj.write(result)
+
+ assert path.exists(path_)
+
+ simple_filter_, _ = python_to_sfg(path_)
+
+ assert str(sfg_simple_filter) == str(simple_filter_)
+ assert sfg_simple_filter.evaluate([2]) == simple_filter_.evaluate([2])
+
+ remove(path_)
+
+ def test_load_complex_sfg(self, precedence_sfg_delays_and_constants):
+ result = sfg_to_python(precedence_sfg_delays_and_constants)
+ path_ = self.get_path()
+
+ assert not path.exists(path_)
+ with open(path_, "w") as file_obj:
+ file_obj.write(result)
+
+ assert path.exists(path_)
+
+ precedence_sfg_registers_and_constants_, _ = python_to_sfg(path_)
+
+ assert str(precedence_sfg_delays_and_constants) == str(precedence_sfg_registers_and_constants_)
+
+ remove(path_)
+
+ def test_load_invalid_path(self):
+ path_ = self.get_path(existing=False)
+ with pytest.raises(Exception):
+ python_to_sfg(path_)
+
+
+class TestGetComponentsOfType:
+ def test_get_no_operations_of_type(self, sfg_two_inputs_two_outputs):
+ assert [op.name for op in sfg_two_inputs_two_outputs.get_components_with_type_name(Multiplication.type_name())] \
+ == []
+
+ def test_get_multple_operations_of_type(self, sfg_two_inputs_two_outputs):
+ assert [op.name for op in sfg_two_inputs_two_outputs.get_components_with_type_name(Addition.type_name())] \
+ == ["ADD1", "ADD2"]
+
+ assert [op.name for op in sfg_two_inputs_two_outputs.get_components_with_type_name(Input.type_name())] \
+ == ["IN1", "IN2"]
+
+ assert [op.name for op in sfg_two_inputs_two_outputs.get_components_with_type_name(Output.type_name())] \
+ == ["OUT1", "OUT2"]
diff --git a/test/test_simulation.py b/test/test_simulation.py
index e8684d666d45eaa53d6a8e058225f3da16597c7a..89a800ad211be9262b3d05314cb371e7c5128f8a 100644
--- a/test/test_simulation.py
+++ b/test/test_simulation.py
@@ -1,90 +1,100 @@
import pytest
import numpy as np
+<<<<<<< HEAD
from b_asic import SFG, Input, Output, Delay, ConstantMultiplication, Simulation
+=======
+from b_asic import SFG, Simulation
+>>>>>>> d2ae5743259f581c116bb3772d17c3b2023ed9e0
class TestRunFor:
def test_with_lambdas_as_input(self, sfg_two_inputs_two_outputs):
- simulation = Simulation(sfg_two_inputs_two_outputs, [lambda n: n + 3, lambda n: 1 + n * 2], save_results = True)
+ simulation = Simulation(sfg_two_inputs_two_outputs, [lambda n: n + 3, lambda n: 1 + n * 2])
- output = simulation.run_for(101)
+ output = simulation.run_for(101, save_results = True)
assert output[0] == 304
assert output[1] == 505
- assert simulation.results[100]["0"] == 304
- assert simulation.results[100]["1"] == 505
-
- assert simulation.results[0]["in1"] == 3
- assert simulation.results[0]["in2"] == 1
- assert simulation.results[0]["add1"] == 4
- assert simulation.results[0]["add2"] == 5
- assert simulation.results[0]["0"] == 4
- assert simulation.results[0]["1"] == 5
-
- assert simulation.results[1]["in1"] == 4
- assert simulation.results[1]["in2"] == 3
- assert simulation.results[1]["add1"] == 7
- assert simulation.results[1]["add2"] == 10
- assert simulation.results[1]["0"] == 7
- assert simulation.results[1]["1"] == 10
-
- assert simulation.results[2]["in1"] == 5
- assert simulation.results[2]["in2"] == 5
- assert simulation.results[2]["add1"] == 10
- assert simulation.results[2]["add2"] == 15
- assert simulation.results[2]["0"] == 10
- assert simulation.results[2]["1"] == 15
-
- assert simulation.results[3]["in1"] == 6
- assert simulation.results[3]["in2"] == 7
- assert simulation.results[3]["add1"] == 13
- assert simulation.results[3]["add2"] == 20
- assert simulation.results[3]["0"] == 13
- assert simulation.results[3]["1"] == 20
+ assert simulation.results["0"][100] == 304
+ assert simulation.results["1"][100] == 505
+
+ assert simulation.results["in1"][0] == 3
+ assert simulation.results["in2"][0] == 1
+ assert simulation.results["add1"][0] == 4
+ assert simulation.results["add2"][0] == 5
+ assert simulation.results["0"][0] == 4
+ assert simulation.results["1"][0] == 5
+
+ assert simulation.results["in1"][1] == 4
+ assert simulation.results["in2"][1] == 3
+ assert simulation.results["add1"][1] == 7
+ assert simulation.results["add2"][1] == 10
+ assert simulation.results["0"][1] == 7
+ assert simulation.results["1"][1] == 10
+
+ assert simulation.results["in1"][2] == 5
+ assert simulation.results["in2"][2] == 5
+ assert simulation.results["add1"][2] == 10
+ assert simulation.results["add2"][2] == 15
+ assert simulation.results["0"][2] == 10
+ assert simulation.results["1"][2] == 15
+
+ assert simulation.results["in1"][3] == 6
+ assert simulation.results["in2"][3] == 7
+ assert simulation.results["add1"][3] == 13
+ assert simulation.results["add2"][3] == 20
+ assert simulation.results["0"][3] == 13
+ assert simulation.results["1"][3] == 20
def test_with_numpy_arrays_as_input(self, sfg_two_inputs_two_outputs):
input0 = np.array([5, 9, 25, -5, 7])
input1 = np.array([7, 3, 3, 54, 2])
simulation = Simulation(sfg_two_inputs_two_outputs, [input0, input1])
- simulation.save_results = True
- output = simulation.run_for(5)
+ output = simulation.run_for(5, save_results = True)
assert output[0] == 9
assert output[1] == 11
- assert simulation.results[0]["in1"] == 5
- assert simulation.results[0]["in2"] == 7
- assert simulation.results[0]["add1"] == 12
- assert simulation.results[0]["add2"] == 19
- assert simulation.results[0]["0"] == 12
- assert simulation.results[0]["1"] == 19
-
- assert simulation.results[1]["in1"] == 9
- assert simulation.results[1]["in2"] == 3
- assert simulation.results[1]["add1"] == 12
- assert simulation.results[1]["add2"] == 15
- assert simulation.results[1]["0"] == 12
- assert simulation.results[1]["1"] == 15
-
- assert simulation.results[2]["in1"] == 25
- assert simulation.results[2]["in2"] == 3
- assert simulation.results[2]["add1"] == 28
- assert simulation.results[2]["add2"] == 31
- assert simulation.results[2]["0"] == 28
- assert simulation.results[2]["1"] == 31
-
- assert simulation.results[3]["in1"] == -5
- assert simulation.results[3]["in2"] == 54
- assert simulation.results[3]["add1"] == 49
- assert simulation.results[3]["add2"] == 103
- assert simulation.results[3]["0"] == 49
- assert simulation.results[3]["1"] == 103
-
- assert simulation.results[4]["0"] == 9
- assert simulation.results[4]["1"] == 11
+ assert isinstance(simulation.results["in1"], np.ndarray)
+ assert isinstance(simulation.results["in2"], np.ndarray)
+ assert isinstance(simulation.results["add1"], np.ndarray)
+ assert isinstance(simulation.results["add2"], np.ndarray)
+ assert isinstance(simulation.results["0"], np.ndarray)
+ assert isinstance(simulation.results["1"], np.ndarray)
+
+ assert simulation.results["in1"][0] == 5
+ assert simulation.results["in2"][0] == 7
+ assert simulation.results["add1"][0] == 12
+ assert simulation.results["add2"][0] == 19
+ assert simulation.results["0"][0] == 12
+ assert simulation.results["1"][0] == 19
+
+ assert simulation.results["in1"][1] == 9
+ assert simulation.results["in2"][1] == 3
+ assert simulation.results["add1"][1] == 12
+ assert simulation.results["add2"][1] == 15
+ assert simulation.results["0"][1] == 12
+ assert simulation.results["1"][1] == 15
+
+ assert simulation.results["in1"][2] == 25
+ assert simulation.results["in2"][2] == 3
+ assert simulation.results["add1"][2] == 28
+ assert simulation.results["add2"][2] == 31
+ assert simulation.results["0"][2] == 28
+ assert simulation.results["1"][2] == 31
+
+ assert simulation.results["in1"][3] == -5
+ assert simulation.results["in2"][3] == 54
+ assert simulation.results["add1"][3] == 49
+ assert simulation.results["add2"][3] == 103
+ assert simulation.results["0"][3] == 49
+ assert simulation.results["1"][3] == 103
+
+ assert simulation.results["0"][4] == 9
+ assert simulation.results["1"][4] == 11
def test_with_numpy_array_overflow(self, sfg_two_inputs_two_outputs):
input0 = np.array([5, 9, 25, -5, 7])
@@ -92,19 +102,29 @@ class TestRunFor:
simulation = Simulation(sfg_two_inputs_two_outputs, [input0, input1])
simulation.run_for(5)
with pytest.raises(IndexError):
- simulation.run_for(1)
+ simulation.step()
+
+ def test_run_whole_numpy_array(self, sfg_two_inputs_two_outputs):
+ input0 = np.array([5, 9, 25, -5, 7])
+ input1 = np.array([7, 3, 3, 54, 2])
+ simulation = Simulation(sfg_two_inputs_two_outputs, [input0, input1])
+ simulation.run()
+ assert len(simulation.results["0"]) == 5
+ assert len(simulation.results["1"]) == 5
+ with pytest.raises(IndexError):
+ simulation.step()
def test_delay(self, sfg_delay):
- simulation = Simulation(sfg_delay, save_results = True)
+ simulation = Simulation(sfg_delay)
simulation.set_input(0, [5, -2, 25, -6, 7, 0])
- simulation.run_for(6)
+ simulation.run_for(6, save_results = True)
- assert simulation.results[0]["0"] == 0
- assert simulation.results[1]["0"] == 5
- assert simulation.results[2]["0"] == -2
- assert simulation.results[3]["0"] == 25
- assert simulation.results[4]["0"] == -6
- assert simulation.results[5]["0"] == 7
+ assert simulation.results["0"][0] == 0
+ assert simulation.results["0"][1] == 5
+ assert simulation.results["0"][2] == -2
+ assert simulation.results["0"][3] == 25
+ assert simulation.results["0"][4] == -6
+ assert simulation.results["0"][5] == 7
def test_find_result_key(self):
indata = [77, 99, 0.3, 23, 88, 3.14, 4.76, 45, 0.099]
@@ -119,13 +139,39 @@ class TestRunFor:
assert sim.results[s.find_result_keys_by_name("Mult")[0]][4] == 0.35
class TestRun:
+ def test_save_results(self, sfg_two_inputs_two_outputs):
+ simulation = Simulation(sfg_two_inputs_two_outputs, [2, 3])
+ assert not simulation.results
+ simulation.run_for(10, save_results = False)
+ assert not simulation.results
+ simulation.run_for(10)
+ assert len(simulation.results["0"]) == 10
+ assert len(simulation.results["1"]) == 10
+ simulation.run_for(10, save_results = True)
+ assert len(simulation.results["0"]) == 20
+ assert len(simulation.results["1"]) == 20
+ simulation.run_for(10, save_results = False)
+ assert len(simulation.results["0"]) == 20
+ assert len(simulation.results["1"]) == 20
+ simulation.run_for(13, save_results = True)
+ assert len(simulation.results["0"]) == 33
+ assert len(simulation.results["1"]) == 33
+ simulation.step(save_results = False)
+ assert len(simulation.results["0"]) == 33
+ assert len(simulation.results["1"]) == 33
+ simulation.step()
+ assert len(simulation.results["0"]) == 34
+ assert len(simulation.results["1"]) == 34
+ simulation.clear_results()
+ assert not simulation.results
+
def test_nested(self, sfg_nested):
input0 = np.array([5, 9])
input1 = np.array([7, 3])
simulation = Simulation(sfg_nested, [input0, input1])
- output0 = simulation.run()
- output1 = simulation.run()
+ output0 = simulation.step()
+ output1 = simulation.step()
assert output0[0] == 11405
assert output1[0] == 4221
@@ -134,21 +180,33 @@ class TestRun:
data_in = np.array([5, -2, 25, -6, 7, 0])
reset = np.array([0, 0, 0, 1, 0, 0])
simulation = Simulation(sfg_accumulator, [data_in, reset])
- output0 = simulation.run()
- output1 = simulation.run()
- output2 = simulation.run()
- output3 = simulation.run()
- output4 = simulation.run()
- output5 = simulation.run()
+ output0 = simulation.step()
+ output1 = simulation.step()
+ output2 = simulation.step()
+ output3 = simulation.step()
+ output4 = simulation.step()
+ output5 = simulation.step()
assert output0[0] == 0
assert output1[0] == 5
assert output2[0] == 3
assert output3[0] == 28
assert output4[0] == 0
assert output5[0] == 7
+
+ def test_simple_accumulator(self, sfg_simple_accumulator):
+ data_in = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ simulation = Simulation(sfg_simple_accumulator, [data_in])
+ simulation.run()
+ assert list(simulation.results["0"]) == [0, 1, 3, 6, 10, 15, 21, 28, 36, 45]
- def test_simple_filter(self, simple_filter):
+ def test_simple_filter(self, sfg_simple_filter):
input0 = np.array([1, 2, 3, 4, 5])
- simulation = Simulation(simple_filter, [input0], save_results=True)
- output0 = [simulation.run()[0] for _ in range(len(input0))]
- assert output0 == [0, 1.0, 2.5, 4.25, 6.125]
+ simulation = Simulation(sfg_simple_filter, [input0])
+ simulation.run_for(len(input0), save_results = True)
+ assert all(simulation.results["0"] == np.array([0, 1.0, 2.5, 4.25, 6.125]))
+
+ def test_custom_operation(self, sfg_custom_operation):
+ simulation = Simulation(sfg_custom_operation, [lambda n: n + 1])
+ simulation.run_for(5)
+ assert all(simulation.results["0"] == np.array([2, 4, 6, 8, 10]))
+ assert all(simulation.results["1"] == np.array([2, 4, 8, 16, 32]))