add cosim utils to VUnit, use it in examples/vhdl/external_buffer

Author: umarcor

examples/vhdl/external_buffer/cosim.py

@@ -0,0 +1,44 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (c) 2014-2019, Lars Asplund lars.anders.asplund@gmail.com
+
+
+from vunit.cosim import *
+import ctypes
+from os.path import join, dirname, isfile
+
+
+args = [line.rstrip('\n') for line in open(join(dirname(__file__), 'args.txt'))]
+
+xargs = enc_args(args)
+
+print("\nREGULAR EXECUTION")
+ghdl = dlopen(args[0])
+try:
+    ghdl.main(len(xargs)-1, xargs)
+# FIXME With VHDL 93, the execution is Aborted and Python exits here
+except SystemExit as exc:
+    if exc.code is not 0:
+        exit(exc.code)
+dlclose(ghdl)
+
+print("\nPYTHON ALLOCATION")
+ghdl = dlopen(args[0])
+
+data = [111, 122, 133, 144, 155]
+
+buf = byte_buf(data + [0 for x in range(2*len(data))])
+
+ghdl.set_string_ptr(0, buf)
+
+for i, v in enumerate(read_byte_buf(buf)):
+    print("py " + str(i) + ": " + str(v))
+
+ghdl.ghdl_main(len(xargs)-1, xargs)
+
+for i, v in enumerate(read_byte_buf(buf)):
+    print("py " + str(i) + ": " + str(v))
+
+dlclose(ghdl)

vunit/cosim.py

@@ -0,0 +1,101 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (c) 2014-2019, Lars Asplund lars.anders.asplund@gmail.com
+
+"""
+Utils for co-execution of a dynamically loadable binaries or shared libraries
+"""
+
+from __future__ import print_function
+import ctypes
+import _ctypes
+from sys import platform
+from os.path import isfile
+
+
+def dlopen(path):
+    """
+    Open/load a PIE binary or a shared library.
+    """
+    if not isfile(path):
+        print('Executable binary not found: ' + path)
+        exit(1)
+    try:
+        return ctypes.CDLL(path)
+    except OSError:
+        print('Loading executables dynamically seems not to be supported on this platform')
+        exit(1)
+
+
+def dlclose(obj):
+    """
+    Close/unload a PIE binary or a shared library.
+
+    :param obj: object returned by ctypes.CDLL when the resource was loaded
+    """
+    if platform == 'linux':
+        _ctypes.dlclose(obj._handle)  # pylint:disable=protected-access
+    # else:
+    #     _ctypes.FreeLibrary(obj._handle)  # pylint:disable=protected-access
+
+
+def enc_args(args):
+    """
+    Convert args to a suitable format for a foreign C function.
+
+    :param args: list of strings
+    """
+    xargs = (ctypes.POINTER(ctypes.c_char) * len(args))()
+    for idx, arg in enumerate(args):
+        xargs[idx] = ctypes.create_string_buffer(arg.encode('utf-8'))
+    return xargs
+
+
+def byte_buf(lst):
+    """
+    Convert array to a string buffer (uint8_t* in C).
+
+    :param lst: list of naturals range [0,255]
+    """
+    return ctypes.create_string_buffer(bytes(lst), len(lst))
+
+
+def int_buf(lst, bpw=4, signed=True):
+    """
+    Convert array to a string buffer (uint8_t* in C).
+
+    :param lst: list of integers
+    :param bpw: number of bytes per word/integer
+    :param signed: whether to encode the numbers as signed
+    """
+    out = [None] * 4 * len(lst)
+    for idx, val in enumerate(lst):
+        out[idx * 4:idx * 4 + 4] = (val).to_bytes(bpw, byteorder="little", signed=signed)
+    return byte_buf(out)
+
+
+def read_byte_buf(buf):
+    """
+    Read byte/string buffer (uint8_t* in C) as a list of numbers.
+    """
+    return read_int_buf(buf, bpw=1, signed=False)
+
+
+def read_int_buf(buf, bpw=4, signed=True):
+    """
+    Read byte/string buffer as a list of numbers.
+
+    :param buf: byte/string buffer (uint8_t* in C) to read from
+    :param bpw: number of bytes per word/integer
+    :param signed: whether to decode the numbers as signed
+    """
+    out = [None] * int(len(buf) / bpw)
+    if bpw == 1:
+        for idx, val in enumerate(buf):
+            out[idx] = int.from_bytes(val, byteorder="little", signed=signed)
+    else:
+        for idx, _ in enumerate(out):
+            out[idx] = int.from_bytes(buf[idx * bpw:idx * bpw + bpw], byteorder="little", signed=signed)
+    return out