Safer array primitives (#1220)

- [x] Review resizable array (what is the intended semantics even)
- [x] Change names of vm primitives.
- [x] Check allocateZeros and allocateNones on JS
- [x] Measure performance cost

Author: phischu

effekt/shared/src/main/scala/effekt/core/vm/Builtin.scala

@@ -248,31 +248,31 @@ lazy val chars: Builtins = Map(
 )
 
 lazy val arrays: Builtins = Map(
-  builtin("array::allocate(Int)") {
+  builtin("array::unsafeAllocate(Int)") {
     case As.Int(x) :: Nil => Value.Array(scala.Array.ofDim(x.toInt))
   },
   builtin("array::size[T](Array[T])") {
     case As.Array(arr) :: Nil => Value.Int(arr.length.toLong)
   },
-  builtin("array::unsafeGet[T](Array[T], Int)") {
+  builtin("array::get[T](Array[T], Int)") {
     case As.Array(arr) :: As.Int(index) :: Nil => arr(index.toInt)
   },
-  builtin("array::unsafeSet[T](Array[T], Int, T)") {
+  builtin("array::set[T](Array[T], Int, T)") {
     case As.Array(arr) :: As.Int(index) :: value :: Nil => arr.update(index.toInt, value); Value.Unit()
   },
 )
 
 lazy val bytearrays: Builtins = Map(
-  builtin("bytearray::allocate(Int)") {
+  builtin("bytearray::unsafeAllocate(Int)") {
     case As.Int(x) :: Nil => Value.ByteArray(scala.Array.ofDim(x.toInt))
   },
   builtin("bytearray::size(ByteArray)") {
     case As.ByteArray(arr) :: Nil => Value.Int(arr.length.toLong)
   },
-  builtin("bytearray::unsafeGet(ByteArray, Int)") {
+  builtin("bytearray::get(ByteArray, Int)") {
     case As.ByteArray(arr) :: As.Int(index) :: Nil => Value.Byte(arr(index.toInt))
   },
-  builtin("bytearray::unsafeSet(ByteArray, Int, Byte)") {
+  builtin("bytearray::set(ByteArray, Int, Byte)") {
     case As.ByteArray(arr) :: As.Int(index) :: As.Byte(value) :: Nil => arr.update(index.toInt, value); Value.Unit()
   },
   builtin("bytearray::compare(ByteArray, ByteArray)") {

examples/benchmarks/are_we_fast_yet/bounce.effekt

@@ -69,7 +69,7 @@ def run(n: Int) = {
 
     each(0, n) { i =>
       each(0, ballCount) { i =>
-        val ball = balls.unsafeGet(i);
+        val ball = balls.get(i);
         val didBounce = ball.bounce();
         if (didBounce)
           bounces = bounces + 1;

examples/benchmarks/are_we_fast_yet/nbody.effekt

@@ -71,13 +71,13 @@ def run(n: Int) = {
   val sun = makeBody(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)
 
   def createBodies(): Array[Body] = {
-    val bodies = allocate[Body](5)
+    val bodies = unsafeAllocate[Body](5)
 
-    bodies.unsafeSet(0, sun);
-    bodies.unsafeSet(1, jupiter);
-    bodies.unsafeSet(2, saturn);
-    bodies.unsafeSet(3, uranus);
-    bodies.unsafeSet(4, neptune);
+    bodies.set(0, sun);
+    bodies.set(1, jupiter);
+    bodies.set(2, saturn);
+    bodies.set(3, uranus);
+    bodies.set(4, neptune);
 
     var px = 0.0;
     var py = 0.0;
@@ -97,16 +97,16 @@ def run(n: Int) = {
         0.0 - (pz / SOLAR_MASS),
         body.mass)
 
-    bodies.unsafeSet(0, sun.offsetMomentum(px, py, pz))
+    bodies.set(0, sun.offsetMomentum(px, py, pz))
 
     bodies
   }
 
   def advance(bodies: Array[Body], dt: Double) = {
     each(0, bodies.size) { i =>
       each(i + 1, bodies.size) { j =>
-        val iBody = bodies.unsafeGet(i);
-        val jBody = bodies.unsafeGet(j);
+        val iBody = bodies.get(i);
+        val jBody = bodies.get(j);
 
         val dx = iBody.x - jBody.x;
         val dy = iBody.y - jBody.y;
@@ -116,15 +116,15 @@ def run(n: Int) = {
         val distance = sqrt(dSquared);
         val mag = dt / (dSquared * distance);
 
-        bodies.unsafeSet(i, Body(
+        bodies.set(i, Body(
           iBody.x, iBody.y, iBody.z,
           iBody.vx - dx * jBody.mass * mag,
           iBody.vy - dy * jBody.mass * mag,
           iBody.vz - dz * jBody.mass * mag,
           iBody.mass
         ));
 
-        bodies.unsafeSet(j, Body(
+        bodies.set(j, Body(
           jBody.x, jBody.y, jBody.z,
           jBody.vx + dx * iBody.mass * mag,
           jBody.vy + dy * iBody.mass * mag,
@@ -135,8 +135,8 @@ def run(n: Int) = {
     }
 
     each(0, bodies.size) { i =>
-      val body = bodies.unsafeGet(i);
-      bodies.unsafeSet(i, Body(
+      val body = bodies.get(i);
+      bodies.set(i, Body(
         body.x + dt * body.vx,
         body.y + dt * body.vy,
         body.z + dt * body.vz,
@@ -151,11 +151,11 @@ def run(n: Int) = {
   def energy(bodies: Array[Body]): Double = {
     var e = 0.0;
     each(0, bodies.size()){ i =>
-      val iBody = bodies.unsafeGet(i);
+      val iBody = bodies.get(i);
       e = e + 0.5 * iBody.mass * (iBody.vx * iBody.vx + iBody.vy * iBody.vy + iBody.vz * iBody.vz);
 
       each(i + 1, bodies.size){ j =>
-        val jBody = bodies.unsafeGet(j);
+        val jBody = bodies.get(j);
         val dx = iBody.x - jBody.x;
         val dy = iBody.y - jBody.y;
         val dz = iBody.z - jBody.z;

examples/benchmarks/are_we_fast_yet/permute.effekt

@@ -4,9 +4,9 @@ import ref
 import array
 
 def swap(arr: Array[Int], i: Int, j: Int) = {
-  val tmp = arr.unsafeGet(i);
-  arr.unsafeSet(i, arr.unsafeGet(j));
-  arr.unsafeSet(j, tmp)
+  val tmp = arr.get(i);
+  arr.set(i, arr.get(j));
+  arr.set(j, tmp)
 }
 
 def run(n: Int) = {

examples/benchmarks/are_we_fast_yet/queens.effekt

@@ -14,19 +14,19 @@ def run(n: Int) = {
   val queenRows: Array[Int] = array(n, -1);
 
   def getRowColumn(r: Int, c: Int): Bool =
-    freeRows.unsafeGet(r) && freeMaxs.unsafeGet(c + r) && freeMins.unsafeGet(c - r + (n - 1))
+    freeRows.get(r) && freeMaxs.get(c + r) && freeMins.get(c - r + (n - 1))
 
   def setRowColumn(r: Int, c: Int, v: Bool) = {
-    freeRows.unsafeSet(r, v);
-    freeMaxs.unsafeSet(c + r, v);
-    freeMins.unsafeSet(c - r + (n - 1), v)
+    freeRows.set(r, v);
+    freeMaxs.set(c + r, v);
+    freeMins.set(c - r + (n - 1), v)
   }
 
   def placeQueen(c: Int): Bool =
     try {
       each(0, n) { r =>
         if (getRowColumn(r, c)) {
-          queenRows.unsafeSet(r, c);
+          queenRows.set(r, c);
           setRowColumn(r, c, false);
 
           if (c == (n - 1)) {

examples/benchmarks/are_we_fast_yet/sieve.effekt

@@ -6,11 +6,11 @@ def run(size: Int) = {
   var primeCount: Int = 0;
   val flags: Array[Bool] = array(size, true);
   each(2, size) { i =>
-    if (flags.unsafeGet(i - 1)) {
+    if (flags.get(i - 1)) {
       primeCount = primeCount + 1;
       var k = i + i;
       while (k <= size) {
-        flags.unsafeSet(k - 1, false);
+        flags.set(k - 1, false);
         k = k + i;
       }
     }

examples/benchmarks/are_we_fast_yet/storage.effekt

@@ -31,7 +31,7 @@ def run(n: Int) = {
   def buildTreeDepth(depth: Int) { rand: Random }: Tree = {
     count.set(count.get + 1);
     if (depth == 1) {
-      Leaf(allocate(mod(rand.next, 10) + 1))
+      Leaf(array::allocateZeros(mod(rand.next, 10) + 1))
     } else {
       Node(
         buildTreeDepth(depth - 1){ rand },

examples/benchmarks/are_we_fast_yet/towers.effekt

@@ -13,25 +13,25 @@ def run(n: Int) = {
   var towers: Towers = array(3, Nil());
 
   def pushDisk(newTopDiskOnPile: Disk, pileIdx: Int): Unit = {
-    val pile: Pile = towers.unsafeGet(pileIdx);
+    val pile: Pile = towers.get(pileIdx);
     pile match {
       case Cons(topDiskOnStack, _) =>
         if (newTopDiskOnPile >= topDiskOnStack) {
           panic("Cannot put a big disk onto a smaller one");
         }
       case Nil() => ()
     }
-    towers.unsafeSet(pileIdx, Cons(newTopDiskOnPile, pile));
+    towers.set(pileIdx, Cons(newTopDiskOnPile, pile));
   }
 
   def popDisk(pileIdx: Int): Disk = {
-    val pile = towers.unsafeGet(pileIdx);
+    val pile = towers.get(pileIdx);
 
     pile match {
       case Nil() =>
         panic("Attempting to remove a disk from an empty pile");
       case Cons(disk, next) =>
-        towers.unsafeSet(pileIdx, next)
+        towers.set(pileIdx, next)
         disk
     }
   }

examples/benchmarks/input_output/large_file.effekt

@@ -16,7 +16,7 @@ def run(n: Int) = {
       panic("failed open for writing")
     }
     val outputBuffer = bytearray(size, 33.toByte)
-    outputBuffer.unsafeSet(999, 10.toByte)
+    outputBuffer.set(999, 10.toByte)
     repeat(n) {
       val m = internal::write(file, outputBuffer, 0, size, -1)
       if (m < outputBuffer.size) {

examples/pos/array/list_conversion.effekt

@@ -50,7 +50,7 @@ def main() = {
   listToArrayAndBack(list)
 
   println("empty array")
-  val emptyArray = array::allocate[Int](0)
+  val emptyArray = array[Int](0, 0)
   arrayToListAndBack(emptyArray)
 
   println("nonempty array")