Implement and benchmark ArrowOperationPlus node

engine/runtime-language-arrow/src/main/java/org/enso/interpreter/arrow/ArrowParser.java

@@ -12,35 +12,41 @@ public record Result(PhysicalLayout physicalLayout, LogicalLayout logicalLayout,
 
   public static Result parse(Source source) {
     String src = source.getCharacters().toString();
-    Matcher m = NEW_ARRAY_CONSTR.matcher(src);
+    Matcher m = PATTERN.matcher(src);
     if (m.find()) {
       try {
-        var layout = LogicalLayout.valueOf(m.group(1));
-        return new Result(PhysicalLayout.Primitive, layout, Mode.Allocate);
+        var layout = LogicalLayout.valueOf(m.group(2));
+        var mode = Mode.parse(m.group(1));
+        if (layout != null && mode != null) {
+          return new Result(PhysicalLayout.Primitive, layout, mode);
+        }
       } catch (IllegalArgumentException iae) {
         // propagate warning
-        return null;
-      }
-    }
-
-    m = CAST_PATTERN.matcher(src);
-    if (m.find()) {
-      try {
-        var layout = LogicalLayout.valueOf(m.group(1));
-        return new Result(PhysicalLayout.Primitive, layout, Mode.Cast);
-      } catch (IllegalArgumentException iae) {
-        // propagate warning
-        return null;
       }
     }
     return null;
   }
 
-  private static final Pattern NEW_ARRAY_CONSTR = Pattern.compile("^new\\[(.+)\\]$");
-  private static final Pattern CAST_PATTERN = Pattern.compile("^cast\\[(.+)\\]$");
+  private static final Pattern PATTERN = Pattern.compile("^([a-z\\+]+)\\[(.+)\\]$");
 
   public enum Mode {
-    Allocate,
-    Cast
+    Allocate("new"),
+    Cast("cast"),
+    Plus("+");
+
+    private final String op;
+
+    private Mode(String text) {
+      this.op = text;
+    }
+
+    static Mode parse(String operation) {
+      for (var m : values()) {
+        if (m.op.equals(operation)) {
+          return m;
+        }
+      }
+      return null;
+    }
   }
 }

engine/runtime-language-arrow/src/main/java/org/enso/interpreter/arrow/node/ArrowEvalNode.java

@@ -6,13 +6,13 @@
 import com.oracle.truffle.api.nodes.RootNode;
 import org.enso.interpreter.arrow.ArrowLanguage;
 import org.enso.interpreter.arrow.ArrowParser;
+import org.enso.interpreter.arrow.runtime.ArrowCastToFixedSizeArrayFactory;
+import org.enso.interpreter.arrow.runtime.ArrowFixedSizeArrayFactory;
+import org.enso.interpreter.arrow.runtime.ArrowOperationPlus;
 
 public class ArrowEvalNode extends RootNode {
   private final ArrowParser.Result code;
 
-  @Child private ArrowFixedSizeNode fixedPhysicalLayout = ArrowFixedSizeNode.create();
-  @Child private ArrowCastFixedSizeNode castToFixedPhysicalLayout = ArrowCastFixedSizeNode.create();
-
   public static ArrowEvalNode create(ArrowLanguage language, ArrowParser.Result code) {
     return new ArrowEvalNode(language, code);
   }
@@ -25,8 +25,13 @@ private ArrowEvalNode(ArrowLanguage language, ArrowParser.Result code) {
   public Object execute(VirtualFrame frame) {
     return switch (code.physicalLayout()) {
       case Primitive -> switch (code.mode()) {
-        case Allocate -> fixedPhysicalLayout.execute(code.logicalLayout());
-        case Cast -> castToFixedPhysicalLayout.execute(code.logicalLayout());
+        case Allocate -> new ArrowFixedSizeArrayFactory(code.logicalLayout());
+        case Cast -> new ArrowCastToFixedSizeArrayFactory(code.logicalLayout());
+        case Plus -> {
+          var factory = new ArrowFixedSizeArrayFactory(code.logicalLayout());
+          yield new ArrowOperationPlus(factory);
+        }
+        default -> throw CompilerDirectives.shouldNotReachHere("unsupported mode");
       };
       default -> throw CompilerDirectives.shouldNotReachHere("unsupported physical layout");
     };

engine/runtime-language-arrow/src/main/java/org/enso/interpreter/arrow/runtime/ArrowFixedSizeArrayFactory.java

@@ -14,7 +14,7 @@
 import org.enso.interpreter.arrow.LogicalLayout;
 
 @ExportLibrary(InteropLibrary.class)
-public class ArrowFixedSizeArrayFactory implements TruffleObject {
+public final class ArrowFixedSizeArrayFactory implements TruffleObject {
 
   private final LogicalLayout logicalLayout;
 

engine/runtime-language-arrow/src/main/java/org/enso/interpreter/arrow/runtime/ArrowOperationPlus.java

@@ -0,0 +1,61 @@
+package org.enso.interpreter.arrow.runtime;
+
+import com.oracle.truffle.api.interop.ArityException;
+import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.InvalidArrayIndexException;
+import com.oracle.truffle.api.interop.TruffleObject;
+import com.oracle.truffle.api.interop.UnknownIdentifierException;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
+import com.oracle.truffle.api.interop.UnsupportedTypeException;
+import com.oracle.truffle.api.library.CachedLibrary;
+import com.oracle.truffle.api.library.ExportLibrary;
+import com.oracle.truffle.api.library.ExportMessage;
+
+@ExportLibrary(InteropLibrary.class)
+public final class ArrowOperationPlus implements TruffleObject {
+  private final ArrowFixedSizeArrayFactory factory;
+
+  public ArrowOperationPlus(ArrowFixedSizeArrayFactory factory) {
+    this.factory = factory;
+  }
+
+  @ExportMessage
+  boolean isExecutable() {
+    return true;
+  }
+
+  @ExportMessage
+  Object execute(Object[] args, @CachedLibrary(limit = "3") InteropLibrary iop)
+      throws ArityException, UnsupportedTypeException, UnsupportedMessageException {
+    if (args.length != 2) {
+      throw ArityException.create(2, 2, args.length);
+    }
+    var arr0 = args[0];
+    var arr1 = args[1];
+    if (!iop.hasArrayElements(arr0) || !iop.hasArrayElements(arr1)) {
+      throw UnsupportedTypeException.create(args);
+    }
+    var len = iop.getArraySize(arr0);
+    if (len != iop.getArraySize(arr1)) {
+      throw UnsupportedTypeException.create(args, "Arrays must have the same length");
+    }
+    var builder = iop.instantiate(factory, len);
+    try {
+      for (long i = 0; i < len; i++) {
+        var elem0 = iop.readArrayElement(arr0, i);
+        var elem1 = iop.readArrayElement(arr1, i);
+        var l0 = iop.asLong(elem0);
+        var l1 = iop.asLong(elem1);
+        iop.invokeMember(builder, "append", l0 + l1);
+      }
+      return iop.invokeMember(builder, "build");
+    } catch (InvalidArrayIndexException | UnknownIdentifierException ex) {
+      throw raise(RuntimeException.class, ex);
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private static <E extends Throwable> E raise(Class<E> type, Throwable t) throws E {
+    throw (E) t;
+  }
+}

engine/runtime-language-arrow/src/test/java/org/enso/interpreter/arrow/AddArrowTest.java

@@ -0,0 +1,71 @@
+package org.enso.interpreter.arrow;
+
+import static org.junit.Assert.*;
+
+import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.io.IOAccess;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class AddArrowTest {
+  private static Context ctx;
+
+  @BeforeClass
+  public static void initEnsoContext() {
+    ctx =
+        Context.newBuilder()
+            .allowExperimentalOptions(true)
+            .allowIO(IOAccess.ALL)
+            .out(System.out)
+            .err(System.err)
+            .allowAllAccess(true)
+            .build();
+  }
+
+  @AfterClass
+  public static void closeEnsoContext() throws Exception {
+    if (ctx != null) {
+      ctx.close();
+    }
+  }
+
+  @Test
+  public void addTwoInt8ArrowArrays() {
+    var arrow = ctx.getEngine().getLanguages().get("arrow");
+    assertNotNull("Arrow is available", arrow);
+    var int8Constr = ctx.eval("arrow", "new[Int8]");
+    assertNotNull(int8Constr);
+
+    var arrLength = 10;
+    var builder1 = int8Constr.newInstance(arrLength);
+    var builder2 = int8Constr.newInstance(arrLength);
+
+    for (var i = 0; i < arrLength; i++) {
+      var ni = arrLength - i - 1;
+      var v = i * i;
+      builder1.invokeMember("append", i, (byte) v);
+      builder2.invokeMember("append", ni, (byte) v);
+    }
+
+    var arr1 = builder1.invokeMember("build");
+    assertEquals("Right size of arr1", arrLength, arr1.getArraySize());
+    var arr2 = builder2.invokeMember("build");
+    assertEquals("Right size of arr2", arrLength, arr2.getArraySize());
+
+    var int8Plus = ctx.eval("arrow", "+[Int8]");
+    var resultArr = int8Plus.execute(arr1, arr2);
+
+    assertTrue("Result is an array", resultArr.hasArrayElements());
+    assertEquals("Right size", arrLength, resultArr.getArraySize());
+
+    for (var i = 0; i < arrLength; i++) {
+      var ni = arrLength - i - 1;
+      var v1 = resultArr.getArrayElement(i).asInt();
+      var v2 = resultArr.getArrayElement(ni).asInt();
+
+      assertEquals("Values at " + i + " and " + ni + " are the same", v1, v2);
+      assertTrue("Values are always bigger than zero: " + v1, v1 > 0);
+    }
+  }
+}