how can i use cuda with nodejs - c++

Question

Cuda is Nivida provided api that lets c/c++ use gpu for some stuff, even though i don't what that some stuff is & would like to know, from what i saw the gains were remarkable. Also cuda only works for nivida gpus...
There does exist a module for nodejs, but it's only for 64bit version of windows, yet there exists cuda for 32bit version as well so only thing missing binding/extension for nodejs to cuda in c++. And There is no sign of documents anywhere on github or internet about that module. Last commits were like 1/2 year+ ago.
If it's all possible than it'd be very great. As nodejs would be able to use gpu for operations, putting it in the whole new level for web stuff, and other applications. Also given parallel nature of nodejs it fits perfectly with gpu's parallel nature.
Suppose there is no module that exists right now. What are my choices.
it's been done already by someone else: http://www.cs.cmu.edu/afs/cs/academic/class/15418-s12/www/competition/r2jitu.com/418/final_report.pdf

Answer 1

here is a binding.gyp file that will build a node extension using two source files
hello.cpp, goodby.cu, and goodby1.cu
{
## for windows, be sure to do node-gyp rebuild -msvs_version=2013,
## and run under a msvs shell
## for all targets
'conditions': [
[ 'OS=="win"', {'variables': {'obj': 'obj'}},
{'variables': {'obj': 'o'}}]],
"targets": [
{
"target_name": "hello",
"sources": [ "hello.cpp", "goodby.cu", "goodby1.cu",],
'rules': [{
'extension': 'cu',
'inputs': ['<(RULE_INPUT_PATH)'],
'outputs':[ '<(INTERMEDIATE_DIR)/<(RULE_INPUT_ROOT).<(obj)'],
'conditions': [
[ 'OS=="win"',
{'rule_name': 'cuda on windows',
'message': "compile cuda file on windows",
'process_outputs_as_sources': 0,
'action': ['nvcc -c <(_inputs) -o <(_outputs)'],
},
{'rule_name': 'cuda on linux',
'message': "compile cuda file on linux",
'process_outputs_as_sources': 1,
'action': ['nvcc','-Xcompiler','-fpic','-c',
'<#(_inputs)','-o','<#(_outputs)'],
}]]}],
'conditions': [
[ 'OS=="mac"', {
'libraries': ['-framework CUDA'],
'include_dirs': ['/usr/local/include'],
'library_dirs': ['/usr/local/lib'],
}],
[ 'OS=="linux"', {
'libraries': ['-lcuda', '-lcudart'],
'include_dirs': ['/usr/local/include'],
'library_dirs': ['/usr/local/lib', '/usr/local/cuda/lib64'],
}],
[ 'OS=="win"', {
'conditions': [
['target_arch=="x64"',
{
'variables': { 'arch': 'x64' }
}, {
'variables': { 'arch': 'Win32' }
}
],
],
'variables': {
'cuda_root%': '$(CUDA_PATH)'
},
'libraries': [
'-l<(cuda_root)/lib/<(arch)/cuda.lib',
'-l<(cuda_root)/lib/<(arch)/cudart.lib',
],
"include_dirs": [
"<(cuda_root)/include",
],
}, {
"include_dirs": [
"/usr/local/cuda/include"
],
}]
]
}
]
}

Answer 2

The proper way to do this is to use the Nvidia CUDA toolkit to write your cuda app in C++ and then invoke it as a separate process from node. This way you can get the most from CUDA and draw on the power of node for controlling that process.
For example, if you have a cuda application and you want to scale it to, say, 32 computers, you would write the application in fast C or C++ and then use node to push it to all the PC's in the cluster and handle communication with each remote process over the network. Node shines in this area. Once each CUDA app instance finishes it's job, you join all the data with node and present it to the user.

Answer 3

The most natural way to hook up CUDA and Node.js would be through an "addon", which allows you to expose c++ code to your javascript programs running on node.
Node itself is a c++ app built on top of the v8 javascript engine, and addons are a way for you to write c++ libraries that can be used by javascript libraries in the same sort of way that node's own libraries do.
From the outside, an addon just looks like a module. The c++ gets compiled into a dynamic library and then exposed to node like any other module.
e.g. my-addon.cc -> (compile) -> my-addon.dylib -> (node-gyp) -> my-addon.node -> var myFoo = require('my-addon').foo()
From inside the addon, you use the v8 and Node APIs to interface with the Javascript environment, and access CUDA with the the normal c++ APIs.
There are a lot of moving parts down at this level. Something as simple as passing a value from one to the other means you need to worry about both c++ memory management and the javascript garbage collector while you wrap/unwrap javascript values to and from appropriate c++ types.
The good news is that most of the issues are fine individually, with great docs and supporting libraries abounding e.g. nan will get a skeleton addon running in no time, and on the CUDA side, you're talking about their normal c++ interface, with truckloads of of docs and tutorials.