{"id":2717,"date":"2016-10-16T16:46:00","date_gmt":"2016-10-16T14:46:00","guid":{"rendered":"https:\/\/blog.risingstack.com\/?p=2717"},"modified":"2024-07-04T10:11:20","modified_gmt":"2024-07-04T08:11:20","slug":"using-buffers-node-js-c-plus-plus","status":"publish","type":"post","link":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/","title":{"rendered":"Using Buffers to share data between Node.js and C++"},"content":{"rendered":"\n<\/p>\n\n\n\n

One of the best things about developing with Node.js<\/a><\/span>Node.js is an asynchronous event-driven JavaScript runtime and is the most effective when building scalable network applications. Node.js is free of locks, so there's no chance to dead-lock any process.<\/span><\/span><\/span> is the ability to move fairly seamlessly between JavaScript and native C++ code – thanks to the V8’s add-on API. The ability to move into C++ is sometimes driven by processing speed, but more often because we already have C++ code and we just want to be able to use it from JavaScript.<\/p>\n\n\n\n

We can categorize the different use cases for add-ons along (at least) two axes – (1) amount of processing time we’ll spend in the C++ code, and (2) the amount of data flowing between C++ and JavaScript.<\/p>\n\n\n\n

\"quadrant\"<\/figure>\n\n\n\n

Most articles discussing C++ add-ons for Node.js are focusing on the differences between the left and right quadrants. If you are in the left quadrants (short processing time), your add-on can possibly be synchronous – meaning the C++ code that executes is running directly in the Node.js event loop when called.<\/p>\n\n\n\n

Node.js allows us to move fairly seamlessly between JavaScript and native C++ code.<\/p><\/blockquote>\n\n\n\n

In this case, the add-on function is blocks and waits for the return value, meaning no other operations can be done in the meantime. In the right quadrants, you would almost certainly design the add-on using the asynchronous pattern. In an asynchronous add-on function, the calling JavaScript code returns immediately. The calling code passes a callback function to the add-on, and the add-on does its work in a separate worker thread. This avoids locking up the Node.js event loop, as the add-on function does not block.<\/p>\n\n\n\n

The difference between the top and bottom quadrants is often overlooked, however they can be just as important.<\/p>\n\n\n\n

V8 vs. C++ memory and data<\/h1>\n\n\n\n

If you are new to writing native add-ons, one of the first things you must master is the differences between V8-owned data (which you can<\/strong> access from C++ add-ons) and normal C++ memory allocations.<\/p>\n\n\n\n

When we say “V8-owned”, we are referring to the storage cells that hold JavaScript data.<\/p>\n\n\n\n

These storage cells are accessible through V8’s C++ API, but they aren’t ordinary C++ variables since they can only be accessed in limited ways. While your add-on could<\/em> restrict itself to ONLY using V8 data, it will more likely create it’s own variables too – in plain old C++. These could be stack or heap variables, and of course are completely independent of V8.<\/p>\n\n\n\n

In JavaScript, primitives (numbers, strings, booleans, etc.) are immutable<\/em>, and a C++ add-on can not alter storage cells associated with primitive JavaScript variables. The primitive JavaScript variables can be reassigned to new storage cells<\/em> created by C++ – but this means that changing data will always result in new<\/em> memory allocation.<\/p>\n\n\n\n

In the upper quadrant (low data transfer), this really isn’t a big deal. If you are designing an add-on that doesn’t have a lot of data exchange, then the overhead of all the new memory allocation probably doesn’t mean much. As your add-ons move closer to the lower quadrant, the cost of allocation \/ copying will start to hurt you.<\/p>\n\n\n\n

For one, it costs you in terms of peak memory usage, and it also costs you in performance<\/strong>!<\/p>\n\n\n\n

The time cost of copying all this data between JavaScript (V8 storage cells) to C++ (and back) usually kills the performance benefits you might be getting from running C++ in the first place!For add-ons in the lower left quadrant (low processing, high data usage), the latency associated with data copying can push your add-on towards the right – forcing you to consider an asynchronous design.<\/p>\n\n\n\n

V8 memory and asynchronous add-ons<\/h1>\n\n\n\n

In asynchronous add-ons we execute the bulk of our C++ processing code in a worker thread. If you are unfamiliar with asynchronous callbacks, you might want to check out a few tutorials (like here<\/a> and here<\/a>).<\/p>\n\n\n\n

A central tenant of asynchronous add-ons is that you can’t access V8 (JavaScript) memory outside the event-loop’s thread<\/em>. This leads us to our next problem. If we have lots of data, that data must be copied out of V8 memory and into your add-on’s native address space from the event loop’s thread<\/em>, before the worker thread starts. Likewise, any data produced or modified by the worker thread must be copied back into V8 by code executing in the event loop (in the callback). If you are interested in creating high throughput Node.js applications, you should avoid spending lots of time in the event loop copying data!<\/p>\n\n\n\n

\"copying\"<\/figure>\n\n\n\n

Ideally, we’d prefer a way to do this:<\/p>\n\n\n\n

\"inplace\"<\/figure>\n\n\n\n

Node.js Buffers to the rescue<\/h1>\n\n\n\n

So, we have two somewhat related problems.<\/p>\n\n\n\n

  1. When working with synchronous add-ons, unless we aren’t changing\/producing data, it’s likely we’ll need to spend a lot of time moving our data between V8 storage cells and plain old C++ variables – which costs us.<\/li>
  2. When working with asynchronous add-ons, we ideally should spend as little time in the event loop as possible. This is why we still have a problem – since we must<\/em> do our data copying in the event loop’s thread due to V8’s multi-threaded restrictions.<\/li><\/ol>\n\n\n\n

    This is where an often overlooked feature of Node.js helps us with add-on development – the Buffer<\/code>. Quoting the Node.js official documentation<\/a>,<\/p>\n\n\n\n

    Instances of the Buffer class are similar to arrays of integers but correspond to fixed-sized, raw memory allocations outside the V8 heap.<\/p><\/blockquote>\n\n\n\n

    This is exactly what we are looking for – because the data inside a Buffer is not stored in a V8 storage cell<\/em>, it is not subjected to the multi-threading rules of V8. This means that we can interact with it in place<\/strong> from a C++ worker thread started by an asynchronous add-on.<\/p>\n\n\n\n

    How Buffers work<\/h2>\n\n\n\n

    Buffers store raw binary data, and they can be found in the Node.js API for reading files and other I\/O devices.<\/p>\n\n\n\n

    Borrowing from some examples in the Node.js documentation, we can create initialized buffers of a specified size, buffers pre-set with a specified value, buffers from arrays of bytes, and buffers from strings.<\/p>\n\n\n\n

    \/\/ buffer with size 10 bytes\nconst<\/strong> buf1 = Buffer.alloc(10);\n\n\/\/ buffer filled with 1's (10 bytes)\nconst<\/strong> buf2 = Buffer.alloc(10, 1);\n\n\/\/buffer containing [0x1, 0x2, 0x3]\nconst<\/strong> buf3 = Buffer.from([1, 2, 3]); \n\n\/\/ buffer containing ASCII bytes [0x74, 0x65, 0x73, 0x74].\nconst<\/strong> buf4 = Buffer.from('test');\n\n\/\/ buffer containing bytes from a file\nconst<\/strong> buf5 = fs.readFileSync(\"some file\");\n<\/code><\/pre>\n\n\n\n
    Buffers can be turned back into traditional JavaScript data (strings) or written back out to files, databases, or other I\/O devices.<\/p>\n\n\n\n
    How to access Buffers in C++<\/h2>\n\n\n\n
    When building an add-on for Node.js, the best place to start is by making use of the NAN (Native Abstractions for Node.js) API rather than directly using the V8 API – which can be a moving target. There are many tutorials on the web for getting started with NAN add-ons – including examples<\/a> in NAN’s code base itself. I’ve written a bit about it here<\/a>, and it’s also covered in a lot of depth in my ebook<\/a>.<\/p>\n\n\n\n
    First, let\u2019s see how an add-on can access a Buffer sent to it from JavaScript. We’ll start with a simple JS program that requires an add-on that we’ll create in a moment:<\/p>\n\n\n\n
    'use strict';\n\/\/ Requiring the add-on that we'll build in a moment...\nconst<\/strong> addon = require<\/strong>('.\/build\/Release\/buffer_example');\n\n\/\/ Allocates memory holding ASCII \"ABC\" outside of V8.\nconst<\/strong> buffer = Buffer.from(\"ABC\");\n\n\/\/ synchronous, rotates each character by +13\naddon.rotate(buffer, buffer.length, 13);\n\nconsole<\/strong>.log(buffer.toString('ascii'));\n<\/code><\/pre>\n\n\n\n
    The expected output is “NOP”, the ASCII rotation by 13 of “ABC”. Let’s take a look the add-on! It consists of three files (in the same directory, for simplicity):<\/p>\n\n\n\n
    \/\/ binding.gyp\n{\n  \"targets\": [\n    {\n        \"target_name\": \"buffer_example\",\n        \"sources\": [ \"buffer_example.cpp\" ], \n        \"include_dirs\" : [\"<!(node -e \\\"require('nan')\\\")\"]\n    }\n  ]\n}\n<\/code><\/pre>\n\n\n\n
    \/\/package.json\n{\n  \"name\": \"buffer_example\",\n  \"version\": \"0.0.1\",\n  \"private\": true,\n  \"gypfile\": true,\n  \"scripts\": {\n    \"start\": \"node index.js\"\n  },\n  \"dependencies\": {\n  \t\"nan\": \"*\"\n  }\n}\n<\/code><\/pre>\n\n\n\n
    \/\/ buffer_example.cpp\n#include<\/strong> <nan.h>\nusing<\/strong> namespace<\/strong> Nan;\nusing<\/strong> namespace<\/strong> v8;\n\nNAN_METHOD(rotate) {\n    char<\/strong>* buffer = (char<\/strong>*) node::Buffer::Data(info[0]->ToObject());\n    unsigned<\/strong> int<\/strong> size = info[1]->Uint32Value();\n    unsigned<\/strong> int<\/strong> rot = info[2]->Uint32Value();\n   \n    for<\/strong>(unsigned<\/strong> int<\/strong> i = 0; i < size; i++ ) {\n        buffer[i] += rot;\n    }   \n}\n\nNAN_MODULE_INIT(Init) {\n   Nan::Set(target, New<String>(\"rotate\").ToLocalChecked(),\n        GetFunction(New<FunctionTemplate>(rotate)).ToLocalChecked());\n}\n\nNODE_MODULE(buffer_example, Init)\n<\/code><\/pre>\n\n\n\n
    The most interesting file is buffer_example.cpp<\/code>. Notice that we’ve used node::Buffer<\/code>‘s Data<\/code> method to convert the first parameter sent to the add-on to a character array. This is now free for us to use in any way we see fit. In this case, we just perform an ASCII rotation of the text. Notice that there is no return value, the memory associated with the Buffer has been modified in place<\/strong>.<\/p>\n\n\n\n
    We can build the add-on by just typing npm install<\/code>. The package.json<\/code> tells npm<\/a><\/span>npm is a software registry that serves over 1.3 million packages. npm is used by open source developers from all around the world to share and borrow code, as well as many businesses. There are three components to npm: the website the Command Line Interface (CLI) the registry Use the website to discover and download packages, create user profiles, and...<\/span><\/span><\/span> to download NAN and build the add-on using the binding.gyp<\/code> file. Running it will give us the “NOP” output we expect.<\/p>\n\n\n\n
    We can also create new<\/em> buffers while inside the add-on. Let’s modify the rotate function to increment the input, but return another buffer containing the string resulting from a decrement operation:<\/p>\n\n\n\n
    NAN_METHOD(rotate) {\n    char<\/strong>* buffer = (char<\/strong>*) node::Buffer::Data(info[0]->ToObject());\n    unsigned<\/strong> int<\/strong> size = info[1]->Uint32Value();\n    unsigned<\/strong> int<\/strong> rot = info[2]->Uint32Value();\n   \n    char<\/strong> * retval = new<\/strong> char<\/strong>[size];\n    for<\/strong>(unsigned<\/strong> int<\/strong> i = 0; i < size; i++ ) {\n        retval[i] = buffer[i] - rot;\n        buffer[i] += rot;\n    }   \n    \n   info.GetReturnValue().Set(Nan::NewBuffer(retval, size).ToLocalChecked());\n}\n<\/code><\/pre>\n\n\n\n
    var<\/strong> result = addon.rotate(buffer, buffer.length, 13);\n\nconsole<\/strong>.log(buffer.toString('ascii'));\nconsole<\/strong>.log(result.toString('ascii'));\n<\/code><\/pre>\n\n\n\n
    Now the resulting buffer will contain ‘456’. Note the use of NAN’s NewBuffer<\/code> function, which wraps the dynamically allocated retval<\/code> array in a Node buffer. Doing so transfers ownership<\/em> of this memory to Node.js, so the memory associated with retval<\/code> will be reclaimed (by calling free<\/code>) when the buffer goes out of scope in JavaScript. More on this issue later – as we don’t always want to have it happen this way!<\/p>\n\n\n\n
    You can find additional information about how NAN handles buffers here<\/a>.<\/p>\n\n\n\n
    Example: PNG and BMP Image Processing<\/h1>\n\n\n\n
    The example above is pretty basic and not particularly exciting. Let’s turn to a more practical example – image processing with C++. If you want to get the full source code for both the example above and the image processing code below, you can head over to my nodecpp-demo<\/code> repository at https:\/\/github.com\/freezer333\/nodecpp-demo<\/a>, the code is in the “buffers” directory.<\/p>\n\n\n\n
    Image processing is a good candidate for C++ add-ons, as it can often be time-consuming, CPU intensive, and some processing techniques have parallelism that C++ can exploit well. In the example we’ll look at now, we’ll simply convert png formatted data into bmp formatted data .<\/p>\n\n\n\n
    Converting a png to bmp is not<\/em> particularly time consuming and it’s probably overkill for an add-on, but it’s good for demonstration purposes. If you are looking for a pure JavaScript implementation of image processing (including much more than png to bmp conversion), take a look at JIMP at https:\/\/www.npmjs.com\/package\/jimp<\/a>https:\/\/www.npmjs.com\/package\/jimp<\/a>.<\/p><\/blockquote>\n\n\n\n
    There are a good number of open source C++ libraries that can help us with this task. I’m going to use LodePNG as it is dependency free and quite simple to use. LodePNG can be found at http:\/\/lodev.org\/lodepng\/<\/a>, and it’s source code is at https:\/\/github.com\/lvandeve\/lodepng<\/a>. Many thanks to the developer, Lode Vandevenne for providing such an easy to use library!<\/p>\n\n\n\n
    Setting up the add-on<\/h2>\n\n\n\n
    For this add-on, we’ll create the following directory structure, which includes source code downloaded from https:\/\/github.com\/lvandeve\/lodepng<\/a>, namely lodepng.h<\/code> and lodepng.cpp<\/code>.<\/p>\n\n\n\n
    \/png2bmp\n | \n |--- binding.gyp\n |--- package.json\n |--- png2bmp.cpp  # the add-on\n |--- index.js     # program to test the add-on\n |--- sample.png   # input (will be converted to bmp)\n |--- lodepng.h    # from lodepng distribution\n |--- lodepng.cpp  # From loadpng distribution\n<\/code><\/pre>\n\n\n\n
    lodepng.cpp<\/code> contains all the necessary code for doing image processing, and I will not discuss it’s working in detail. In addition, the lodepng distribution contains sample code that allows you to specifically convert between png and bmp. I’ve adapted it slightly and will put it in the add-ons source code file png2bmp.cpp<\/code> which we will take a look at shortly.<\/p>\n\n\n\n
    Let’s look at what the actual JavaScript program looks like before diving into the add-on code itself:<\/p>\n\n\n\n
    'use strict';\nconst<\/strong> fs = require<\/strong>('fs');\nconst<\/strong> path = require<\/strong>('path');\nconst<\/strong> png2bmp = require<\/strong>('.\/build\/Release\/png2bmp');\n\nconst<\/strong> png_file = process.argv[2];\nconst<\/strong> bmp_file = path.basename(png_file, '.png') + \".bmp\";\nconst<\/strong> png_buffer = fs.readFileSync(png_file);\n\nconst<\/strong> bmp_buffer = png2bmp.getBMP(png_buffer, png_buffer.length);\nfs.writeFileSync(bmp_file, bmp_buffer);\n<\/code><\/pre>\n\n\n\n
    The program uses a filename for a png image as a command line option. It calls an add-on function getBMP<\/code> which accepts a buffer containing the png file and its length. This add-on is synchronous<\/em>, but we’ll take a look at the asynchronous version later on too.<\/p>\n\n\n\n
    Here’s the package.json<\/code>, which is setting up npm start<\/code> to invoke the index.js<\/code> program with a command line argument of sample.png<\/code>. It’s a pretty generic image:<\/p>\n\n\n\n
    {\n  \"name\": \"png2bmp\",\n  \"version\": \"0.0.1\",\n  \"private\": true,\n  \"gypfile\": true,\n  \"scripts\": {\n    \"start\": \"node index.js sample.png\"\n  },\n  \"dependencies\": {\n  \t\"nan\": \"*\"\n  }\n}\n<\/code><\/pre>\n\n\n\n
    \"sample\"<\/figure>\n\n\n\n
    Here is the binding.gyp<\/code> file – which is fairly standard, other than a few compiler flags needed to compile lodepng. It also includes the requisite references to NAN.<\/p>\n\n\n\n
    {\n  \"targets\": [\n    {\n      \"target_name\": \"png2bmp\",\n      \"sources\": [ \"png2bmp.cpp\", \"lodepng.cpp\" ], \n      \"cflags\": [\"-Wall\", \"-Wextra\", \"-pedantic\", \"-ansi\", \"-O3\"],\n      \"include_dirs\" : [\"<!(node -e \\\"require('nan')\\\")\"]\n    }\n  ]\n}\n<\/code><\/pre>\n\n\n\n
    png2bmp.cpp<\/code> will mostly contain V8\/NAN code. However, it does have one image processing utility function – do_convert<\/code>, adopted from lodepng’s png to bmp example code.<\/p>\n\n\n\n
    The function accepts a vector<unsigned char><\/code> containing input data (png format) and a vector<unsigned char><\/code> to put its output (bmp format) data into. That function, in turn, calls encodeBMP<\/code>, which is straight from the lodepng examples.<\/p>\n\n\n\n
    Here is the full code listing of these two functions. The details are not important to the understanding of the add-ons Buffer<\/code> objects but are included here for completeness. Our add-on entry point(s) will call do_convert<\/code>.<\/p>\n\n\n\n
    ~~~~~~~~~~{#binding-hello .cpp}\n\/*\nALL LodePNG code in this file is adapted from lodepng's \nexamples, found at the following URL:\nhttps:\/\/github.com\/lvandeve\/lodepng\/blob\/<\/a>\nmaster\/examples\/example_bmp2png.cpp'\n*\/\n\nvoid<\/strong> encodeBMP<\/strong>(std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>>& bmp, \n  const<\/strong> unsigned<\/strong> char<\/strong>* image, int<\/strong> w, int<\/strong> h)\n{\n  \/\/3 bytes per pixel used for both input and output.\n  int<\/strong> inputChannels = 3;\n  int<\/strong> outputChannels = 3;\n  \n  \/\/bytes 0-13\n  bmp.push_back('B'); bmp.push_back('M'); \/\/0: bfType\n  bmp.push_back(0); bmp.push_back(0); \n  bmp.push_back(0); bmp.push_back(0); \n  bmp.push_back(0); bmp.push_back(0); \/\/6: bfReserved1\n  bmp.push_back(0); bmp.push_back(0); \/\/8: bfReserved2\n  bmp.push_back(54 % 256); \n  bmp.push_back(54 \/ 256); \n  bmp.push_back(0); bmp.push_back(0); \n\n  \/\/bytes 14-53\n  bmp.push_back(40); bmp.push_back(0); \n  bmp.push_back(0); bmp.push_back(0);  \/\/14: biSize\n  bmp.push_back(w % 256); \n  bmp.push_back(w \/ 256); \n  bmp.push_back(0); bmp.push_back(0); \/\/18: biWidth\n  bmp.push_back(h % 256); \n  bmp.push_back(h \/ 256); \n  bmp.push_back(0); bmp.push_back(0); \/\/22: biHeight\n  bmp.push_back(1); bmp.push_back(0); \/\/26: biPlanes\n  bmp.push_back(outputChannels * 8); \n  bmp.push_back(0); \/\/28: biBitCount\n  bmp.push_back(0); bmp.push_back(0); \n  bmp.push_back(0); bmp.push_back(0);  \/\/30: biCompression\n  bmp.push_back(0); bmp.push_back(0); \n  bmp.push_back(0); bmp.push_back(0);  \/\/34: biSizeImage\n  bmp.push_back(0); bmp.push_back(0); \n  bmp.push_back(0); bmp.push_back(0);  \/\/38: biXPelsPerMeter\n  bmp.push_back(0); bmp.push_back(0); \n  bmp.push_back(0); bmp.push_back(0);  \/\/42: biYPelsPerMeter\n  bmp.push_back(0); bmp.push_back(0); \n  bmp.push_back(0); bmp.push_back(0);  \/\/46: biClrUsed\n  bmp.push_back(0); bmp.push_back(0); \n  bmp.push_back(0); bmp.push_back(0);  \/\/50: biClrImportant\n \n  int<\/strong> imagerowbytes = outputChannels * w;\n  \/\/must be multiple of 4\n  imagerowbytes = imagerowbytes % 4 == 0 ? imagerowbytes : \n            imagerowbytes + (4 - imagerowbytes % 4); \n  \n  for<\/strong>(int<\/strong> y = h - 1; y >= 0; y--) \n  {\n    int<\/strong> c = 0;\n    for<\/strong>(int<\/strong> x = 0; x < imagerowbytes; x++)\n    {\n      if<\/strong>(x < w * outputChannels)\n      {\n        int<\/strong> inc = c;\n        \/\/Convert RGB(A) into BGR(A)\n        if<\/strong>(c == 0) inc = 2;\n        else<\/strong> if<\/strong>(c == 2) inc = 0;\n        bmp.push_back(image[inputChannels \n            * (w * y + x \/ outputChannels) + inc]);\n      }\n      else<\/strong> bmp.push_back(0);\n      c++;\n      if<\/strong>(c >= outputChannels) c = 0;\n    }\n  }\n\n  \/\/ Fill in the size\n  bmp[2] = bmp.size() % 256;\n  bmp[3] = (bmp.size() \/ 256) % 256;\n  bmp[4] = (bmp.size() \/ 65536) % 256;\n  bmp[5] = bmp.size() \/ 16777216;\n}\n\nbool<\/strong> do_convert<\/strong>(\n  std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>> & input_data, \n  std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>> & bmp)\n{\n  std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>> image; \/\/the raw pixels\n  unsigned<\/strong> width, height;\n  unsigned<\/strong> error = lodepng::decode(image, width, \n    height, input_data, LCT_RGB, 8);\n  if<\/strong>(error) {\n    std<\/strong>::cout<\/strong> << \"error \" << error << \": \" \n              << lodepng_error_text(error) \n              << std<\/strong>::endl;\n    return<\/strong> false;\n  }\n  encodeBMP(bmp, &image[0], width, height);\n  return<\/strong> true;\n}\n~~~~~~~~~~\n<\/code><\/pre>\n\n\n\n
    Sorry… that listing was long, but it’s important to see what’s actually going on! Let’s get to work bridging all this code to JavaScript.<\/p>\n\n\n\n
    Synchronous Buffer Processing<\/h2>\n\n\n\n
    The png image data is actually read when we are in JavaScript, so it’s passed in as a Node.js Buffer<\/code>. We’ll use NAN to access the buffer itself. Here’s the complete code for the synchronous version:<\/p>\n\n\n\n
    NAN_METHOD(GetBMP) {\nunsigned<\/strong> char<\/strong>*buffer = (unsigned<\/strong> char<\/strong>*) node::Buffer::Data(info[0]->ToObject());\n    unsigned<\/strong> int<\/strong> size = info[1]->Uint32Value();\n   \n    std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>> png_data(buffer, buffer + size);\n    std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>> bmp;\n     \n    if<\/strong> ( do_convert(png_data, bmp)) {\n        info.GetReturnValue().Set(\n            NewBuffer((char<\/strong> *)bmp.data(), bmp.size()\/*, buffer_delete_callback, bmp*\/).ToLocalChecked());\n    }\n}  \n\nNAN_MODULE_INIT(Init) {\n   Nan::Set(target, New<String>(\"getBMP\").ToLocalChecked(),\n        GetFunction(New<FunctionTemplate>(GetBMP)).ToLocalChecked());\n}\n\nNODE_MODULE(png2bmp, Init)\n<\/code><\/pre>\n\n\n\n
    In GetBMP<\/code>, we use the familiar Data<\/code> method to unwrap the buffer so we can work with it like a normal character array. Next, we build a vector<\/code> around the input so we can pass it to our do_convert<\/code> function listed above. Once the bmp<\/code> vector is filled in by do_convert<\/code>, we wrap it up in a Buffer<\/code> and return to JavaScript.<\/p>\n\n\n\n
    So here is the problem<\/em> with this code: The data contained in the buffer we return is likely deleted before our JavaScript gets to use it. Why? Because the bmp<\/code> vector is going to go out of scope as our GetBMP<\/code> function returns. C++ vector semantics hold that when the vector goes out of scope, the vector’s destructor deletes all data within the vector – in our case, our bmp data will be deleted as well! This is a huge problem since the Buffer<\/code> we send back to JavaScript will have it’s data deleted out from under it. You might get away with this (race conditions are fun right?), but it will eventually cause your program to crash.<\/p>\n\n\n\n
    Luckily, NewBuffer<\/code> has an optional third and fourth parameter to give us some more control.<\/p>\n\n\n\n
    The third parameter is a callback which ends up being called when the Buffer<\/code> gets garbage collected by V8. Remember that Buffer<\/code>s are JavaScript objects, whose data is stored outside of V8, but the object itself is under V8’s control.<\/p>\n\n\n\n
    From this perspective, it should make sense that a callback would be handy. When V8 destroys the buffer, we need some way of freeing up the data we have created – which is passed into the callback as its first parameter. The signature of the callback is defined by NAN – Nan::FreeCallback()<\/code>. The fourth parameter is a hint to aid in deallocation, and we can use it however we want.<\/p>\n\n\n\n
    Since our problem is that the vector containing bitmap data goes out of scope, we can dynamically<\/em> allocate the vector itself instead, and pass it into the free callback where it can be properly deleted when the Buffer<\/code> has been garbage collected.<\/p>\n\n\n\n
    Below is the new delete_callback<\/code>, along with the new call to NewBuffer<\/code>. I’m sending the actual pointer to the vector as the hint, so it can be deleted directly.<\/p>\n\n\n\n
    void<\/strong> buffer_delete_callback<\/strong>(char<\/strong>* data, void<\/strong>* the_vector) {\n  delete<\/strong> reinterpret_cast<\/strong><vector<\/strong><unsigned<\/strong> char<\/strong>> *> (the_vector);\n}\n\nNAN_METHOD(GetBMP) {\n    \n  unsigned<\/strong> char<\/strong>*buffer =  (unsigned<\/strong> char<\/strong>*) node::Buffer::Data(info[0]->ToObject());\n  unsigned<\/strong> int<\/strong> size = info[1]->Uint32Value();\n   \n  std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>> png_data(buffer, buffer + size); \n  std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>> * bmp = new<\/strong> vector<\/strong><unsigned<\/strong> char<\/strong>>();\n     \n  if<\/strong> ( do_convert(png_data, *bmp)) {\n      info.GetReturnValue().Set(\n          NewBuffer(\n            (char<\/strong> *)bmp->data(), \n            bmp->size(), \n            buffer_delete_callback, \n            bmp)\n            .ToLocalChecked());\n  }\n}\n<\/code><\/pre>\n\n\n\n
    Run this program by doing an npm install<\/code> and then an npm start<\/code> and you’ll see a sample.bmp<\/code> generated in your directory that looks eerily similar to sample.png<\/code> – just a whole lot bigger (because bmp compression is far less efficient than png).<\/p>\n\n\n\n
    Asynchronous Buffer Processing<\/h2>\n\n\n\n
    Let’s develop an asynchronous version of the png to bitmap converter. We’ll perform the actual conversion in a C++ worker thread, using Nan::AsyncWorker<\/code>. By using Buffer<\/code> objects, we can avoid copying the png data, so we will only need to hold a pointer to the underlying data such that our worker thread can access it. Likewise, the data produced by the worker thread (the bmp<\/code> vector) can be used to create a new Buffer<\/code> without copying data.<\/p>\n\n\n\n
     class<\/strong> PngToBmpWorker : public<\/strong> AsyncWorker {\n    public<\/strong>:\n    PngToBmpWorker(Callback * callback, \n        v8::Local<v8::Object> &pngBuffer, int<\/strong> size) \n        : AsyncWorker(callback) {\n        unsigned<\/strong> char<\/strong>*buffer = \n          (unsigned<\/strong> char<\/strong>*) node::Buffer::Data(pngBuffer);\n\n        std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>> tmp(\n          buffer, \n          buffer +  (unsigned<\/strong> int<\/strong>) size);\n\n        png_data = tmp;\n    }\n    void<\/strong> Execute<\/strong>() {\n       bmp = new<\/strong> vector<\/strong><unsigned<\/strong> char<\/strong>>();\n       do_convert(png_data, *bmp);\n    }\n    void<\/strong> HandleOKCallback<\/strong> () {\n        Local<Object> bmpData = \n               NewBuffer((char<\/strong> *)bmp->data(), \n               bmp->size(), buffer_delete_callback, \n               bmp).ToLocalChecked();\n        Local<Value> argv[] = { bmpData };\n        callback->Call(1, argv);\n    }\n\n    private<\/strong>:\n        vector<\/strong><unsigned<\/strong> char<\/strong>> png_data;\n        std<\/strong>::vector<\/strong><unsigned<\/strong> char<\/strong>> * bmp;\n};\n\nNAN_METHOD(GetBMPAsync) {\n    int<\/strong> size = To<int<\/strong>>(info[1]).FromJust();\n    v8::Local<v8::Object> pngBuffer = \n      info[0]->ToObject();\n\n    Callback *callback = \n      new<\/strong> Callback(info[2].As<Function>());\n\n    AsyncQueueWorker(\n      new<\/strong> PngToBmpWorker(callback, pngBuffer , size));\n}\n<\/code><\/pre>\n\n\n\n
    Our new GetBMPAsync<\/code> add-on function first unwraps the input buffer sent from JavaScript and then initializes and queues a new PngToBmpWorker<\/code> worker , using NAN’s API. The worker object’s Execute<\/code> method is called by libuv<\/code> inside a worker thread where the conversion is done. When the Execute<\/code> function returns, libuv<\/code> calls the HandleOKCallback<\/code> in the Node.js event loop thread, which creates the buffer and invokes the callback sent from JavaScript.<\/p>\n\n\n\n
    Now we can utilize this add-on function in JavaScript like this:<\/p>\n\n\n\n
    png2bmp.getBMPAsync(png_buffer, \n  png_buffer.length,\n  function<\/strong>(bmp_buffer) {\n    fs.writeFileSync(bmp_file, bmp_buffer);\n}); \n<\/code><\/pre>\n\n\n\n
    Summary<\/h1>\n\n\n\n
    There were two core takeaways in this post:<\/p>\n\n\n\n
    1. You can’t ignore the costs of copying data between V8 storage cells and C++ variables. If you aren’t careful, you can easily kill the performance boost you might have thought you were getting by dropping into C++ to perform your work!<\/li>
    2. Buffers offer a way to work with the same data in both JavaScript and C++, thus avoiding the need to create copies.<\/li><\/ol>\n\n\n\n
      Using buffers in your add-ons can be pretty painless. I hope I’ve been able to show you this through a simple demo application that rotates ASCII text, along with more practical synchronous and asynchronous image conversion examples Hopefully, this post helps you boost the performance of your own add-ons!<\/p>\n\n\n\n
      A reminder, all the code from this post can be found at https:\/\/github.com\/freezer333\/nodecpp-demo<\/a>, the code is in the “buffers” directory.<\/p>\n\n\n\n
      If you are looking for more tips on how to design Node.js C++ add-ons, please check out my ebook on C++ and Node.js Integration<\/a>.<\/p>\n\n\n\n
      This article is written by Scott Frees. The author’s bio:
      <\/strong>“I’m a freelance software developer and consultant – specialized in custom application development, workflow automation and software integration. More info: https:\/\/scottfrees.com\/”<\/em><\/p><\/blockquote>\n\n\n\n
      \n","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[20],"tags":[],"class_list":["post-2717","post","type-post","status-publish","format-standard","hentry","category-devops"],"yoast_head":"\nUsing Buffers to share data between Node.js and C++ - RisingStack Engineering<\/title>\n<meta name=\"description\" content=\"Learn how you can share data between Node.js and C++ using Buffers - in order to work with the same data in both languages, in a performant way.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Using Buffers to share data between Node.js and C++ - RisingStack Engineering\" \/>\n<meta property=\"og:description\" content=\"Learn how you can share data between Node.js and C++ using Buffers - in order to work with the same data in both languages, in a performant way.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/\" \/>\n<meta property=\"og:site_name\" content=\"RisingStack Engineering\" \/>\n<meta property=\"article:published_time\" content=\"2016-10-16T14:46:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-04T08:11:20+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/blog.risingstack.com\/wp-content\/uploads\/2022\/03\/quadrant.png\" \/>\n<meta name=\"author\" content=\"RisingStack Engineering\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"RisingStack Engineering\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"17 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/\"},\"author\":{\"name\":\"RisingStack Engineering\",\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/#\\\/schema\\\/person\\\/7cd795f2e5173258661ba604144b0b22\"},\"headline\":\"Using Buffers to share data between Node.js and C++\",\"datePublished\":\"2016-10-16T14:46:00+00:00\",\"dateModified\":\"2024-07-04T08:11:20+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/\"},\"wordCount\":2875,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/blog.risingstack.com\\\/wp-content\\\/uploads\\\/2022\\\/03\\\/quadrant.png\",\"articleSection\":[\"DevOps\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/\",\"url\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/\",\"name\":\"Using Buffers to share data between Node.js and C++ - RisingStack Engineering\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/blog.risingstack.com\\\/wp-content\\\/uploads\\\/2022\\\/03\\\/quadrant.png\",\"datePublished\":\"2016-10-16T14:46:00+00:00\",\"dateModified\":\"2024-07-04T08:11:20+00:00\",\"description\":\"Learn how you can share data between Node.js and C++ using Buffers - in order to work with the same data in both languages, in a performant way.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/#primaryimage\",\"url\":\"https:\\\/\\\/blog.risingstack.com\\\/wp-content\\\/uploads\\\/2022\\\/03\\\/quadrant.png\",\"contentUrl\":\"https:\\\/\\\/blog.risingstack.com\\\/wp-content\\\/uploads\\\/2022\\\/03\\\/quadrant.png\",\"width\":465,\"height\":367},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/using-buffers-node-js-c-plus-plus\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/blog.risingstack.com\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Using Buffers to share data between Node.js and C++\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/#website\",\"url\":\"https:\\\/\\\/blog.risingstack.com\\\/\",\"name\":\"RisingStack Engineering\",\"description\":\"Node.js Tutorials & Resources\",\"publisher\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/blog.risingstack.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/#organization\",\"name\":\"RisingStack Engineering\",\"url\":\"https:\\\/\\\/blog.risingstack.com\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/blog.risingstack.com\\\/wp-content\\\/uploads\\\/2021\\\/05\\\/logo-white-f0fca36fce94ceacd3d608caa6649361-1.svg\",\"contentUrl\":\"https:\\\/\\\/blog.risingstack.com\\\/wp-content\\\/uploads\\\/2021\\\/05\\\/logo-white-f0fca36fce94ceacd3d608caa6649361-1.svg\",\"width\":180,\"height\":45,\"caption\":\"RisingStack Engineering\"},\"image\":{\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/blog.risingstack.com\\\/#\\\/schema\\\/person\\\/7cd795f2e5173258661ba604144b0b22\",\"name\":\"RisingStack Engineering\",\"url\":\"https:\\\/\\\/blog.risingstack.com\\\/author\\\/coolsp\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Using Buffers to share data between Node.js and C++ - RisingStack Engineering","description":"Learn how you can share data between Node.js and C++ using Buffers - in order to work with the same data in both languages, in a performant way.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/","og_locale":"en_US","og_type":"article","og_title":"Using Buffers to share data between Node.js and C++ - RisingStack Engineering","og_description":"Learn how you can share data between Node.js and C++ using Buffers - in order to work with the same data in both languages, in a performant way.","og_url":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/","og_site_name":"RisingStack Engineering","article_published_time":"2016-10-16T14:46:00+00:00","article_modified_time":"2024-07-04T08:11:20+00:00","og_image":[{"url":"https:\/\/blog.risingstack.com\/wp-content\/uploads\/2022\/03\/quadrant.png","type":"","width":"","height":""}],"author":"RisingStack Engineering","twitter_card":"summary_large_image","twitter_misc":{"Written by":"RisingStack Engineering","Est. reading time":"17 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/#article","isPartOf":{"@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/"},"author":{"name":"RisingStack Engineering","@id":"https:\/\/blog.risingstack.com\/#\/schema\/person\/7cd795f2e5173258661ba604144b0b22"},"headline":"Using Buffers to share data between Node.js and C++","datePublished":"2016-10-16T14:46:00+00:00","dateModified":"2024-07-04T08:11:20+00:00","mainEntityOfPage":{"@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/"},"wordCount":2875,"commentCount":0,"publisher":{"@id":"https:\/\/blog.risingstack.com\/#organization"},"image":{"@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/#primaryimage"},"thumbnailUrl":"https:\/\/blog.risingstack.com\/wp-content\/uploads\/2022\/03\/quadrant.png","articleSection":["DevOps"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/","url":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/","name":"Using Buffers to share data between Node.js and C++ - RisingStack Engineering","isPartOf":{"@id":"https:\/\/blog.risingstack.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/#primaryimage"},"image":{"@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/#primaryimage"},"thumbnailUrl":"https:\/\/blog.risingstack.com\/wp-content\/uploads\/2022\/03\/quadrant.png","datePublished":"2016-10-16T14:46:00+00:00","dateModified":"2024-07-04T08:11:20+00:00","description":"Learn how you can share data between Node.js and C++ using Buffers - in order to work with the same data in both languages, in a performant way.","breadcrumb":{"@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/#primaryimage","url":"https:\/\/blog.risingstack.com\/wp-content\/uploads\/2022\/03\/quadrant.png","contentUrl":"https:\/\/blog.risingstack.com\/wp-content\/uploads\/2022\/03\/quadrant.png","width":465,"height":367},{"@type":"BreadcrumbList","@id":"https:\/\/blog.risingstack.com\/using-buffers-node-js-c-plus-plus\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/blog.risingstack.com\/"},{"@type":"ListItem","position":2,"name":"Using Buffers to share data between Node.js and C++"}]},{"@type":"WebSite","@id":"https:\/\/blog.risingstack.com\/#website","url":"https:\/\/blog.risingstack.com\/","name":"RisingStack Engineering","description":"Node.js Tutorials & Resources","publisher":{"@id":"https:\/\/blog.risingstack.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/blog.risingstack.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/blog.risingstack.com\/#organization","name":"RisingStack Engineering","url":"https:\/\/blog.risingstack.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/blog.risingstack.com\/#\/schema\/logo\/image\/","url":"https:\/\/blog.risingstack.com\/wp-content\/uploads\/2021\/05\/logo-white-f0fca36fce94ceacd3d608caa6649361-1.svg","contentUrl":"https:\/\/blog.risingstack.com\/wp-content\/uploads\/2021\/05\/logo-white-f0fca36fce94ceacd3d608caa6649361-1.svg","width":180,"height":45,"caption":"RisingStack Engineering"},"image":{"@id":"https:\/\/blog.risingstack.com\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/blog.risingstack.com\/#\/schema\/person\/7cd795f2e5173258661ba604144b0b22","name":"RisingStack Engineering","url":"https:\/\/blog.risingstack.com\/author\/coolsp\/"}]}},"_links":{"self":[{"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/posts\/2717","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/comments?post=2717"}],"version-history":[{"count":1,"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/posts\/2717\/revisions"}],"predecessor-version":[{"id":4225,"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/posts\/2717\/revisions\/4225"}],"wp:attachment":[{"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/media?parent=2717"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/categories?post=2717"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.risingstack.com\/wp-json\/wp\/v2\/tags?post=2717"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}