48

I want to extend python and numpy by writing some modules in C or C++, using BLAS and LAPACK. I also want to be able to distribute the code as standalone C/C++ libraries. I would like this libraries to use both single and double precision float. Some examples of functions I will write are conjugate gradient for solving linear systems or accelerated first order methods. Some functions will need to call a Python function from the C/C++ code.

After playing a little with the Python/C API and the Numpy/C API, I discovered that many people advocate the use of Cython instead (see for example this question or this one). I am not an expert about Cython, but it seems that for some cases, you still need to use the Numpy/C API and know how it works. Given the fact that I already have (some little) knowledge about the Python/C API and none about Cython, I was wondering if it makes sense to keep on using the Python/C API, and if using this API has some advantages over Cython. In the future, I will certainly develop some stuff not involving numerical computing, so this question is not only about numpy. One of the thing I like about the Python/C API is the fact that I learn some stuff about how the Python interpreter is working.

Thanks.

Community
  • 1
  • 1
Edouard
  • 1,463
  • 1
  • 11
  • 13
  • BLAS and LAPACK are already integrated in scipy if I recall correctly – fabrizioM Apr 19 '11 at 18:46
  • Note: the link that your provided for [some cases](http://wiki.cython.org/tutorials/numpy#UsingtheNumpyCAPI) points to a code that uses Numpy/C API from *Cython*, not C. – jfs Apr 19 '11 at 18:53
  • 1
    @fabrizioM: Yes, BLAS and LAPACK are used in numpy and scipy. But I want to develop numerical algorithms which are not in numpy nor scipy, and I want to do it in C/C++ for efficiency reasons. – Edouard Apr 19 '11 at 21:56
  • @J.F. Sebastian: True. My point is that this code is quite close to the C code one would write using the Numpy/C API: the underlying behavior has to be known (like reference counts). – Edouard Apr 19 '11 at 22:09

3 Answers3

92

The current "top answer" sounds a bit too much like FUD in my ears. For one, it is not immediately obvious that the Average Developer would write faster code in C than what NumPy+Cython gives you anyway. Quite the contrary, the time it takes to even get the necessary C code to work correctly in a Python environment is usually much better invested in writing a quick prototype in Cython, benchmarking it, optimising it, rewriting it in a faster way, benchmarking it again, and then deciding if there is anything in it that truly requires the 5-10% more performance that you may or may not get from rewriting 2% of the code in hand-tuned C and calling it from your Cython code.

I'm writing a library in Cython that currently has about 18K lines of Cython code, which translate to almost 200K lines of C code. I once managed to get a speed-up of almost 25% for a couple of very important internal base level functions, by injecting some 20 lines of hand-tuned C code in the right places. It took me a couple of hours to rewrite and optimise this tiny part. That's truly nothing compared to the huge amount of time I saved by not writing (and having to maintain) the library in plain C in the first place.

Even if you know C a lot better than Cython, if you know Python and C, you will learn Cython so quickly that it's worth the investment in any case, especially when you are into numerics. 80-95% of the code you write will benefit so much from being written in a high-level language, that you can safely lay back and invest half of the time you saved into making your code just as fast as if you had written it in a low-level language right away.

That being said, your comment that you want "to be able to distribute the code as standalone C/C++ libraries" is a valid reason to stick to plain C/C++. Cython always depends on CPython, which is quite a dependency. However, using plain C/C++ (except for the Python interface) will not allow you to take advantage of NumPy either, as that also depends on CPython. So, as usual when writing something in C, you will have to do a lot of ground work before you get to the actual functionality. You should seriously think about this twice before you start this work.

Stefan Behnel
  • 921
  • 1
  • 5
  • 2
11

First, there is one point in your question I don't get:

[...] also want to be able to distribute the code as standalone C/C++ libraries. [...] Some functions will need to call a Python function from the C/C++ code.

How is this supposed to work?

Next, as to your actual question, there are certainly advantages of using the Python/C API directly:

  • Most likely, you are more familar with writing C code than writing Cython code.

  • Writing your code in C gives you maximum control. To get the same performance from Cython code as from equivalent C code, you'll have to be very careful. You'll not only need to make sure to declare the types of all variables, you'll also have to set some flags adequately -- just one example is bounds checking. You will need intimate knowledge how Cython is working to get the best performance.

  • Cython code depends on Python. It does not seem to be a good idea to write code that should also be distributed as standalone C library in Cython

Sven Marnach
  • 574,206
  • 118
  • 941
  • 841
  • 1
    "How is this supposed to work?" -- The usual method is to embed the Python interpreter, no? – Nicholas Knight Apr 20 '11 at 11:29
  • @Nicholas: I don't know if this is what the OP plans to do. Maybe the functions that will need to call Python functions simply won't be part of the C library? Some clarification would be nice. (And I'm aware that this first part is more of a comment than an answer, but since I was writing an answer anyway, I put it there for better formatting.) – Sven Marnach Apr 20 '11 at 11:48
  • The point you raise is indeed not very clear. What I meant is that some functions of my library will take user defined functions as argument. Python users will define those functions in Python and C/C++ users will use functors in C/C++ instead. Is this more clear ? – Edouard Apr 20 '11 at 18:15
  • In addition, Cython doesn't seem to give you full safety/portability because its type system is quite impoverished compared to C (although `size_t` was finally added in 0.11). – Fred Foo May 04 '11 at 07:57
0

The main disadvantage of the Python/C API is that it can be very slow if it's used in an inner loop. I'm seeing that calling a Python function takes a 80-160x hit over calling an equivalent C++ function.

If that doesn't bother your code then you benefit from being able to write some chunks of code in Python, have access to Python libraries, support callbacks written directly in Python. That also means that you can make some changes without recompiling, making prototyping easier.

Adam
  • 16,808
  • 7
  • 52
  • 98