Производительность Node.js/coffeescript на алгоритме, интенсивно использующем математику

Как указывали другие ответчики, массивы JavaScript являются основным узким местом производительности для того типа операций, которые вы выполняете. Поскольку они динамические, доступ к элементам, естественно, намного медленнее, чем при использовании статических массивов Java.

Хорошая новость заключается в том, что в JavaScript появился новый стандарт для статически типизированных массивов, который уже поддерживается некоторыми браузерами. Хотя они еще не поддерживаются в самом Node, вы можете легко добавить их с помощью библиотеки: https://github.com/tlrobinson/v8-typed-array

После установки typed-array через npm вот моя модифицированная версия вашего кода:

{Float32Array} = require 'typed-array'

genHeightField = (sz) ->
    timeStart = new Date()
    DATA_SIZE = sz
    SEED = 1000.0
    iters = 0

    # Initialize 2D array of floats
    data = new Array(DATA_SIZE)
    for rows in [0...DATA_SIZE]
      data[rows] = new Float32Array(DATA_SIZE)
      for cols in [0...DATA_SIZE]
          data[rows][cols] = 0

    # The rest is the same...

Ключевой строкой здесь является объявление data[rows].

С помощью строки data[rows] = new Array(DATA_SIZE) (по сути, эквивалентной оригиналу) я получаю контрольные числа:

17
75
417
1376
5461

И со строкой data[rows] = new Float32Array(DATA_SIZE) я получаю

19
47
215
855
3452

Таким образом, одно небольшое изменение сокращает время работы примерно на 1/3, то есть увеличивает скорость на 50%!

Это все еще не Java, но это довольно существенное улучшение. Ожидайте, что будущие версии Node/V8 еще больше сократят разрыв в производительности.

Предостережение: следует отметить, что обычные числа JS имеют двойную точность, то есть 64-битные числа с плавающей запятой. Использование Float32Array, таким образом, снизит точность, что сделает это чем-то вроде сравнения яблок и апельсинов — я не знаю, насколько улучшение производительности связано с использованием 32-битной математики, а насколько — с более быстрым доступом к массиву. Float64Array является частью спецификации V8, но еще не реализован в библиотека v8-typed-array.)

Если вы ищете производительность в таких алгоритмах, как coffee/js, так и Java — неправильные языки для использования. Javascript особенно плохо подходит для таких задач, потому что он не имеет типа массива — массивы — это просто хэш-карты, где ключи должны быть целыми числами, что, очевидно, не будет таким быстрым, как настоящий массив. Что вам нужно, так это написать этот алгоритм на C и вызывать его из узла (см. http://nodejs.org/docs/v0.4.10/api/addons.html). Если вы действительно не умеете вручную оптимизировать машинный код, хороший C легко превзойдет любой другой язык.

Забудьте на минуту о Coffeescript, потому что это не корень проблемы. Этот код в любом случае просто записывается в обычный старый javascript, когда узел его запускает.

Как и любая другая среда javascript, node является однопоточным. Двигатель V8 чертовски быстр, но для некоторых типов приложений вы не сможете превзойти скорость JVM.

Я бы сначала предложил попробовать исправить ваш алмазный алгоритм непосредственно в js, прежде чем переходить на CS. Посмотрите, какие виды оптимизации скорости вы можете сделать.

На самом деле, меня сейчас тоже немного интересует эта проблема, и я собираюсь взглянуть на это.

Редактировать #2 Это моя вторая переработка с некоторыми оптимизациями, такими как предварительное заполнение массива данных. Это не значительно быстрее, но код немного чище.

var makegrid = function(size){
    size++; //increment by 1

    var grid = [];
        grid.length = size,
        gsize = size-1; //frequently used value in later calculations.

    //setup grid array
    var len = size;
    while(len--){
        grid[len] = (new Array(size+1).join(0).split('')); //creates an array of length "size" where each index === 0
    }

    //populate four corners of the grid
    grid[0][0] = grid[gsize][0] = grid[0][gsize] = grid[gsize][gsize] = corner_vals;

    var side_length = gsize;

    while(side_length >= 2){
        var half_side = Math.floor(side_length / 2);

        //generate new square values
        for(var x=0; x<gsize; x += side_length){
            for(var y=0; y<gsize; y += side_length){

                //calculate average of existing corners            
                var avg = ((grid[x][y] + grid[x+side_length][y] + grid[x][y+side_length] + grid[x+side_length][y+side_length]) / 4) + (Math.random() * (2*height_range - height_range));

                //calculate random value for avg for center point
                grid[x+half_side][y+half_side] = Math.floor(avg);

            }
        }

        //generate diamond values
        for(var x=0; x<gsize; x+= half_side){
            for(var y=(x+half_side)%side_length; y<gsize; y+= side_length){

                var avg = Math.floor( ((grid[(x-half_side+gsize)%gsize][y] + grid[(x+half_side)%gsize][y] + grid[x][(y+half_side)%gsize] + grid[x][(y-half_side+gsize)%gsize]) / 4) + (Math.random() * (2*height_range - height_range)) );

                grid[x][y] = avg;

                if( x === 0) grid[gsize][y] = avg;
                if( y === 0) grid[x][gsize] = avg;
            }
        }

        side_length /= 2;
        height_range /= 2;
    }

    return grid;
}

makegrid(256)
makegrid(512)
makegrid(1024)
makegrid(2048)
makegrid(4096)

Я всегда предполагал, что когда люди описывают среду выполнения javascript как «быструю», они имеют в виду относительно других интерпретируемых динамических языков. Интересно было бы сравнение с ruby, python или smalltalk. Сравнивать JavaScript с Java некорректно.

Отвечая на ваш вопрос, я считаю, что результаты, которые вы видите, указывают на то, что вы можете ожидать, сравнивая эти два совершенно разных языка.