C++

node.js Native Extensions

or, what to do when JS is not good enough

Ivan Vergiliev

@IvanVergiliev
Currently helping Chaos Group build a cloud rendering platform
Competitive programming enthusiast
- So, we'll talk about performance
- ...just to keep the stereotype alive
Slides for this talk at IvanVergiliev.github.io/node-cpp

So, you need more speed?

V8 is really fast
- Probably the fastest JavaScript engine nowadays

but it can also be kinda slow
- The fastest JavaScript engine
- Abstractions, GC, dynamic typing, etc. all come at a price
We'll assume that, for some reason, our users need a way to sort a large amount of numbers

How should we do that?

var a = []; for (var i = 0; i < 1000000; ++i) { a[i] = Math.random() } console.time('sort'); a.sort(); console.timeEnd('sort');
In-browser - about 12 seconds
node.js - make it 10s
C++ - 0.8 seconds
- before optimizations

Call C++ from Javascript!

A typical CommonJS module

var sort = function (arr) {
  return arr.sort(); // yeah, cuz that makes sense...
}

exports.sort = sort;

A basic C++ extension module

#include <node.h>
#include <v8.h>

using namespace v8;

Handle<Value> Sort(const Arguments& args) {
  HandleScope scope;
  return Undefined();
}

void Init(Handle<Object> exports) {
  exports->Set(String::NewSymbol("sort"),
      FunctionTemplate::New(Sort)->GetFunction());
}

NODE_MODULE(algortihm, Init)

Build with node-gyp

npm install -g node-gyp
binding.gyp: { 'targets': [{ 'target_name': 'algorithm', # must be the same as the one in INIT_MODULE 'sources': [ 'module.cc' ] }] }
node-gyp configure build
results are by default in build/Release/algorithm.node

The sort function

Handle<Value> Sort(const Arguments& args) {
  HandleScope scope;
  if (args.Length() < 1 || !args[0]->IsArray()) {
    ThrowException(Exception::TypeError(String::New("First argument should be an array")));
    return Undefined();
  }
  Handle<Array> arr = Handle<Array>::Cast(args[0]);
  vector<double> v;
  for (int i = 0; i < arr->Length(); ++i) {
    v.push_back(arr->Get(i)->NumberValue());
  }
  sort(v.begin(), v.end());
  Handle<Array> res = Array::New(v.size());
  for (int i = 0; i < v.size(); ++i) {
    res->Set(i, Number::New(v[i]));
  }
  return scope.Close(res);
}

runs in less than a second - that's much better

Are we done?

Would you run this in production?

I hope not.

All JavaScript runs in a single thread, using an event loop managed by libuv
Our Sort function is not very asynchronous.

Going async

Enter uv_queue_work

int uv_queue_work(
    uv_loop_t* loop,
    uv_work_t* req,
    uv_work_cb work_cb,
    uv_after_work_cb after_work_cb);

Async Sort

struct AsyncSortData {
  vector<double> v;
  Persistent<Function> callback;

  ~AsyncSortData() {
    callback.Dispose();
  }
};

Handle<Value> AsyncSort(const Arguments& args) {
  ...
  uv_work_t* req = new uv_work_t;
  AsyncSortData* data = new AsyncSortData;
  req->data = data;
  for (int i = 0; i < arr->Length(); ++i) {
    data->v.push_back(arr->Get(i)->NumberValue());
  }
  data->callback = Persistent<Function>::New(Local<Function>::Cast(args[1]));
  uv_queue_work(uv_default_loop(), req, sort, afterSort);
  return Undefined();
}

Async Sort

void sort(uv_work_t* req) {
  auto data = reinterpret_cast<AsyncSortData*>(req->data);
  sort(data->v.begin(), data->v.end());
};

void afterSort(uv_work_t* req) {
  HandleScope scope;
  auto data = reinterpret_cast<AsyncSortData*>(req->data);
  Handle<Array> res = Array::New(data->v.size());
  for (int i = 0; i < data->v.size(); ++i) {
    res->Set(i, Number::New(data->v[i]));
  }
  data->callback->Call(res, 1, (Handle<Value>[]){res});
  delete data;
  delete req;
}

node.js Native Extensions

or, what to do when JS is not good enough

Ivan Vergiliev

@IvanVergiliev

Currently helping Chaos Group build a cloud rendering platform

Competitive programming enthusiast

Slides for this talk at IvanVergiliev.github.io/node-cpp

So, you need more speed?

V8 is really fast

but it can also be kinda slow

We'll assume that, for some reason, our users need a way to sort a large amount of numbers

How should we do that?

Call C++ from Javascript!

A typical CommonJS module

A basic C++ extension module

Build with node-gyp

The sort function

Are we done?

Going async

Async Sort

Async Sort

Reasons to avoid native extensions?

When to avoid going the C++ way

References