1 of 22

2 of 22

Tales from FFI

Building in Rust for Python

🦀 ❤️ 🐍

Ishan Bhanuka

@twitu

Rust India July Meetup

3 of 22

Intro Briefly

🤯🤪

4 of 22

Cover we will

What?
How?
Enough talk, Now code
When to use?

5 of 22

What?

6 of 22

What?

7 of 22

What?

`extern` keyword in C introduces the concept of data or function that is "external" to the program.

Similarly rust has `extern "C" fn` which says the function can be called from outside the rust program. Here the "C" indicates that calling the function should be called as if it were a C function.

https://doc.rust-lang.org/nomicon/ffi.html#foreign-function-interface

—

Concepts

Logic in Language R and P need to be bundled together.

Static linking - This can be done before executing the program. All the logic is packaged into a single bundle.

Dynamic linking - While the program is executing the required bundle is loaded. Check dlopen.

This is more involved and you can look at it separately.

ABI - Application Binary Interface. When a language R calls language P through ffi it needs to be sure that it understands how the language P represents the data. If P changes it's data representation frequently R won't understand it and well the program will crash.

—

Examples:

* WASM running the browser.

* Writing android mobile app using Rust on mobile using JNI

* LLVM compiler written in C++ has bindings for Rust

* and many more ...

8 of 22

9 of 22

How?

Control flow?
Data transfer?
Data representation?
Memory management?

10 of 22

How? Control Flow?

11 of 22

How? Control Flow?

12 of 22

How? Data transfer?

The biggest challenge with ffi is for both languages to agree on the data representation. In case of Python everything is an object and a pointer. For Rust everything is a struct i.e. a block of memory either allocated on the stack or the heap. Is there no common ground for Python and Rust to agree on a data representation….

Well actually there is. The core of CPython is written in C and well Rust and C do agree on representing data as a block of memory and pointers to dereference said block of memory.

We can use this to systematically translate or transfer Python data into Rust data. Inside the object there is something like a pointer with a lot of metadata, the pointer is passed to Rust through an extern function. But we need a lot more metadata to properly use Python objects this of course is hidden somewhere in the block of memory. Pyo3 is a Rust library that extracts all this information and makes it easy to do the ffi. It’s of course a bunch of low level unsafe stuff that relies on manually translating Python’s object format.

But at the end we can extract copy types directly. For Clone types we need a deep extract. For e.g. a List of Ints can only be converted to a Vec<usize> by first going into the list extracting the ints and then creating a Vec and putting those usizes in the Vec.

13 of 22

How? Data transfer?

14 of 22

How? Data transfer?

15 of 22

How? Data representation?

But you see Python has a liberaly data model with few restrictions it can store a list of heterogeneous items which can’t be represented at all in standard Rust data types. In such cases, Pyo3 gives us a generic wrapped pointer known as a PyAny. It’s pretty much equivalent to an object in Python.

Analogy: You see when the Bengali and Tamil are living together they need to be able to communicate with each other. But they are only fluent in their native languages and a little smattering of english in between. Thankfully that little bit of English will save them because it is some common ground on which they can start communicating. Think of Pyo3 as a dictionary that helps them communicate by translating their little common ground of English through which they convert Tamil to English and then English to Bengali. But of course everything can’t be translated and some specifics are lost in translation.

16 of 22

How? Memory management?

Now there is one rule regarding heap allocated objects that both languages need to follow. The one who allocates is the one who deallocates if this is not followed there might be memory leaks or dangling pointers. Stack memory is allocated on the stack in a stack frame and is deallocated once the function returns and the stack frames is removed.

Now in case of Python everything is allocated on the heap so all objects need to go back to Python to be garbage collected. For Rust Copy types are directly translated, while heap types are either translated or transferred as pointers. But they need to be returned to Rust so that it can be properly deallocated.

Coming back to our Tamil and Bengali friends they live in the same apartment so they need to share common space and items like kitchen utensils and tv remote. So they only rule is that if someone uses somebody else’s stuff they should return it. Otherwise there will be trouble.

17 of 22

18 of 22

Working Example

Rust logger for Python

🦀 ❤️ 🐍

19 of 22

When to FFI?

Technically possible?
Fits the context?

Biggest benefit??

Performance 🤤
Correctness 🏎️
Maintainer velocity 🧑‍💻

Toy example should we use this logger or any logger written in Rust. It’s not a simple answer. In nautilus we actually interfaced the logger with Cython this was so that logging could be done using pointers which means logging could be done without acquiring the GIL.

FFI introduces significant additional complexity to a codebase. Firstly it must be possible to interface the two languages, and the developers must be comfortable with both. Their must be decent enough tooling so that it’s not an uphill battle to implement features.

The next consideration is why it is needed. And if it’s fits the context of the project. For e.g. in the nautilus project most of the users writing strategies are data scientists, traders etc and they are comfortable with Python. So the idea was to have the scripting flexibility of Python for the user interface along with the benefits of Rust for the core engine.

Take a guess which one is the biggest benefit of the rewrite?

Of course there’s magnitude of performance improvement and far fewer bugs.

But the biggest benefit of the project was not the safety or correctness but the fact that it significantly improved developer velocity. For a small open source project with 3-4 maintainers burnout/dropout is very real. Because of the well known advantages of Rust, the project can now work on implementing important features rather than performance tuning and solving silly bugs.

20 of 22

21 of 22

Advanced Patterns

Generics - Void pointer + Tag
Accessing Python objects in Rust
Async stuff
Interfacing Rust and Cython

FFI introduces significant additional complexity to a codebase. Firstly it must be possible to interface the two languages, and the developers must be comfortable with both. Their must be decent enough tooling so that it’s not an uphill battle to implement features.

The next consideration is why it is needed. And if it’s fits the context of the project. For e.g. in the nautilus project most of the users writing strategies are data scientists, traders etc and they are comfortable with Python. So the idea was to have the scripting flexibility of Python for the user interface along with the benefits of Rust for the core engine.

Take a guess which one is the biggest benefit of the rewrite?

Of course there’s magnitude of performance improvement and far fewer bugs.

But the biggest benefit of the project was not the safety or correctness but the fact that it significantly improved developer velocity. For a small open source project with 3-4 maintainers burnout/dropout rate is very real. Because of the well known advantages of Rust, the project can now work on implementing important features rather than performance tuning and solving silly bugs.

22 of 22

References

FFI introduces significant additional complexity to a codebase. Firstly it must be possible to interface the two languages, and the developers must be comfortable with both. Their must be decent enough tooling so that it’s not an uphill battle to implement features.

The next consideration is why it is needed. And if it’s fits the context of the project. For e.g. in the nautilus project most of the users writing strategies are data scientists, traders etc and they are comfortable with Python. So the idea was to have the scripting flexibility of Python for the user interface along with the benefits of Rust for the core engine.

Take a guess which one is the biggest benefit of the rewrite?

Of course there’s magnitude of performance improvement and far fewer bugs.

But the biggest benefit of the project was not the safety or correctness but the fact that it significantly improved developer velocity. For a small open source project with 3-4 maintainers burnout/dropout rate is very real. Because of the well known advantages of Rust, the project can now work on implementing important features rather than performance tuning and solving silly bugs.