[LLVMdev] Project proposition: llvm based dsp engine

[Maurizio De Cecco]

I have been looking for a while to  LLVM as a possible technology to 
build a DSP execution engine, providing the runtime flexibility needed 
by real-time interactive DSP applications (like patcher languages), or 
by plug-in based processors, and in the same moment
the powerful link time optimizations that such a system can provide.

Such a task is daunting for a single developer project like mine, but it 
may become feasible if  such engine could be useful for multiple 
projects, so to become a community initiative (i am sending this
mail to the Linux Audio Developers mailing list and to the LLVM mailing 
list, feel free to send it elsewhere if you find it useful).

So, I'll explain in a few lines exactly what i thinking of, and i 
propose that if anybody is interested in such initiative she/he can 
contact me directly, and we will see if there is enough interest
for actually start something. Of course, i may also miss an existing 
project on the same field, in this case, let me know :->.

The idea is the following: build a tool kit, based on LLVM, to 
dynamically build the execution chain of DSP applications; almost all 
DSP applications using plug-ins have something of this kind.
This toolkit will be based on code generation and JIT, and should have a 
flexible architecture so to accomodate multiple plugin API/ABI, to be 
able to call, from the same execution chain, DSP operation written
for different contexts (for example, LADSPA plug-ins, PD objects, and so 
on). The code generation would allow this integration for a very low run 
time cost.

But the most interesting part is actually providing a definition of 
native, LLVM compiled, plug-ins, and to use the LLVM link time 
optimizations for doing things like inlining, loop fusions etc, between 
different DSP operation; this can provide quite a speed improvement for 
those chains composed of simple operators.

The execution chain should be flexible enough to provide support for 
multi-rate synchronous data flows, and should include support for 
multiple threads execution (probably different chains for different 
threads).

To complete the project, let's add a library of DSP operators, a 
reasonable high level API to use it, and documentation to help the DSP 
application designer (i find the LLVM learning curve quite steep :).

Contact maurizio at dececco.name if you are interest in setting up such a 
project; if enough developers with the right skills and enough interest 
are found I'll set up a project mailing list to further discuss the subject.

Cordially,
  Maurizio


__________
Maurizio De Cecco  -
Music:    http://www.myspace.com/mauriziodececco
Blog:     http://maurizio.dececco.name/
Software: http://www.jmax-phoenix.org/