BlurShader.ts

import Shader = require("./Shader");

export = BlurShader;

class BlurShader implements Shader {
    apply(d:number[], o:number[], s:number, xmin:number, xmax:number, ymin:number, ymax:number) {
        for (var y:number = ymin; y < ymax; ++y) {
            for (var x:number = xmin; x < xmax; ++x) {
                var p:number = y * s + x;
                var a:number = d[p] * 2
                      + d[p - 1]
                      + d[p + 1]
                      + d[p - s]
                      + d[p + s];
                a = (1000 * (a + 500)) / 6000;
                o[p] = a | 0;
            }
        }
    }
}

Image.ts

import Shader = require("./Shader");

export = Image;

class Image {
    private data:number[];
    private width:number;
    private height:number;
    private stride:number;

    private static generator:Shader = {
        apply: (i:number[], o:number[], s:number, xmin:number, xmax:number, ymin:number, ymax:number) => {
            for (var y = ymin; y < ymax; ++y) {
                for (var x = xmin; x < xmax; ++x) {
                    var p:number = y * s + x;
                    o[p] = Math.random();
                }
            }
        }
    };

    public static random(newWidth:number, newHeight:number):Image {
        return new Image(newWidth, newHeight).process(Image.generator);
    }

    constructor(width:number, height:number, data:number[] = null) {
        this.width = width;
        this.height = height;
        this.stride = width + 2;
        var area = this.stride * (this.height + 2);

        if (data === null) {
            this.data = new Array(area);
        } else if (data.length != area) {
            throw new Error("Invalid data buffer.");
        } else {
            this.data = data;
        }
    }

    public process(f:Shader):Image {
        var w = this.width, h = this.height, s = this.stride;
        var d:number[] = this.data;
        var n:number[] = new Array(d.length);

        f.apply(d, n, s, 1, w, 1, h);
        return new Image(w, h, n);
    }

    public processInline():Image {
        var w:number = this.width, h:number = this.height, s:number = this.stride;
        var d:number[] = this.data;
        var n:number[] = new Array(d.length);

        for (var y = 1; y < h; ++y) {
            for (var x = 1; x < w; ++x) {
                var p = y * s + x;
                var a = d[p] * 2
                    + d[p - 1]
                    + d[p + 1]
                    + d[p - s]
                    + d[p + s];
                n[p] = (1000 * (a + 500)) / 6000;
            }
        }

        return new Image(w, h, n);
    }
}

main.ts

import ShaderBench = require("./ShaderBench");

console.log("Instantiating benchmark...");
var benchmark = new ShaderBench();

console.log("Executing loops with callback...");
for (var i = 0; i < 100; ++i) {
    console.log("Executing iteration " + i);
    benchmark.testProcessProc();
}

console.log("Executing loops with inline...");
for (var i = 0; i < 100; ++i) {
    console.log("Executing iteration " + i);
    benchmark.testProcessInline();
}

Shader.ts

export = Shader;

interface Shader {
    apply(input:Number[], out:Number[], stride:Number, xmin:Number, xmax:Number, ymin:Number, ymax:Number);
}

ShaderBench.ts

import BlurShader = require("./BlurShader");
import Image = require("./Image");
import Shader = require("./Shader");

export = ShaderBench;

class ShaderBench {
    public static width = 4000;
    public static height = 2000;
    public proc:Shader;
    public lambda:Shader;
    public image:Image;

    public constructor() {
        this.image = Image.random(ShaderBench.width, ShaderBench.height);

        this.proc = new BlurShader();
        this.lambda = {
            apply: (d:number[], o:number[], s:number, xmin:number, xmax:number, ymin:number, ymax:number) => {
                for (var y = ymin; y < ymax; ++y) {
                    for (var x = xmin; x < xmax; ++x) {
                        var p = y * s + x;
                        var a = d[p] * 2
                            + d[p - 1]
                            + d[p + 1]
                            + d[p - s]
                            + d[p + s];
                        a = (1000 * (a + 500)) / 6000;
                        o[p] = a;
                    }
                }
            }
        };
    }

    public testProcessProc():Image {
        return this.image.process(this.proc);
    }

    public testProcessInline():Image {
        return this.image.processInline();
    }

    public testProcessLambda():Image {
        return this.image.process(this.lambda);
    }
}