Tided up and tested the code.

Author: ashleydavis

README.md

@@ -1,2 +1,31 @@
 # nodejs-memory-test
-Code to test how much memory is available with Node.js
+
+A test program to estimate how much heap memory is available to a Node.js application.
+
+This example code accompanies the book [Data Wrangling with JavaScript](http://bit.ly/2t2cJu2).
+
+If you're a JavaScript developer, you already know that working with data is a big deal. Why let the Python and R coders get all the glory? JavaScript isn't just good at data visualization, you can move your entire data wrangling pipeline to JavaScript and work more effectively. [Data Wrangling with JavaScript](http://bit.ly/2t2cJu2) teaches you core data munging techniques in JavaScript, along with many libraries and tools that will make your data tasks even easier.
+
+## Setup
+
+Clone the repo to your local hard drive and change directory to the repo.
+
+No dependencies are required.
+
+## Run
+
+To determine the largest amount of memory that can be allocated in Node.js run:
+
+    node index.js
+
+Let this run for a while and it will eventually abort with a fatal out of memory error like this:
+
+    FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory
+
+The last line of text printed tells you the total amount of heap memory available to your application under Node.js.
+
+Now try increasing heap memory, add the '--max-old-space-size' command line parameter as follows and run it again:
+
+    node --max-old-space-size=6000 index.js
+
+You should now have much more heap memory to play with!

index.js

@@ -0,0 +1,60 @@
+//
+// Small program to test the maximum amount of allocations in multiple blocks.
+// This script searches for the largest allocation amount.
+//
+
+//
+// Allocate a certain size to test if it can be done.
+//
+function alloc (size) {
+    const numbers = size / 8;
+    const arr = []
+    arr.length = numbers; // Simulate allocation of 'size' bytes.
+    for (let i = 0; i < numbers; i++) {
+        arr[i] = i;
+    }
+    return arr;
+};
+
+//
+// Keep allocations referenced so they aren't garbage collected.
+//
+const allocations = []; 
+
+//
+// Allocate successively larger sizes, doubling each time until we hit the limit.
+//
+function allocToMax () {
+
+    console.log("Start");
+
+    const field = 'heapUsed';
+    const mu = process.memoryUsage();
+    console.log(mu);
+    const gbStart = mu[field] / 1024 / 1024 / 1024;
+    console.log(`Start ${Math.round(gbStart * 100) / 100} GB`);
+
+    let allocationStep = 100 * 1024;
+
+    while (true) {
+        // Allocate memory.
+        const allocation = alloc(allocationStep);
+
+        // Allocate and keep a reference so the allocated memory isn't garbage collected.
+        allocations.push(allocation);
+
+        // Check how much memory is now allocated.
+        const mu = process.memoryUsage();
+        const mbNow = mu[field] / 1024 / 1024 / 1024;
+        //console.log(`Total allocated       ${Math.round(mbNow * 100) / 100} GB`);
+        console.log(`Allocated since start ${Math.round((mbNow - gbStart) * 100) / 100} GB`);
+
+        // Infinite loop, never get here.
+    }
+
+    // Infinite loop, never get here.
+};
+
+allocToMax();
+
+// Infinite loop, never get here.