Implement a mechanism to realloc array buffers; Trap when trying to allocate more than max size; Test allocators in CI

Author: dcodeIO

.travis.yml

@@ -2,8 +2,8 @@ language: node_js
 notifications:
  email: false
 stages:
- - name: check-pr
-  if: type = pull_request
+- name: check-pr
+ if: type = pull_request
 jobs:
  include:
 
@@ -24,6 +24,13 @@ jobs:
  - node_js: node
  script: npm run clean && node bin/asc -v && npm test
  env: Tests the sources on latest stable node.js
+ - node_js: lts/*
+ script:
+ - npm run clean
+ - cd $TRAVIS_BUILD_DIR/tests/allocators/arena && npm run build && cd .. && npm test arena
+ - cd $TRAVIS_BUILD_DIR/tests/allocators/buddy && npm run build && cd .. && npm test buddy
+ - cd $TRAVIS_BUILD_DIR/tests/allocators/tlsf && npm run build && cd .. && npm test tlsf
+ env: Tests the allocators on latest node.js LTS
 
  - stage: build
  node_js: lts/*

bin/asc.js

@@ -279,10 +279,12 @@ exports.main = function main(argv, options, callback) {
  sourceText = readFile(path.join(dir, plainName + ".ts"));
  if (sourceText !== null) {
  sourcePath = exports.libraryPrefix + plainName + ".ts";
+ break;
  } else {
  sourceText = readFile(path.join(dir, indexName + ".ts"));
  if (sourceText !== null) {
  sourcePath = exports.libraryPrefix + indexName + ".ts";
+ break;
  }
  }
  }
@@ -312,10 +314,12 @@ exports.main = function main(argv, options, callback) {
  sourceText = readFile(path.join(dir, plainName + ".ts"));
  if (sourceText !== null) {
  sourcePath = exports.libraryPrefix + plainName + ".ts";
+ break;
  } else {
  sourceText = readFile(path.join(dir, indexName + ".ts"));
  if (sourceText !== null) {
  sourcePath = exports.libraryPrefix + indexName + ".ts";
+ break;
  }
  }
  }
@@ -530,12 +534,17 @@ exports.main = function main(argv, options, callback) {
  sourceMap.sources.forEach((name, index) => {
  let text = null;
  if (name.startsWith(exports.libraryPrefix)) {
- for (let i = 0, k = customLibDirs.length; i < k; ++i) {
- text = readFile(path.join(
- customLibDirs[i],
- name.substring(exports.libraryPrefix.length))
- );
- if (text !== null) break;
+ let stdName = name.substring(exports.libraryPrefix.length).replace(/\.ts$/, "");
+ if (exports.libraryFiles.hasOwnProperty(stdName)) {
+ text = exports.libraryFiles[stdName];
+ } else {
+ for (let i = 0, k = customLibDirs.length; i < k; ++i) {
+ text = readFile(path.join(
+ customLibDirs[i],
+ name.substring(exports.libraryPrefix.length))
+ );
+ if (text !== null) break;
+ }
  }
  } else {
  text = readFile(path.join(baseDir, name));

dist/asc.js

@@ -7,15 +7,15 @@
  * @module std/assembly/allocator/arena
  *//***/
 
-import { AL_MASK } from "../internal/allocator";
+import { AL_MASK, MAX_SIZE_32 } from "../internal/allocator";
 
 var startOffset: usize = (HEAP_BASE + AL_MASK) & ~AL_MASK;
 var offset: usize = startOffset;
 
 @global
 export function allocate_memory(size: usize): usize {
- const MAX_SIZE: usize = 1 << 30;
- if (size && size < MAX_SIZE) {
+ if (size) {
+  if (size > MAX_SIZE_32) unreachable();
  let ptr = offset;
  let newPtr = (ptr + size + AL_MASK) & ~AL_MASK;
  let pagesBefore = current_memory();

dist/asc.js.map

@@ -347,9 +347,7 @@ export function allocate_memory(request: usize): usize {
  * a hard-coded limit on the maximum allocation size because of the way this
  * allocator works.
  */
- if (request > MAX_ALLOC - HEADER_SIZE) {
- return 0;
- }
+ if (request > MAX_ALLOC - HEADER_SIZE) unreachable();
 
  /*
  * Initialize our global state if this is the first call to "malloc". At the

std/assembly/allocator/arena.ts

@@ -457,7 +457,8 @@ export function allocate_memory(size: usize): usize {
 
  // search for a suitable block
  var data: usize = 0;
- if (size && size <= Block.MAX_SIZE) {
+ if (size) {
+ if (size > Block.MAX_SIZE) unreachable();
  // 32-bit MAX_SIZE is 1 << 30 and itself aligned, hence the following can't overflow MAX_SIZE
  size = max<usize>((size + AL_MASK) & ~AL_MASK, Block.MIN_SIZE);
 

std/assembly/allocator/buddy.ts

@@ -1,7 +1,7 @@
 import {
  HEADER_SIZE,
  MAX_BLENGTH,
- allocate
+ allocUnsafe
 } from "./internal/arraybuffer";
 
 @sealed
@@ -11,7 +11,7 @@ export class ArrayBuffer {
 
  constructor(length: i32) {
  if (<u32>length > <u32>MAX_BLENGTH) throw new RangeError("Invalid array buffer length");
- var buffer = allocate(length);
+ var buffer = allocUnsafe(length);
  set_memory(changetype<usize>(buffer) + HEADER_SIZE, 0, <usize>length);
  return buffer;
  }
@@ -23,7 +23,7 @@ export class ArrayBuffer {
  if (end < 0) end = max(len + end, 0);
  else end = min(end, len);
  var newLen = max(end - begin, 0);
- var buffer = allocate(newLen);
+ var buffer = allocUnsafe(newLen);
  move_memory(changetype<usize>(buffer) + HEADER_SIZE, changetype<usize>(this) + HEADER_SIZE + begin, newLen);
  return buffer;
  }

std/assembly/allocator/tlsf.ts

@@ -17,14 +17,44 @@ export function computeSize(byteLength: i32): usize {
  return <usize>1 << <usize>(<u32>32 - clz<u32>(byteLength + HEADER_SIZE - 1));
 }
 
-/** Allocates a raw ArrayBuffer with uninitialized contents. */
-export function allocate(byteLength: i32): ArrayBuffer {
+/** Allocates a raw ArrayBuffer. Contents remain uninitialized. */
+export function allocUnsafe(byteLength: i32): ArrayBuffer {
  assert(<u32>byteLength <= <u32>MAX_BLENGTH);
  var buffer = allocate_memory(computeSize(byteLength));
  store<i32>(buffer, byteLength, offsetof<ArrayBuffer>("byteLength"));
  return changetype<ArrayBuffer>(buffer);
 }
 
+/** Reallocates an ArrayBuffer, resizing it as requested. Tries to modify the buffer in place. */
+export function reallocUnsafe(buffer: ArrayBuffer, newByteLength: i32): ArrayBuffer {
+ var oldByteLength = buffer.byteLength;
+ if (newByteLength > oldByteLength) {
+ assert(newByteLength <= MAX_BLENGTH);
+ let oldSize = computeSize(oldByteLength);
+ if (<i32>(oldSize - HEADER_SIZE) <= newByteLength) { // fast path: zero out additional space
+ store<i32>(changetype<usize>(buffer), newByteLength, offsetof<ArrayBuffer>("byteLength"));
+ set_memory(
+ changetype<usize>(buffer) + HEADER_SIZE + oldByteLength,
+ 0,
+ <usize>(newByteLength - oldByteLength)
+ );
+ } else { // slow path: copy to new buffer
+ let newBuffer = allocUnsafe(newByteLength);
+ move_memory(
+ changetype<usize>(newBuffer) + HEADER_SIZE,
+ changetype<usize>(buffer) + HEADER_SIZE,
+ <usize>newByteLength
+ );
+ return newBuffer;
+ }
+ } else if (newByteLength < oldByteLength) { // fast path: override size
+ // TBD: worth to copy and release if size is significantly less than before?
+ assert(newByteLength >= 0);
+ store<i32>(changetype<usize>(buffer), newByteLength, offsetof<ArrayBuffer>("byteLength"));
+ }
+ return buffer;
+}
+
 /** Common typed array interface. Not a global object. */
 // export declare interface ArrayBufferView<T> {
 // readonly buffer: ArrayBuffer;

std/assembly/arraybuffer.ts

@@ -1,6 +1,7 @@
 import {
+ HEADER_SIZE,
  MAX_BLENGTH,
- allocate
+ allocUnsafe
  // ArrayBufferView
 } from "./arraybuffer";
 
@@ -15,7 +16,9 @@ export abstract class TypedArray<T> /* implements ArrayBufferView<T> */ {
  const MAX_LENGTH = <u32>MAX_BLENGTH / sizeof<T>();
  if (<u32>length > MAX_LENGTH) throw new RangeError("Invalid typed array length");
  var byteLength = length << alignof<T>();
- this.buffer = allocate(byteLength);
+ var buffer = allocUnsafe(byteLength);
+ set_memory(changetype<usize>(buffer) + HEADER_SIZE, 0, <usize>byteLength);
+ this.buffer = buffer;
  this.byteOffset = 0;
  this.byteLength = byteLength;
  }