Using FXP for fixed point input to c functions

[chrisbaldwin2]

I am using your FXP library for fixed point python and loving it! I am currently working on a tool to translate python to RTL but need some help. I am trying to pass arrays of fixed point values to c functions, but am getting caught with TypeErrors. I am using Vivado's ap_fixed.h library on the C side. I have tried using wrapper functions but would love to see if any of you have tried this.

Please feel free to reach out by email at [email protected]

[francof2a]

Hello @chrisbaldwin2,
It's really nice that fxpmath is useful for you.
Your project is a great idea. I have experience with RTL but have no experience with RTL synthesis from high level language like C.

It would be nice if you provide an example of your problem.

[chrisbaldwin2]

Sure thing. I have made a short example file. My goal is to test the python and C code in order to ensure that the translation works successfully. We then use Vivado HLS to turn C code into RTL.

This file contains the python function [py_start] that we are testing as well as the main function which tests against the c function [c_start].

py_start.py

from ctypes import *
import random
import pathlib
import numpy as np
from numpy.ctypeslib import ndpointer

def py_start(x, y):
## Literally the most miserable python but zip doesn't work, y=x+2 doesn't work
for i, x_val in enumerate(x):
y[i] = x_val + 2
# print(y)

if name == "main":
print('------Starting Python------')
x = np.array([1.1, 2.2, 3.3], dtype=np.float32)
y_py = np.zeros([3], dtype=np.float32)
y_c = np.zeros([3], dtype=np.float32)

print('--Running Python--')
py_start(x, y_py)

print('--Running C--')
# print('CDLL')
c_lib = CDLL("./c_start.so")
# print('Args')
c_lib.c_start.argtypes = [ndpointer(c_float, flags="C_CONTIGUOUS"), ndpointer(c_float, flags="C_CONTIGUOUS")]
# print('Func Call')
c_lib.c_start(x, y_c)
# print('End Func Call')
print('Python: ' + str(y_py))
print('C:      ' + str(y_c))
print('------Finishing Python------')

end of py_start.py

start of c_start.cpp

#define ARRAY_LEN 3

void c_start(float x[ARRAY_LEN], float y[ARRAY_LEN]){
for(int i=0; i<ARRAY_LEN; i++){
y[i] = x[i]+2;
}
}
// Need shell of main function for unknown g++ reasons
int main(){
return 0;
}

end of c_start.cpp

This code above works with floats but what we need to do is be able to pass fixed point vales to the c function. We need to use Vivado's ap_fixed.h library for HLS synthesis but since this type is not in Python, I am running into issues trying to call the C function. I tried getting around this by using a void * wrapper but it still doesn't work. I am very new to calling c functions within python so I was wondering if you had any tips for how to get this to work. Would there be a way to define ap_fixed within python to match the types? Is the void * method the right direction?

start of py_fixed.py

import numpy as np
from fxpmath import Fxp
from numpy.ctypeslib import ndpointer

def py_start(x, y):
## Literally the most miserable python but zip doesn't work, y=x+2 doesn't work
for i, x_val in enumerate(x):
y[i] = x_val + 2
# print(y)

if name == "main":
print('------Starting Python------')
x = Fxp([1.1, 2.2, 3.3], n_word=16, n_frac=2)
y_py = Fxp([0, 0, 0], n_word=16, n_frac=2)
y_c = Fxp([0, 0, 0], n_word=16, n_frac=2)

print('--Running Python--')
py_start(x, y_py)

print('--Running C--')
# print('CDLL')
c_lib = CDLL("./c_fixed.so")
# print('Args')
c_lib.c_start.argtypes = [ndpointer(c_void_p), ndpointer(c_void_p)]
# print('Func Call')
c_lib.c_start(x, y_c)
# print('End Func Call')
print('Python: ' + str(y_py))
print('C:      ' + str(y_c))
print('------Finishing Python------')

end of py_fixed.py

start of c_fixed.cpp

#define ARRAY_LEN 3
#include <ap_fixed.h>

typedef ap_fixed<16, 2> data_t;

extern "C" void c_start(data_t *x, data_t *y){
for(int i=0; i<ARRAY_LEN; i++){
y[i] = x[i]+2;
}
}

extern "C" void c_start_wrap(void x, void y){
c_start( (data_t) x, (data_t) y);
}

int main(){
return 0;
}

end of c_fixed.cpp

[francof2a]

Doing a quick review of the code, I think the problem is in how arguments are passed to C function.

When:

c_lib.c_start(x, y_c)

x and y_c are Fxp objects that C function doesn't know how handle. I think you need to pass the float or int representation of values stored in Fxp objects, so maybe you can try:

c_lib.c_start(x(), y_c())    # equivalent to c_lib.c_start(x.get_val(), y_c.get_val())  

The code above is passing numpy arrays to your C function. It could be also a problem if your C function can't handle ndarray also. In that case you can send python lists just like:

c_lib.c_start(x().tolist(), y_c().tolist())

The problem of doing all of this is new objects are created (ndarray or list). So, your pointer are pointing to new objects. A workar around could be:

x_ptr = x()    # or x_ptr = x().tolist()
y_c_ptr = y_c()

c_lib.c_start(x_ptr, y_c_ptr)

x(x_ptr)
y_c(y_c_ptr)

An alternative approach is to return the array modified from C function, so:

y_c.equal(lib.c_start(x(), y_c()))

A little more elegant :)

[chrisbaldwin2]

I am able to convert from fixed to floating point and back (the c code is not actually fully fleshed out) but in our case of doing an RTL
conversion, this type casting does have a performance impact. Would there be any way to actually call the c function without having to convert to floating point for the C call? Unfortunately this kind of translation would have an impact on the C translation. Ultimately it would be best to call with some intermediate either char, short, or int pointer that the fixed point goes through so that the c code does not have to do a quantization of the value.

This is the code that I was able to get working with the fixed point conversion. Again to just somehow pass a pointer to the bits and typecast that to a fixed value rather than go fixed to float to fixed to float to fixed would be much more efficient. This has a significant impact both on simulation and on hardware utilization. Do you know what would be involved in actually importing the ap_fixed type into python? I think that may be the best solution for our case but I am not really sure. I think as long as the python interpreter believes your Fxp type is the same (assuming the bit order is the same) as ap_fixed, we shouldn't have a problem with calling c functions with ap_fixed parameters.

Again thank you so much with your help so far and would love to get this working more efficiently soon!

Chris

##Start of py_fixed.py
from ctypes import *
import random
import pathlib
import numpy as np
from fxpmath import Fxp
from numpy.ctypeslib import ndpointer

def py_start(x, y):
## Literally the most miserable python but zip doesn't work, y=x+2 doesn't work
for i, x_val in enumerate(x):
y[i] = x_val + 2
# print(y)

if name == "main":
print('------Starting Python------')
x = Fxp([1.1, 2.2, 3.3], n_word=16, n_frac=2)
y_py = Fxp([0, 0, 0], n_word=16, n_frac=2)
y_c = Fxp([0, 0, 0], n_word=16, n_frac=2)

print('--Running Python--')
py_start(x, y_py)

print('--Running C--')
print('CDLL')
c_lib = CDLL("./c_start.so")
print('Args')
c_lib.c_start_wrap.argtypes = [ndpointer(c_float), ndpointer(c_float)]
print('Function Parameters')
x_ptr, y_ptr = np.array(x.astype(float), dtype=np.float32), np.array(y_c.astype(float), dtype=np.float32)
print(x_ptr)
print('Func Call')
c_lib.c_start_wrap(x_ptr, y_ptr)
y_c.equal(y_ptr)
print('End Func Call')
print('Python: ' + str(y_py))
print('C:      ' + str(y_c))
print('------Finishing Python------')

##End of py_fixed.py

##Start of c_fixed.cpp
#define ARRAY_LEN 3
#include <ap_fixed.h>
#define FLOAT_TEST 0

typedef ap_fixed<16, 2> data_t;

extern "C" void c_start(data_t *x, data_t *y){
for(int i=0; i<ARRAY_LEN; i++){
y[i] = x[i]+2;
}
}

extern "C" void c_start_wrap(float x, float y){
#if FLOAT_TEST
for(int i=0; i<ARRAY_LEN; i++){
y[i] = x[i]+2;
}
#else
c_start( (data_t) x, (data_t) y);
#endif
}
##End of c_fixed.cpp

[chrisbaldwin2]

@francof2a
After some time, I have a working way to send fixed point to ap_fixed. What I was able to do is just match the raw bits from Fxp to ap_fixed using the hex function and set_val with raw=True. One interesting note is that the bits only lineup if the int is 3 in Fxp and 4 in ap_fixed.

The only thing that would really help reduce the clumsiness would be if there was a function which allowed for the value to be output into an nd array with their raw value. That would prevent having to use x_nd = np.array([(int(x_s.hex(), 16)) for x_s in x], dtype=np.int16, order='C') which seems like I'm taking extra steps for no reason.

Is this a feature you would consider adding if not already implemented? If there is already a way to do it, would you mind sharing?

py_fixed.py

## Author: Chris Baldwin
## Date 12/14/2020

from ctypes import *
import random
import pathlib
import numpy as np
from fxpmath import Fxp
from numpy.ctypeslib import ndpointer

n_word = 16
n_int = 3

debug = False

## Python Function being tested. Subtracts 2 from x and outputs into y
def py_start(x, y):
    for i, x_val in enumerate(x):
        y[i] = x_val - 2

if __name__ == "__main__":
    print('------Starting Python------')
    ## Input for function
    x = Fxp([8, -4.23, 3.26], signed=True, n_word=n_word, n_int=n_int)
    ## Output for py function call
    y_py = Fxp([0, 0, 0], signed=True, n_word=n_word, n_int=n_int)
    ## Output for c function call
    y_c = Fxp([0, 0, 0], signed=True, n_word=n_word, n_int=n_int)


    print('--Running Python--')
    py_start(x, y_py)

    print('--Running C--')

    if debug:
        print('Cretating CDLL Object')
    c_lib = CDLL("./c_start.so")

    if debug:
        print('Defining Arguments')
    c_lib.c_start_wrap.argtypes = [ndpointer(c_int16), ndpointer(c_int16)]

    if debug:
        print('Creating Function Parameters')

    ## Converts Fxp object to list of integers
    x_nd = np.array([(int(x_s.hex(), 16)) for x_s in x], dtype=np.int16, order='C')
    ## Destination numpy array for integers return
    y_nd = np.zeros(3, dtype=np.int16, order='C')

    if debug:
        print('Type definitions:')
        print('X type ' + str(x.dtype))
        print('X list type ' + str( type(x()) ))
        print('X nd list ' + str(x_nd))

        print('Func Call')
    c_lib.c_start_wrap(x_nd, y_nd)

    if debug:
        print('End Func Call')

    ## Converts the integer value to Fixed point
    y_c.set_val((y_nd), raw=True)

    if debug:
        print('Py Binary:')
        print( y_py.bin(frac_dot=True) )
        print('C Binary:')
        print( y_c.bin(frac_dot=True) )

    print('Python: ' + str(y_py))
    print('C:      ' + str(y_c))
    print('------Finishing Python------')

c_start.c

// Author: Chris Baldwin
// Date: 12/14/2020
#include <ap_fixed.h>
#define ARRAY_LEN 3
#define DEBUG 1

typedef ap_fixed<16, 4> data_t;

extern "C" void c_start(data_t *x, data_t *y){
    for(int i=0; i<ARRAY_LEN; i++){
        // std::cout << "X = " << x[i].to_float() << " Y = " << y[i].to_float() << '\n';
        y[i] = x[i]-2;
        #if DEBUG
        std::cout << "Float:  X = " << x[i].to_float()  << " Y = " << y[i].to_float()  << '\n';
        std::cout << "String: X = " << x[i].to_string() << " Y = " << y[i].to_string() << '\n';
        #endif
    }
}

extern "C" void c_start_wrap(int16_t *x, int16_t *y){
    #if DEBUG
    printf("Pre: x %x y %x\n", *x, *y);
    #endif
    c_start( (data_t*) x, (data_t*) y);
    #if DEBUG
    printf("Post: x %x y %x\n", *x, *y);
    #endif
}

int main(){
    return 0;
}

Makefile

all: c_start.o c_start.so c_start

c_start.so: c_start.cpp
	g++ -std=c++11 -fPIC -I/tools/Xilinx/Vivado/2019.1/include -I/usr/include/python3.8 -shared c_start.cpp -o c_start.so

clean:
	rm c_start.o c_start.so c_start

[francof2a]

Hello Cris,

Do you know what would be involved in actually importing the ap_fixed type into python?

No, I don't know.

One interesting note is that the bits only lineup if the int is 3 in Fxp and 4 in ap_fixed

Could it be because sign bit? n_int int signed Fxp does not include sign bit, but n_word do include obviously.
I don't know anything about ap_fixed, sorry.

The only thing that would really help reduce the clumsiness would be if there was a function which allowed for the value to be output into an nd array with their raw value. That would prevent having to use x_nd = np.array([(int(x_s.hex(), 16)) for x_s in x], dtype=np.int16, order='C') which seems like I'm taking extra steps for no reason.

Is this a feature you would consider adding if not already implemented? If there is already a way to do it, would you mind sharing?

Fxp store its raw value(s) in a ndarray internally, and you can access doing x.val, but if Fxp is signed, raw values are signed also (int64 for example). It's not implemented a method to recover raw values as unsigned (in signed Fxp), but I see now it could be useful (I'll include that in next release, thanks).

Instead of doing a conversion by .hex, I think you may do the conversion in the following way:

x_nd = np.where(x.val < 0, (1 << x.n_word) + x.val, x.val)    # adding the casting you need

The code above is converting negative integers into positives according number of bits of Fxp.