In previous articles we introduced the CBinding.jl Julia package and demonstrated it with a binary I/O example. The new version of CBinding.jl brings support for C (ANSI C, C89, C99, C11, and C18) constructs to Julia and offers the following features:

Even perfectly valid, yet somewhat inhumane C definitions are supported, such as:

Several significant changes to the package were made with the 1.0 release, including the integration of capabilities from CBindingGen.jl for automatic bindings generation. Therefore, this article aims at helping you transition your code to incorporate these changes so you can save time and effort.

While much of the behind-the-scenes representation of C types remains the same, the method of defining them has changed. Rather than using the half-C, half-Julia @cstruct, @cunion, or @cenum macro syntax (which was fairly unnatural for both C and Julia developers), the C code itself is now used as-is.

Below is a more realistic example where the C code might rely on types defined in other header files or Julia packages.

Using the C syntax itself makes for a more natural and convenient way of expressing types since the C code probably already exists. In fact, the update detailed below takes advantage of that fact to make defining bindings even easier!

In general, C libraries come with header files defining how to interface them. Since CBinding.jl utilizes a C parser to convert C code into Julia, it is now possible to just directly include the definitions from the header files themselves. Using libsndfile as example, we can simply define the module as below to automatically create bindings.

Users transitioning to Julia from a C or C++ background should find that this method of creating bindings is familiar and easy to work with. Creating a compiler context closely resembles a command-line for compiling C code that uses the library. And just as in C, including the header file defines the types, functions, global variables, and (some of) the macros provided by the library that can then be used in Julia code.

Calling a C library’s functions (even variable-length argument functions) is done in the standard way, func(arg1, arg2, …​), but the bindings created with the new release can also be used to obtain function pointers. Often callback functions and object-oriented types require users to obtain and store function pointers. We have made this easy and elegant by using the empty subscript (func_ptr = func[]) on function bindings.

A change was also made to global variable bindings. Access to a C library’s global variable is achieved with the empty subscript operator as well (global_var[] to load, global_var[] = val to store).

Package load times should be noticeably better in the new version. The original macro approach used by CBinding.jl and CBindingGen.jl resulted in very slow package compilation times. Our new approach has resulted in practically imperceivable compilation times compared to equivalent Julia definitions that even allows for an interactive C experience in the REPL.

The performance of using the C constructs is vastly improved as well. Everything from accessing nested fields in user-defined types to calling function bindings has been significantly optimized. We will use the following types to demonstrate comparable performance with native Julia code.

Now that we have defined equivalent types, we can use a simple function to benchmark performance.

As you can see, the performance of using the two immutable objects is identical, and accessing the two mutable objects is practically identical as well.

One of the big features introduced with the 1.0 release is the process of dereferencing pointers. When manipulating objects in memory, by using a pointer to a user-defined type, the access of a field member actually results in a pointer to the field rather than the value of it. Therefore, loading or storing values in memory (for either primitive or aggregate fields) is accomplished by dereferencing the pointer with the empty subscript syntax (ptr[] to load, ptr[] = val to store). We illustrate this with the zero-copy, memory-mapped binary I/O example below.

The performance of accessing memory is similar to that of accessing fields in a mutable Julia type. Knowing that fields in immutable types can be used approximately 100 times faster, it is sometimes beneficial to load an entire object from memory before repeatedly accessing fields in it. Experimentation and benchmarking are required to reveal how to optimally structure access patterns in your code.

Another feature introduced in the 1.0 release is the automated importing of code documentation from C into Julia. It is converted automatically just by including a C header file containing properly formatted documentation. Using the libsndfile bindings example from above, the REPL help mode can be used to display the definition and documentation, as shown below:

If you are considering the transition to Julia, but have several C libraries you depend on, let us help! Analytech Solutions offers many years of experience working with both Julia and C, and we can streamline your transition process. Please contact us for more information!

Keith Rutkowski is a seasoned visionary, inventor, and computer scientist with a passion to provide companies with innovative research and development, physics-based modeling and simulation, data analysis, and scientific or technical software/computing services. He has over a decade of industry experience in scientific and technical computing, high-performance parallelized computing, and hard real-time computing.