Energy Consumption Measurement of Algorithms with Rhino

[StSchnell]

This post describes the use of jPowerMonitor for measuring energy consumption of JavaScript algorithms with Rhino. jPowerMonitor is a JUnit extension and Java agent for energy consumption measurement from msg systems from Hans-Peter Keilhofer aka @keilhofh and Jakob Deiner aka @deinerj. The use of jPowerMonitor is very well described. Here we focus on usage in the context of Rhino.

What is Green IT and Green Coding?

Green IT is a generic term and describes the practice of environmentally friendly procurement, use and disposal of computer resources. Green coding is a subset of this and is about sustainable programming. Among other things the target here is to achieve the lowest possible energy consumption. This is another non-functional programming requirement. Because each line of code has the potential to reduce energy and resource consumption. This reduces emissions and saves raw materials.

jPowerMonitor with Rhino

Rhino is part of many products in business. For precisely this reason it can be valuable to look at this. To detect which code sequences and algorithms have which energy consumption, we can use jPowerMonitor for analysis with Rhino. Here we use jPowerMonitor as a Java agent. It is important not to use Rhino in interpretative mode, it is necessary to compile the JavaScript source code into a class. The following batch file can be used to perform an analysis:

java -cp ".;rhino-1.7.14.jar" org.mozilla.javascript.tools.jsc.Main yourScript.js
java -javaagent:jpowermonitor-1.1.2-all.jar=jpowermonitor.yaml -cp ".;rhino-1.7.14.jar" yourScript

It compiles the JavaScript source to a class and invoke this class with jPowerMonitor as agent.

Example Code to be Analyzed

In the following example four sorting algorithms are compared and their energy consumption determined.

// Class to create random numbers in an array
function CArray(numElements) {

  this.dataStore = [];
  this.pos = 0;
  this.numElements = numElements;

  for (var i = 0; i < numElements; ++i) {
    this.dataStore[i] = i;
  }

}

CArray.prototype = {

  setData : function() {
    for (var i = 0; i < this.numElements; ++i) {
      this.dataStore[i] = Math.floor(Math.random() * (255));
    }
  },

  clear : function() {
    for (var i = 0; i < this.dataStore.length; ++i) {
      this.dataStore[i] = 0;
    }
  },

  insert : function(element) {
    this.dataStore[this.pos++] = element;
  },

  toString : function() {
    var retstr = "";
    for (var i = 0; i < this.dataStore.length; i++) {
      if (i < this.dataStore.length - 1) {
        retstr += this.dataStore[i] + ",";
      } else {
        retstr += this.dataStore[i];
      }
    }
    return retstr;
  }

}

// Bubble Sort
function bubbleSort(dataStore) {

  var swap = function(arr, index1, index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
  }

  var numElements = dataStore.length;
  var temp;

  for (var outer = numElements; outer >= 2; --outer) {
    for (var inner = 0; inner <= outer-1; ++inner) {
      if (dataStore[inner] > dataStore[inner+1]) {
        swap(dataStore, inner, inner+1);
      }
    }
  }

}

// Selection Sort
function selectionSort(dataStore) {

  var swap = function(arr, index1, index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
  }

  var min, temp;

  for (var outer = 0; outer <= dataStore.length-2; ++outer) {
    min = outer;
    for (var inner = outer + 1; inner <= dataStore.length-1; ++inner) {
      if (dataStore[inner] < dataStore[min]) {
        min = inner;
      }
    }
    swap(dataStore, outer, min);
  }

}

// Insertion Sort
function insertionSort(dataStore) {
  var temp, inner;
  for (var outer = 1; outer <= dataStore.length-1; ++outer) {
    temp = dataStore[outer];
    inner = outer;
    while (inner > 0 && (dataStore[inner-1] >= temp)) {
      dataStore[inner] = dataStore[inner-1];
      --inner;
    }
    dataStore[inner] = temp;
  }
}

// Quick Sort
function quickSort(arr) {
  if (arr.length == 0) {
    return [];
  }
  var left = [];
  var right = [];
  var pivot = arr[0];
  for (var i = 1; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return quickSort(left).concat(pivot, quickSort(right));
}

function main() {

  // Define that 25000 random numbers are generated
  print("\nComparison with 25000 random numbers");
  var numElements = 25000;

  // Generate random numbers and sort it with bubble sort algorithm
  print("\nBubble sort running...");
  var numsBubbleSort = new CArray(numElements);
  numsBubbleSort.setData();
  var startTime = new Date().getTime();
  bubbleSort(numsBubbleSort.dataStore);
  var endTime = new Date().getTime();
  var time = endTime - startTime;
  print("Bubble sort execution time: " + time + " milliseconds");

  // Generate random numbers and sort it with selection sort algorithm
  print("\nSelection sort running...");
  var numsSelectionSort = new CArray(numElements);
  numsSelectionSort.setData();
  startTime = new Date().getTime();
  selectionSort(numsSelectionSort.dataStore);
  endTime = new Date().getTime();
  time = endTime - startTime;
  print("Selection sort execution time: " + time + " milliseconds");

  // Generate random numbers and sort it with insertion sort algorithm
  print("\nInsertion sort running...");
  var numsInsertionSort = new CArray(numElements);
  numsInsertionSort.setData();
  startTime = new Date().getTime();
  insertionSort(numsInsertionSort.dataStore);
  endTime = new Date().getTime();
  time = endTime - startTime;
  print("Insertion sort execution time: " + time + " milliseconds");

  // Generate random numbers and sort it with quick sort algorithm
  print("\nQuick sort running...");
  var numsQuickSort = new CArray(numElements);
  numsQuickSort.setData();
  startTime = new Date().getTime();
  quickSort(numsQuickSort.dataStore)
  endTime = new Date().getTime();
  time = endTime - startTime;
  print("Quick sort execution time: " + time + " milliseconds");

}

main();

The example code contains a class for generating random numbers and four functions that contain the specific sorting algorithm. In the main function they are called sequentially and the execution time is measured.

Result of the Example

By calling the JavaScript code and measure it, the following result is displayed or similar:

Comparison with 25000 random numbers

Bubble sort running...
Bubble sort execution time: 19171 milliseconds

Selection sort running...
Selection sort execution time: 13990 milliseconds

Insertion sort running...
Insertion sort execution time: 1769 milliseconds

Quick sort running...
Quick sort execution time: 173 milliseconds

jPowerMonitor creates a file with the prefix jPowerMonitor in the name and the tail energy_per_method.csv. This files contains a list with the energy consumption of each method of the JavaScript source. After sorting the energy consumption in descending order, it looks like this, for example:

Thread	Method	Energy	CO2
main	org.mozilla.javascript.ScriptRuntime.nameOrFunction	451,54763 J	0,06083 g
main	org.mozilla.javascript.ScriptRuntime.nameIncrDecr	141,47857 J	0,01906 g
Statistics	java.lang.Thread.getStackTrace	61,76399 J	0,00832 g
main	org.mozilla.javascript.IdScriptableObject.get	55,14209 J	0,00743 g
main	test._c_bubbleSort_6	37,83092 J	0,00510 g
main	test._c_anonymous_7	33,58804 J	0,00453 g
main	test._c_selectionSort_8	5,39698 J	0,00073 g
main	org.mozilla.javascript.ScriptableObject.getProperty	4,01843 J	0,00054 g
main	test._c_insertionSort_10	3,44042 J	0,00046 g
main	test._c_quickSort_11	2,24607 J	0,00030 g
main	org.mozilla.javascript.ScriptableObject.getBase	0,44327 J	0,00006 g
main	org.mozilla.javascript.ScriptRuntime.getObjectElem	0,44143 J	0,00006 g
main	org.mozilla.javascript.NativeArray.js_push	0,44140 J	0,00006 g
main	test._c_CArray_1	0,44097 J	0,00006 g
main	java.lang.StringLatin1.regionMatchesCI	0,08478 J	0,00001 g

The calls of the sorting algorithms and their results are clearly visible.

It is important to ensure that no other activities are executed out on the computer.

Conclusion

jPowerMonitor is a great library. In the context of JavaScript with the Rhino engine it delivers interesting information about the energy consumption of functions and methods at program execution. However, one disadvantage is that Rhino cannot provide this information in interpretive mode. If a platform uses this mode, this approach can unfortunately not be used. In this case the measurements must be perform on reference systems. But that provides also valuable clues.