Run results for: sha1asm - MeasureThat.net

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:49.0) Gecko/20100101 Firefox/49.0

Browser: Firefox 49

Operating system: Mac OS X 10.11

Device Platform: Other

Date tested: 7 years ago

Test name	Executions per second
computeHash_direct	764.1 Ops/sec
computeHash_parse	1539.5 Ops/sec

HTML Preparation code:

<html>
  <body>
  <script src="https://www.toolsley.com/sha1asm.js"></script>
  
  <div id="computeHash_direct"></div>
  </body>
</html>

Script Preparation code:

var typedArray, blob;

typedArray = new Uint8Array(1024 * 1024);
for (var i = 0; i < typedArray.length; typedArray[i] = i % 256, ++i);

blob = new Blob([typedArray], {type: 'application/octet-binary'}); 

function computeHash_direct(file, hashCallback, errorCallback) {
  var hashAlgo = new sha1asm();
  var hash;

  // function parseFile(file, endCallback) {
  var fileSize = file.size,
      chunkSize = 2097152,  // 1024 * 1024 * 2 - read in chunks of 2MB
      offset = 0,
      endByte,
      time,
      fileReader = new FileReader();

  function readNextChunk() {
    var endFromOffset = offset + chunkSize,
        endByte = endFromOffset >= fileSize ? fileSize : endFromOffset;
    fileReader.readAsArrayBuffer(file.slice(offset, endByte));
  }

  fileReader.onloadend = function (e) {
    var arrayBuffer = e.target.result;

    hashAlgo.update(new Uint8Array(arrayBuffer));
    
    offset += arrayBuffer.byteLength;
    if (offset < fileSize) {
      readNextChunk();
    } else {
      hash = hashAlgo.final();
      // console.log("Time to parse (direct) (ms): " + (new Date().getTime() - time));
      // console.log("Hash (sha1asm): " + hash);
      if (!e.target.error) {
        hashCallback(hash);
      } else {
        errorCallback(e.target.error);
      }
      //endCallback(e.target.error);
    }

  };
  fileReader.onerror = function () {
  };

  time = new Date().getTime();
  hashAlgo.reset();
  readNextChunk();
}

function computeHash_parse(file, hashCallback, errorCallback) {
  var hashAlgo;

  function parseFile(file, chunkCallback, endCallback) {
    var // blobSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice,
    fileSize = file.size,
        chunkSize = 2097152,  // 1024 * 1024 * 2 - read in chunks of 2MB
        offset = 0,
        endByte,
        time,
        fileReader = new FileReader();

    function readNextChunk() {
      var endFromOffset = offset + chunkSize,
          endByte = endFromOffset >= fileSize ? fileSize : endFromOffset;
      //fileReader.readAsArrayBuffer(blobSlice.call(file, offset, endByte));
      fileReader.readAsArrayBuffer(file.slice(offset, endByte));
    }

    fileReader.onloadend = function (e) {
      var arrayBuffer = e.target.result;

      chunkCallback(arrayBuffer);

      offset += arrayBuffer.byteLength;
      if (offset < fileSize) {
        readNextChunk();
      } else {
        endCallback(e.target.error);
        //console.log("Time to parse (parse) (ms): " + (new Date().getTime() - time));
      }
    };
    fileReader.onerror = function () {
      // running = false;
      // registerLog('<strong>Oops, something went wrong.</strong>', 'error');
    };

    time = new Date().getTime();
    readNextChunk();
  }

  hashAlgo = new sha1asm();
  hashAlgo.reset();
  parseFile(file,
            function (arrayBuffer) {
              hashAlgo.update(new Uint8Array(arrayBuffer));
              // hashAlgo.update(arrayBuffer);
            },
            function (err) {
              if (! err) {
                var hash = hashAlgo.final();
                // console.log("Hash (sha1asm): " + hash);
                hashCallback(hash);
              } else if (typeof errorCallback === "function" ) {
                errorCallback(err);
              }
  			}
           );
}  

function logHash(hash) {
  // console.log("Hash:", hash);
}

function logErr(err) {
  // console.log("ERROR:", err);
}

Tests:

computeHash_direct
computeHash_direct(blob, logHash, logErr);
computeHash_parse
computeHash_parse(blob, logHash, logErr);