[WIP] lib/threading

.gitignore

@@ -3,3 +3,6 @@ docs/
 node_modules/
 out/
 raw/
+.history
+.vscode
+.idea

cli/asc.js

@@ -417,7 +417,9 @@ exports.main = function main(argv, options, callback) {
   assemblyscript.setNoTreeShaking(compilerOptions, args.noTreeShaking);
   assemblyscript.setNoAssert(compilerOptions, args.noAssert);
   assemblyscript.setImportMemory(compilerOptions, args.importMemory);
+  assemblyscript.setSharedMemory(compilerOptions, args.sharedMemory);
   assemblyscript.setImportTable(compilerOptions, args.importTable);
+  assemblyscript.ignoreDataSegments(compilerOptions, args.ignoreDataSegments);
   assemblyscript.setMemoryBase(compilerOptions, args.memoryBase >>> 0);
   assemblyscript.setSourceMap(compilerOptions, args.sourceMap != null);
   assemblyscript.setOptimizeLevelHints(compilerOptions, optimizeLevel, shrinkLevel);

cli/asc.json

@@ -106,6 +106,16 @@
     "type": "b",
     "default": false
   },
+  "sharedMemory": {
+    "description": "Declare memory as shared.",
+    "type": "i",
+    "default": 0
+  },
+  "ignoreDataSegments": {
+    "description": "Ingore data segments to binary. Default false.",
+    "type": "b",
+    "default": false
+  },
   "memoryBase": {
     "description": "Sets the start offset of compiler-generated static memory.",
     "type": "i",

examples/atomic-shared-memory/assembly/index.js

@@ -0,0 +1,23 @@
+const fs   = require("fs");
+const path = require("path");
+
+const compiled = new WebAssembly.Module(
+  fs.readFileSync(path.resolve(__dirname, "..", "build", "atomic.builtins.wasm"))
+);
+const memory = new WebAssembly.Memory({
+  initial: 256,
+  maximum: 256,
+  shared: true
+})
+const imports = {
+  env: {
+    memory,
+    abort: (filename, line, column) => {
+      throw Error("abort called at " + line + ":" + colum);
+    }
+  }
+};
+
+Object.defineProperty(module, "exports", {
+  get: () => new WebAssembly.Instance(compiled, imports).exports
+});

examples/atomic-shared-memory/assembly/index.ts

@@ -0,0 +1,105 @@
+declare function log(v: i32): void;
+
+export function test(): void {
+  var i: i32 = 0;
+  var u: u32 = 0;
+  var I: i64 = 0;
+  var U: u64 = 0;
+
+  // Atomic store
+  Atomic.store<i8>(120, <i32>8);
+  Atomic.store<i16>(121, <i32>16);
+  Atomic.store<i32>(123, <i32>32);
+
+  Atomic.store<i8>(120, <i64>8);
+  Atomic.store<i16>(121, <i64>16);
+  Atomic.store<i32>(123, <i64>32);
+  Atomic.store<i64>(127, <i64>64);
+
+  // Atomic load
+  i = Atomic.load<i8>(120);
+  i = Atomic.load<i16>(121);
+  i = Atomic.load<i32>(123);
+  u = Atomic.load<i8>(120);
+  u = Atomic.load<i16>(121);
+  u = Atomic.load<i32>(123);
+
+  I = Atomic.load<i8>(120);
+  I = Atomic.load<i16>(121);
+  I = Atomic.load<i32>(123);
+  I = Atomic.load<i64>(127);
+  U = Atomic.load<i8>(120);
+  U = Atomic.load<i16>(121);
+  U = Atomic.load<i32>(123);
+  U = Atomic.load<i64>(127);
+
+  // Atomic add
+  i = Atomic.add<i8>(120, 1);
+  i = Atomic.add<i16>(121, 1);
+  i = Atomic.add<i32>(123, 1);
+
+  I = Atomic.add<i8>(120, <i64>1);
+  I = Atomic.add<i16>(121, <i64>1);
+  I = Atomic.add<i32>(123, <i64>1);
+  I = Atomic.add<i64>(127, <i64>1);
+
+  // Atomic subtract
+  Atomic.sub<i8>(120, 1);
+  Atomic.sub<i16>(121, 1);
+  Atomic.sub<i32>(123, 1);
+
+  I = Atomic.sub<i8>(120, <i64>1);
+  I = Atomic.sub<i16>(121, <i64>1);
+  I = Atomic.sub<i32>(123, <i64>1);
+  I = Atomic.sub<i64>(127, <i64>1);
+
+  // Atomic AND
+  Atomic.and<i8>(120, 1);
+  Atomic.and<i16>(121, 1);
+  Atomic.and<i32>(123, 1);
+
+  I = Atomic.and<i8>(120, <i64>1);
+  I = Atomic.and<i16>(121, <i64>1);
+  I = Atomic.and<i32>(123, <i64>1);
+  I = Atomic.and<i64>(127, <i64>1);
+
+  // Atomic OR
+  Atomic.or<i8>(120, 1);
+  Atomic.or<i16>(121, 1);
+  Atomic.or<i32>(123, 1);
+
+  I = Atomic.or<i8>(120, <i64>1);
+  I = Atomic.or<i16>(121, <i64>1);
+  I = Atomic.or<i32>(123, <i64>1);
+  I = Atomic.or<i64>(127, <i64>1);
+
+  // Atomic XOR
+  Atomic.xor<i8>(120, 1);
+  Atomic.xor<i16>(121, 1);
+  Atomic.xor<i32>(123, 1);
+
+  I = Atomic.xor<i8>(120, <i64>1);
+  I = Atomic.xor<i16>(121, <i64>1);
+  I = Atomic.xor<i32>(123, <i64>1);
+  I = Atomic.xor<i64>(127, <i64>1);
+
+  // Atomic xchg
+  Atomic.xchg<i8>(120, 1);
+  Atomic.xchg<i16>(121, 1);
+  Atomic.xchg<i32>(123, 1);
+
+  I = Atomic.xchg<i8>(120, <i64>1);
+  I = Atomic.xchg<i16>(121, <i64>1);
+  I = Atomic.xchg<i32>(123, <i64>1);
+  I = Atomic.xchg<i64>(127, <i64>1);
+
+  // Atomic cmpxchg
+  Atomic.cmpxchg<i8>(120, 1, 2);
+  Atomic.cmpxchg<i16>(121, 1, 2);
+  Atomic.cmpxchg<i32>(123, 1, 2);
+
+  I = Atomic.cmpxchg<i8>(120, <i64>1, <i64>2);
+  I = Atomic.cmpxchg<i16>(121, <i64>1, <i64>2);
+  I = Atomic.cmpxchg<i32>(123, <i64>1, <i64>2);
+  I = Atomic.cmpxchg<i64>(127, <i64>1, <i64>2);
+}

examples/atomic-shared-memory/assembly/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../../std/assembly.json",
+  "include": [
+    "./**/*.ts"
+  ]
+}

examples/atomic-shared-memory/build/index.asm.js

@@ -0,0 +1,77 @@
+function asmFunc(global, env, buffer) {
+ "almost asm";
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+ var Math_imul = global.Math.imul;
+ var Math_fround = global.Math.fround;
+ var Math_abs = global.Math.abs;
+ var Math_clz32 = global.Math.clz32;
+ var Math_min = global.Math.min;
+ var Math_max = global.Math.max;
+ var Math_floor = global.Math.floor;
+ var Math_ceil = global.Math.ceil;
+ var Math_sqrt = global.Math.sqrt;
+ var abort = env.abort;
+ var nan = global.NaN;
+ var infinity = global.Infinity;
+ var $0 = env.memory;
+ var $lib_allocator_arena_startOffset = 0;
+ var $lib_allocator_arena_offset = 0;
+ var assembly_index_str = 8;
+ var HEAP_BASE = 16;
+ var i64toi32_i32$HIGH_BITS = 0;
+ function assembly_index_read() {
+  return assembly_index_str | 0;
+ }
+
+ function start() {
+  $lib_allocator_arena_startOffset = (HEAP_BASE + 7 | 0) & 4294967288 | 0;
+  $lib_allocator_arena_offset = $lib_allocator_arena_startOffset;
+ }
+
+ function __wasm_grow_memory(pagesToAdd) {
+  pagesToAdd = pagesToAdd | 0;
+  var oldPages = __wasm_current_memory() | 0;
+  var newPages = oldPages + pagesToAdd | 0;
+  if ((oldPages < newPages) && (newPages < 65535)) {
+   var newBuffer = new ArrayBuffer(Math_imul(newPages, 65536));
+   var newHEAP8 = new global.Int8Array(newBuffer);
+   newHEAP8.set(HEAP8);
+   HEAP8 = newHEAP8;
+   HEAP16 = new global.Int16Array(newBuffer);
+   HEAP32 = new global.Int32Array(newBuffer);
+   HEAPU8 = new global.Uint8Array(newBuffer);
+   HEAPU16 = new global.Uint16Array(newBuffer);
+   HEAPU32 = new global.Uint32Array(newBuffer);
+   HEAPF32 = new global.Float32Array(newBuffer);
+   HEAPF64 = new global.Float64Array(newBuffer);
+   buffer = newBuffer;
+  }
+  return oldPages;
+ }
+
+ function __wasm_current_memory() {
+  return buffer.byteLength / 65536 | 0;
+ }
+
+ return {
+  read: assembly_index_read, 
+  memory: Object.create(Object.prototype, {
+   grow: {
+    value: __wasm_grow_memory
+   }, 
+   buffer: {
+    get: function () {
+     return buffer;
+    }
+
+   }
+  })
+ };
+}

examples/atomic-shared-memory/build/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("allocator/arena");
+let str = "A";
+function read() {
+    return str;
+}
+exports.read = read;