Julia Interface to the Cpp and CUDA parts of GENN.

[russelljjarvis]

Even though its currently un-supported, do you think it would be possible to program GENN using Julia instead of Python?

GENN is a code generator and Julia is good for meta-programming, so I am guessing this might be an okay idea. Furthermore, Julia has some support of cpp, and great support for CUDA.

I have some connectivity matrices that I have wrangled from the Sonata format (HDF5) Allen Brain V1 model.

https://github.com/russelljjarvis/getConnectomes/blob/main/load_allen_measured_model.jl

Could I hack this cpp example to use my connection matrices using codegen that comes from inside Julia?

https://genn-team.github.io/genn/documentation/4/html/dc/d7e/Tutorial2.html

[neworderofjamie]

I know nothing about Julia but I think you can call into Python so, if that extends to numpy arrays, then you could copy your arrays straight into PyGeNN easily enough. The python version of https://genn-team.github.io/genn/documentation/4/html/d5/d39/subsect34.html describes how to manually set sparse connectivity from two lists/numpy arrays.

[russelljjarvis]

Thanks. I will try it out, and report back!

[russelljjarvis]

Yes, I can use PyCall, but I think I will get faster overall performance if I call cpp from Julia. Still, I think I should use pycall as you write to get warmed up and to make more progress on this task.

[russelljjarvis]

To get Julia support for Genn, all the compiled code that lives in ~/git/genn/pygenn/genn_wrapper

(all the *.so files) can in theory be wrapped in:

https://github.com/JuliaInterop/CxxWrap.jl

But I would need to add a libcxxwrap.h header file to that directory recompile those files with
substituting these calls:

genn/src/genn/genn/Makefile

Lines 31 to 36 in 6b09eaa

	$(CXX) -dynamiclib -undefined dynamic_lookup $(CXXFLAGS) -o $@ $(OBJECTS)
	install_name_tool -id "@loader_path/$(@F)" $@
	else
	$(LIBGENN): $(OBJECTS)
	mkdir -p $(@D)
	$(CXX) -shared $(CXXFLAGS) -o $@ $(OBJECTS)

ifdef DYNAMIC
ifeq ($(DARWIN),DARWIN)
$(LIBGENN): $(OBJECTS)
mkdir -p $(@d)
$(CXX) -dynamiclib -undefined dynamic_lookup $(CXXFLAGS) -o $@ $(OBJECTS)
install_name_tool -id "@loader_path/$(@f)" $@
else
$(LIBGENN): $(OBJECTS)
mkdir -p $(@d)
$(CXX) -shared $(CXXFLAGS) -o $@ $(OBJECTS)
endif
else
$(LIBGENN): $(OBJECTS)
mkdir -p $(@d)
$(AR) $(ARFLAGS) $@ $(OBJECTS)
endif

-include $(DEPS)

$(OBJECT_DIRECTORY)/%.o: %.cc $(OBJECT_DIRECTORY)/%.d
mkdir -p $(@d)
$(CXX) -std=c++11 $(CXXFLAGS) -c -o $@ $<

%.d: ;

With

mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH=/path/to/libcxxwrap-julia-prefix /path/to/sourcedirectory
cmake --build . --config Release

Which may not even make sense because I think (CXX) evaluates to g+ not cmake.

I am sure there would be a way to do it.

That compilation to make the cpp discoverable is just writing the Julia wrapper code. I have established that building Genn inside a julia environment is possible on all platforms using:

https://github.com/JuliaPackaging/BinaryBuilder.jl

[russelljjarvis]

Be warned, SWIG is going to be dropped in the next release (as it's badly supported, buggy, slow and generates massive python extensions) and replaced with manually-created PyBind11 bindings (e.g. https://github.com/genn-team/genn/blob/genn_5/pygenn/src/genn.cc)

This actually works out better from a Julia interface perspective, as swig makes the process opaque, there is no easy way to replicate what swig does with Julia.

[russelljjarvis]

Nonetheless, in terms of compilers, GeNN builds with MSVC 2017, 2019, 2022, GCC > 4.9.1 and Clang (as far as I know, only tested on Mac but I imagine setting CXX will work). No particular plans to switch from MSBuild/GNU make to cmake though

This might also be good in terms of writing an interface.

I think I just need to make these header files (
https://github.com/JuliaInterop/libcxxwrap-julia/tree/main/include/jlcxx) visible to the compiler and plonk them in the same directory as this:
https://github.com/genn-team/genn/blob/genn_5/pygenn/src/genn.cc

The two documented options are cmake and autoconfig.

Is it theoretically possible for me to create an autoconfig file from the Make files?

[neworderofjamie]

I don't think what's used to build GeNN is important as extension building is two stage:

1. You build a dynamic library using make and
2. Build the extension with whatever build system you want e.g. the Python one is built using setuptools through https://github.com/genn-team/genn/blob/genn_5/setup.py#L6.

I don't see why the same couldn't be done with Julia - just link the dynamic library, include suitable headers, write your binding code and build with cmake.

[russelljjarvis]

This would be awesome, I had been messing around with this for about 48 hours previously. But I wasn't smart enough to figure out how to convert make files into cmake commands.

Can I get ask for advice here about techniques for converting the make files to cmake commands (assuming all of my environmental variables are correct, cmake compiler is cuda compatible, and cuda driver is functional)?

This also looks like it would help (an auto function wrapper, Cpp function discovery tool):
https://github.com/grasph/wrapit

It looks like I might be able to mix and match this Makefile

https://github.com/grasph/wrapit/blob/main/examples/ex001-HelloWorld/Makefile

with the genn Makefile(s).

[neworderofjamie]

I don't think you need to - just build libGeNN, libCUDABackend etc using make with DYNAMIC=1 (following the first step of the PyGeNN instructions) and then use whatever build system you want for building your Julia extension and link against the libraries.