Viper bit manipulation challenges

[sk8board]

My application requires many bit manipulations be performed frequently. Therefore I want my bit manipulation code to be as efficient as possible to allow more time for the processor to perform other tasks.

Viper documentation states that Viper is very fast when using pointers. So I tried a simple program to learn bit manipulation with Viper.

As you might have guessed, I am having errors related to types, such as:

Here I have B:int =, but I get an error if I do not convert B to an int again. Why do I have to use int(B) after using B:int = ?

from array import array

d = array('L',[3])

@micropython.viper
def bit_manip(A:ptr32):
    print("A =",f"{A:003b}")
    B:int = ((int(A) >> 1 & 1) != 0)
    print("B =", f"{B:003b}")
    C:int = int(B) | (1 << 1)     # why must "B" be converted to an int a second time?
    print("C =", f"{C:003b}")


bit_manip(d[0])

# If I do not use int(B) after B:int =, then I receive this error. ViperTypeError: can't do binary op between 'bool' and 'int'

The function below used A:ptr32 at the beginning, but later I have to convert A to an int int(A) for the function to work. Why?

from array import array

d = array('L',[3])

@micropython.viper
def bit_manip(A:ptr32):         # I use A:ptr32 with intent of using pointer within the function
    print("A =",f"{A:003b}")
    B:int = ((A[0] >> 1 & 1) != 0)  # the function does not work when I use A[0], but int(A) does work. Why?
    print("B =", f"{B:003b}")
    C:int = int(B) | (1 << 1)     
    print("C =", f"{C:003b}")
    

bit_manip(d[0])

Could you please help me understand how to use Viper bit manipulation with fastest completion time?

[bixb922]

See here for a detailed description of Viper: https://github.com/micropython/micropython/wiki/Improving-performance-with-Viper-code

In both examples, you pass d[0] to bit_manip. You need to call bit_manip(d), so that within bit_manip, A becomes a pointer to the array d, and A[0] is the first element of d.

((A[0] >> 1 & 1) != 0) yields a boolean because of the != operator. B:int is then overridden and B winds up as a boolean. That's why you need to cast with int() again. Note that B:int is not a type cast, it's only a type hint. In fact, in viper functions, the only type hints that do something are the type hints of parameters and of the return type. B:int = something does not influence what Viper does.

Used with the Viper intdata type and ptr data types to access integer arrays, viper is very fast.

[sk8board]

Very helpful. Thank you for taking time to explain. Do you know if there is a significant speed advantage with a pointer vs an integer with regard to bit manipulations?

[bixb922]

A ptr has to be indexed to get the value as in A[0]. A plain Viper int is fastest, indexing a pointer with a constant is a bit slower, indexing with a viper int variable is a bit slower again. But always a lot faster than Non-Viper code.

Assigning A[0] to a int variable only is a gain if you use that variable 2 or 3 times. It's best to try this out and measure what's fastest.

[sk8board]

I rewrote four data parsing functions from MicroPython to Viper, which reduced process time from 1100us to 230us.

I then rewrote the four Viper functions into one long Viper function, which reduced process time from 230us to 120us. I did not expect one large function to reduce process time by half. Is this a common result?

[bixb922]

Viper calls can be several times faster than regular calls. The gain you see really depends on the frequency of the call, but it's very possible to see this effect. It's best to experiment and measure.

[sk8board]

1. A plain Viper int is fastest,
2. indexing a pointer with a constant is a bit slower,
3. indexing with a viper int variable is a bit slower again. But always a lot faster than Non-Viper code.

Assigning A[0] to a int variable only is a gain if you use that variable 2 or 3 times. It's best to try this out and measure what's fastest.

Very helpful. I tested my code against this and I agree with your statement. Thank you.