Working IPC b/w verilog test and python GUI

Author: scopeInfinity

emulator/Makefile.mk

@@ -8,6 +8,19 @@ $(BUILD_EMULATOR)/%_test: $(SRC_EMULATOR)/%_test.v
 	iverilog -o $@ $^
 
 verilog_modules: $(patsubst $(SRC_EMULATOR)/%_test.v, $(BUILD_EMULATOR)/%_test, $(shell find $(SRC_EMULATOR) -name '*_test.v'))
+	mkdir -p $(BUILD_EMULATOR)/io
 
 test_verilog_modules: $(patsubst $(SRC_EMULATOR)/%_test.v, $(BUILD_EMULATOR)/%_test, $(shell find $(SRC_EMULATOR) -name '*_test.v'))
 	$(foreach test_name, $^, echo "Executing $(test_name)" && ./$(test_name))
+
+$(BUILD_EMULATOR)/module/libipc.so: $(SRC_EMULATOR)/module/ipc.cpp
+	mkdir -p $(dir $@)
+	g++ -shared -Wl,-soname,libipc.so -o $@ -fPIC $^
+
+$(BUILD_EMULATOR)/module/ipc.py: $(SRC_EMULATOR)/module/ipc.py $(BUILD_EMULATOR)/module/libipc.so
+	mkdir -p $(dir $@)
+	cp -f $< $@
+
+$(BUILD_EMULATOR)/module/ipc.o: $(SRC_EMULATOR)/module/ipc.cpp
+	mkdir -p $(dir $@)
+	g++ -o $@ $^

emulator/chipset_test.v

@@ -23,6 +23,6 @@ module chipset_test;
             $error("chipset failed");
             $fatal(1);
         end
-        $finish();
+        // $finish();
     end
 endmodule

emulator/module/ipc.cpp

@@ -0,0 +1,24 @@
+#include <string>
+#include <iostream>
+#include <stdio.h>
+#include <sstream>
+
+void handle_output(void (*callback)(int,int), int process_id, int value) {
+    callback(process_id, value);
+}
+
+void fast_io(void (*callback)(int,int)) {
+    unsigned int pid, v;
+    int len = scanf("IPC %x %x\n", &pid, &v);
+    if(len>0) {
+        handle_output(callback, pid, v);
+    }
+}
+
+extern "C" void fast_io_loop(void (*callback)(int,int)) {
+    std::ios_base::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+    while(1) {
+        fast_io(callback);
+    }
+}

emulator/module/ipc.v

@@ -0,0 +1,11 @@
+// Handle Inter Process Communication
+// We were not able to figure out simpler way to do so.
+module IPCOut(
+    input[15:0] process_id,
+    input[31:0] value
+    );
+
+    always @(value) begin
+        $display("IPC %x %x", process_id, value);
+    end
+endmodule

emulator/module/ipc_test.v

@@ -0,0 +1,20 @@
+`include "emulator/module/ipc.v"
+
+module ipc_test;
+    reg[15:0] process_id;
+    reg[31:0] value;
+
+    IPCOut dut(.process_id(process_id[15:0]), .value(value[31:0]));
+
+    initial begin
+        # 5
+        process_id = 10;
+        # 1
+        value = 20;
+        # 1
+        value = 25;
+        # 1
+        value = 30;
+    end
+endmodule
+

emulator/seq/io.c

@@ -0,0 +1,6 @@
+#include "stdio.h"
+#include "stdlib.h"
+
+extern "C" void system_init() {
+	printf("Start system initialization ...\n");
+}

emulator/seq/io_devices.v

@@ -1,23 +1,58 @@
 `include "emulator/com/rom.v"
-`define CONSDEV_ID 1
+`include "emulator/module/ipc.v"
+`define CONSDEV_ID 3
 `define PROM_ID 2
 
+`define IO_DIR "build/emulator/io"
+
+// Import the function called "system_init" implemented in C code
+
 module IODevices(
     output[31:0] value_out,
     input[7:0] device_id,
     input[31:0] value_in,
     input is_write,
     input clk);
 
+    integer fio;
+
     reg[31:0] _data [255:0];
+    initial begin
+        // $fseek(fio, 0, 0);
+        // system_init();
+    end
+    reg[15:0] process_id;
+    // assign
+    reg[31:0] value;
+    IPCOut ipcout(.process_id(process_id[15:0]), .value(value[31:0]));
+
     always @(negedge clk) begin
         // Write are triggered at negedge
         if (is_write) begin
             _data[device_id] <= value_in;
+            process_id <= {8'b00000000, device_id};
+            value <= value_in;
+
+
+            // fio = $fopen("build/emulator/io/output.txt","w");
+            // $fseek(fio, 0, 0);
+            // $fwrite(fio, "%b\n", value_in);
+            // $fflush(fio);
+            // $fclose(fio);
             $display("IO:output[%x] <= %x", device_id, value_in);
         end
     end
 
+    reg[31:0] _ipc_input[0:15];
+    // integer i;
+    always @(posedge clk) begin
+        // At some random interval
+        $readmemb("/tmp/ourpc_input.txt", _ipc_input);
+        // for (i=0; i<16; i=i+1) begin
+        //     $display("INPUT[%d]: %x", i, _ipc_input[i]);
+        // end
+    end
+
     // PROM
     wire[31:0] prom_value;
     ROM_PINGPONG prom(.out(prom_value), .address(_data[`PROM_ID][15:0]));
@@ -26,7 +61,11 @@ module IODevices(
     always @(device_id) begin
         case (device_id)
             `PROM_ID: _value <= prom_value;
-            `CONSDEV_ID: _value <= _data[`CONSDEV_ID];
+            default:
+                begin
+                _value <= _ipc_input[device_id];
+                // $display("IO:input[%x] <= %x", device_id, _value);
+                end
         endcase
     end
     assign value_out = _value;

planner/__main__.py

@@ -5,7 +5,7 @@
 from planner.asm import program_parser
 from planner.sim import bin_parser
 from planner.sim import devices
-from planner.sim.programs import ping_pong
+from planner.sim.programs import ping_pong, verilog_input
 
 
 def args_parser():
@@ -26,6 +26,8 @@ def args_parser():
 
     bin_parser = subparsers.add_parser("compile_and_execute")
     bin_parser.add_argument("program")
+
+    subparsers.add_parser("verilog_io")
     return parser
 
 def main():
@@ -45,6 +47,8 @@ def main():
             _bin.set_output_device(6, devices.IntegerOutput("Screen6", bits=16))
             while True:
                 _bin.step()
+    if args.source == "verilog_io":
+        verilog_input.start()
     if args.source == "compile_and_execute":
         if args.program == "ping_pong":
             ping_pong.start()

planner/sim/programs/verilog_input.py

@@ -0,0 +1,23 @@
+from planner.sim import verilog_devices, gui_devices
+from planner.sim import devices, gui_devices
+import pygame
+
+def start():
+    io = verilog_devices.VerilogIO()
+    gui_manager = gui_devices.GUIDeviceManager()
+
+    input = devices.LatchInput("input", bits=4)
+    gui_manager.add_device((0, 0), gui_devices.KeyPressedInput(input, {
+            pygame.K_w: 0,
+            pygame.K_s: 1,
+            pygame.K_UP: 2,
+            pygame.K_DOWN: 3,
+        }))
+    io.set_input_device(1, input)
+
+    display = devices.LEDDisplay("LED", use_print=False, width_anode=16, height_cathode=8)
+    gui_manager.add_device((0, 0), gui_devices.GUILed(display))
+    io.set_output_device(6, display.get_anodes()[0])
+    io.set_output_device(7, display.get_cathodes()[0])
+    io.run(blocking=False)
+    gui_manager.draw_loop()

planner/sim/verilog_devices.py

@@ -0,0 +1,69 @@
+from planner.sim import devices
+import threading
+import os
+from ctypes import cdll, c_int, CFUNCTYPE
+
+IO_DEVICES = 16
+LIB = "build/emulator/module/libipc.so"
+INPUT_FILE = "/tmp/ourpc_input.txt"
+
+global_io = None
+@CFUNCTYPE(None, c_int, c_int)
+def handle_output(pid, value):
+    print("Got PID(%d) Value(%d)" % (pid, value))
+    global_io.output_devices[pid].update(value)
+
+def io_loop(hh):
+    while True:
+        s = input()
+        print(s)
+        s=s.split()
+        if s[0]=="IPC":
+            pid,value = s[1],s[2]
+            pid=int(pid, 16)
+            value=int(value, 16)
+            print("Got PID(%d) Value(%d)" % (pid, value))
+            dev =  global_io.output_devices[pid]
+            if dev is None:
+                print("Device is None")
+            else:
+                dev.update(value)
+
+class VerilogIO:
+    def __init__(self):
+        self.input_devices = [None]*IO_DEVICES
+        self.output_devices = [None]*IO_DEVICES
+
+        # lib = cdll.LoadLibrary(LIB)
+        # lib.fast_io_loop
+        global global_io
+        global_io = self
+        self.mu = threading.Lock()
+        self.t = threading.Thread(target=io_loop, args=[handle_output])
+
+
+    def run(self, blocking=True):
+        self.write_input(0, 0)
+        self.t.start()
+        if blocking:
+            self.t.join()
+
+    def write_input(self, new_val, old_val):
+        data = [0 if i is None else i.get() for i in self.input_devices]
+        data_str = '\n'.join([
+          "{:032b}".format(x) for x in data
+        ])
+        with self.mu:
+            with open(INPUT_FILE, "w") as f:
+                f.write(data_str)
+
+    def set_input_device(self, index: int, d: devices.InputDevice):
+        d.add_change_handler(self.write_input)
+        self.input_devices[index] = d
+
+    def set_output_device(self, index: int, d: devices.Device):
+        self.output_devices[index] = d
+
+
+
+