From 7200ada98e6d5be895479be80b6b08eb9175143b Mon Sep 17 00:00:00 2001
From: Lukas Stadler <lukas.stadler@oracle.com>
Date: Wed, 15 Nov 2017 16:46:08 +0100
Subject: [PATCH] add VectorAccess pattern for efficient access to vectors and
implement it for all data types
---
.../oracle/truffle/r/runtime/RRuntime.java | 4 +
.../com/oracle/truffle/r/runtime/RType.java | 14 +
.../r/runtime/data/NativeDataAccess.java | 44 +-
.../truffle/r/runtime/data/RComplex.java | 59 ++
.../r/runtime/data/RComplexVector.java | 84 ++-
.../truffle/r/runtime/data/RDouble.java | 35 +
.../r/runtime/data/RDoubleSequence.java | 37 +
.../truffle/r/runtime/data/RDoubleVector.java | 58 +-
.../truffle/r/runtime/data/RExpression.java | 53 ++
.../truffle/r/runtime/data/RExternalPtr.java | 2 +-
.../truffle/r/runtime/data/RFactor.java | 5 +-
.../truffle/r/runtime/data/RIntSequence.java | 37 +
.../truffle/r/runtime/data/RIntVector.java | 58 +-
.../truffle/r/runtime/data/RInteger.java | 35 +
.../truffle/r/runtime/data/RLanguage.java | 49 ++
.../oracle/truffle/r/runtime/data/RList.java | 54 ++
.../truffle/r/runtime/data/RListBase.java | 6 -
.../truffle/r/runtime/data/RLogical.java | 35 +
.../r/runtime/data/RLogicalVector.java | 58 +-
.../truffle/r/runtime/data/RPairList.java | 49 ++
.../oracle/truffle/r/runtime/data/RRaw.java | 35 +
.../truffle/r/runtime/data/RRawVector.java | 65 +-
.../truffle/r/runtime/data/RScalarList.java | 45 ++
.../truffle/r/runtime/data/RScalarVector.java | 5 +
.../truffle/r/runtime/data/RSequence.java | 5 +
.../truffle/r/runtime/data/RString.java | 35 +
.../r/runtime/data/RStringSequence.java | 37 +
.../truffle/r/runtime/data/RStringVector.java | 54 +-
.../truffle/r/runtime/data/RVector.java | 31 +-
.../data/closures/RToVectorClosure.java | 16 +-
.../data/model/RAbstractComplexVector.java | 4 -
.../data/model/RAbstractContainer.java | 12 +-
.../data/model/RAbstractRawVector.java | 4 -
.../data/nodes/FastPathVectorAccess.java | 635 ++++++++++++++++++
.../data/nodes/SlowPathVectorAccess.java | 606 +++++++++++++++++
.../r/runtime/data/nodes/VectorAccess.java | 501 ++++++++++++++
.../interop/TruffleObjectConverter.java | 17 +-
.../truffle/r/runtime/ops/na/NACheck.java | 11 +
38 files changed, 2806 insertions(+), 88 deletions(-)
create mode 100644 com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/FastPathVectorAccess.java
create mode 100644 com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/SlowPathVectorAccess.java
create mode 100644 com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/VectorAccess.java
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RRuntime.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RRuntime.java
index d3965fab24..ddba79ddb2 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RRuntime.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RRuntime.java
@@ -762,6 +762,10 @@ public class RRuntime {
return isNA(value.getRealPart()) || isNA(value.getImaginaryPart());
}
+ public static boolean isNA(double real, double imag) {
+ return isNA(real) || isNA(imag);
+ }
+
@TruffleBoundary
public static String escapeString(String value, boolean encodeNonASCII, boolean quote) {
if (isNA(value)) {
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RType.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RType.java
index 58096f6025..ccd1f53dc1 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RType.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RType.java
@@ -96,6 +96,20 @@ public enum RType {
}
}
+ public boolean isAtomic() {
+ switch (this) {
+ case Logical:
+ case Double:
+ case Integer:
+ case Complex:
+ case Character:
+ case Raw:
+ return true;
+ default:
+ return false;
+ }
+ }
+
public boolean isVector() {
switch (this) {
case Logical:
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/NativeDataAccess.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/NativeDataAccess.java
index efe8ee17d0..ab9c0f0439 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/NativeDataAccess.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/NativeDataAccess.java
@@ -314,21 +314,35 @@ public final class NativeDataAccess {
UnsafeAdapter.UNSAFE.getDouble(address + (index * 2 + 1) * Unsafe.ARRAY_DOUBLE_INDEX_SCALE));
}
- public static void setNativeMirrorData(Object nativeMirror, int index, double value) {
+ public static double getComplexNativeMirrorDataR(Object nativeMirror, int index) {
+ long address = ((NativeMirror) nativeMirror).dataAddress;
+ assert address != 0;
+ assert index < ((NativeMirror) nativeMirror).length;
+ return UnsafeAdapter.UNSAFE.getDouble(address + index * 2 * Unsafe.ARRAY_DOUBLE_INDEX_SCALE);
+ }
+
+ public static double getComplexNativeMirrorDataI(Object nativeMirror, int index) {
+ long address = ((NativeMirror) nativeMirror).dataAddress;
+ assert address != 0;
+ assert index < ((NativeMirror) nativeMirror).length;
+ return UnsafeAdapter.UNSAFE.getDouble(address + (index * 2 + 1) * Unsafe.ARRAY_DOUBLE_INDEX_SCALE);
+ }
+
+ public static void setNativeMirrorDoubleData(Object nativeMirror, int index, double value) {
long address = ((NativeMirror) nativeMirror).dataAddress;
assert address != 0;
assert index < ((NativeMirror) nativeMirror).length;
UnsafeAdapter.UNSAFE.putDouble(address + index * Unsafe.ARRAY_DOUBLE_INDEX_SCALE, value);
}
- public static void setNativeMirrorData(Object nativeMirror, int index, byte value) {
+ public static void setNativeMirrorRawData(Object nativeMirror, int index, byte value) {
long address = ((NativeMirror) nativeMirror).dataAddress;
assert address != 0;
assert index < ((NativeMirror) nativeMirror).length;
UnsafeAdapter.UNSAFE.putByte(address + index * Unsafe.ARRAY_BYTE_INDEX_SCALE, value);
}
- public static void setNativeMirrorData(Object nativeMirror, int index, int value) {
+ public static void setNativeMirrorIntData(Object nativeMirror, int index, int value) {
long address = ((NativeMirror) nativeMirror).dataAddress;
assert address != 0;
assert index < ((NativeMirror) nativeMirror).length;
@@ -390,10 +404,14 @@ public final class NativeDataAccess {
if (noIntNative.isValid() || data != null) {
return data.length;
} else {
- return (int) ((NativeMirror) vector.getNativeMirror()).length;
+ return getDataLengthFromMirror(vector.getNativeMirror());
}
}
+ static int getDataLengthFromMirror(Object mirror) {
+ return (int) ((NativeMirror) mirror).length;
+ }
+
static void setData(RIntVector vector, int[] data, int index, int value) {
if (noIntNative.isValid() || data != null) {
data[index] = value;
@@ -478,7 +496,7 @@ public final class NativeDataAccess {
if (noDoubleNative.isValid() || data != null) {
data[index] = value;
} else {
- setNativeMirrorData(vector.getNativeMirror(), index, value);
+ setNativeMirrorDoubleData(vector.getNativeMirror(), index, value);
}
}
@@ -490,6 +508,22 @@ public final class NativeDataAccess {
}
}
+ static double getDataR(RComplexVector vector, double[] data, int index) {
+ if (noComplexNative.isValid() || data != null) {
+ return data[index * 2];
+ } else {
+ return getComplexNativeMirrorDataR(vector.getNativeMirror(), index);
+ }
+ }
+
+ static double getDataI(RComplexVector vector, double[] data, int index) {
+ if (noComplexNative.isValid() || data != null) {
+ return data[index * 2 + 1];
+ } else {
+ return getComplexNativeMirrorDataI(vector.getNativeMirror(), index);
+ }
+ }
+
static int getDataLength(RComplexVector vector, double[] data) {
if (noComplexNative.isValid() || data != null) {
return data.length >> 1;
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RComplex.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RComplex.java
index af6a3028bc..367c91a771 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RComplex.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RComplex.java
@@ -30,7 +30,11 @@ import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.context.RContext;
import com.oracle.truffle.r.runtime.data.model.RAbstractComplexVector;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromComplexAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromComplexAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
@ValueType
public final class RComplex extends RScalarVector implements RAbstractComplexVector {
@@ -143,4 +147,59 @@ public final class RComplex extends RScalarVector implements RAbstractComplexVec
return Math.sqrt(re * re + im * im);
}
}
+
+ private static final class FastPathAccess extends FastPathFromComplexAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected RComplex getComplex(Object store, int index) {
+ assert index == 0;
+ return (RComplex) store;
+ }
+
+ @Override
+ protected double getComplexR(Object store, int index) {
+ assert index == 0;
+ return ((RComplex) store).realPart;
+ }
+
+ @Override
+ protected double getComplexI(Object store, int index) {
+ assert index == 0;
+ return ((RComplex) store).imaginaryPart;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromComplexAccess SLOW_PATH_ACCESS = new SlowPathFromComplexAccess() {
+ @Override
+ protected RComplex getComplex(Object store, int index) {
+ assert index == 0;
+ return (RComplex) store;
+ }
+
+ @Override
+ protected double getComplexR(Object store, int index) {
+ assert index == 0;
+ return ((RComplex) store).realPart;
+ }
+
+ @Override
+ protected double getComplexI(Object store, int index) {
+ assert index == 0;
+ return ((RComplex) store).imaginaryPart;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RComplexVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RComplexVector.java
index a3cedbc005..b6ebdd2696 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RComplexVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RComplexVector.java
@@ -30,7 +30,11 @@ import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.Utils;
import com.oracle.truffle.r.runtime.data.closures.RClosures;
import com.oracle.truffle.r.runtime.data.model.RAbstractComplexVector;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromComplexAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromComplexAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
import com.oracle.truffle.r.runtime.ops.na.NACheck;
public final class RComplexVector extends RVector<double[]> implements RAbstractComplexVector {
@@ -104,10 +108,8 @@ public final class RComplexVector extends RVector<double[]> implements RAbstract
NativeDataAccess.setData(this, (double[]) store, index, value.getRealPart(), value.getImaginaryPart());
}
- @Override
- public RComplex getDataAt(Object store, int index) {
- assert data == store;
- return NativeDataAccess.getData(this, (double[]) store, index);
+ public void setDataAt(int index, RComplex value) {
+ NativeDataAccess.setData(this, data, index, value.getRealPart(), value.getImaginaryPart());
}
@Override
@@ -115,11 +117,6 @@ public final class RComplexVector extends RVector<double[]> implements RAbstract
return NativeDataAccess.getData(this, data, index);
}
- @Override
- public String toString() {
- return toString(i -> getDataAt(i).toString());
- }
-
@Override
public boolean verify() {
if (isComplete()) {
@@ -219,4 +216,73 @@ public final class RComplexVector extends RVector<double[]> implements RAbstract
complete = false;
}
}
+
+ private static final class FastPathAccess extends FastPathFromComplexAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected RComplex getComplex(Object store, int index) {
+ return RComplex.valueOf(getComplexR(store, index), getComplexI(store, index));
+ }
+
+ @Override
+ protected double getComplexR(Object store, int index) {
+ return hasStore ? ((double[]) store)[index * 2] : NativeDataAccess.getDoubleNativeMirrorData(store, index * 2);
+ }
+
+ @Override
+ protected double getComplexI(Object store, int index) {
+ return hasStore ? ((double[]) store)[index * 2 + 1] : NativeDataAccess.getDoubleNativeMirrorData(store, index * 2 + 1);
+ }
+
+ @Override
+ protected void setComplex(Object store, int index, double real, double imaginary) {
+ if (hasStore) {
+ ((double[]) store)[index * 2] = real;
+ ((double[]) store)[index * 2 + 1] = imaginary;
+ } else {
+ NativeDataAccess.setNativeMirrorDoubleData(store, index * 2, real);
+ NativeDataAccess.setNativeMirrorDoubleData(store, index * 2 + 1, imaginary);
+ }
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromComplexAccess SLOW_PATH_ACCESS = new SlowPathFromComplexAccess() {
+ @Override
+ protected RComplex getComplex(Object store, int index) {
+ RComplexVector vector = (RComplexVector) store;
+ return NativeDataAccess.getData(vector, vector.data, index);
+ }
+
+ @Override
+ protected double getComplexR(Object store, int index) {
+ RComplexVector vector = (RComplexVector) store;
+ return NativeDataAccess.getDataR(vector, vector.data, index);
+ }
+
+ @Override
+ protected double getComplexI(Object store, int index) {
+ RComplexVector vector = (RComplexVector) store;
+ return NativeDataAccess.getDataI(vector, vector.data, index);
+ }
+
+ @Override
+ protected void setComplex(Object store, int index, double real, double imaginary) {
+ RComplexVector vector = (RComplexVector) store;
+ NativeDataAccess.setData(vector, vector.data, index, real, imaginary);
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDouble.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDouble.java
index 6a66889e9c..c0eff99975 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDouble.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDouble.java
@@ -28,8 +28,12 @@ import com.oracle.truffle.api.profiles.ConditionProfile;
import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.context.RContext;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractDoubleVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromDoubleAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromDoubleAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
@ValueType
public final class RDouble extends RScalarVector implements RAbstractDoubleVector {
@@ -99,4 +103,35 @@ public final class RDouble extends RScalarVector implements RAbstractDoubleVecto
public boolean isNA() {
return RRuntime.isNA(getValue());
}
+
+ private static final class FastPathAccess extends FastPathFromDoubleAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected double getDouble(Object store, int index) {
+ assert index == 0;
+ return ((RDouble) store).value;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromDoubleAccess SLOW_PATH_ACCESS = new SlowPathFromDoubleAccess() {
+ @Override
+ protected double getDouble(Object store, int index) {
+ assert index == 0;
+ return ((RDouble) store).value;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDoubleSequence.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDoubleSequence.java
index a94cce37d0..5d0ca6da84 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDoubleSequence.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDoubleSequence.java
@@ -26,8 +26,12 @@ import com.oracle.truffle.api.CompilerAsserts;
import com.oracle.truffle.api.profiles.ConditionProfile;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.data.closures.RClosures;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractDoubleVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromDoubleAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromDoubleAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
public final class RDoubleSequence extends RSequence implements RAbstractDoubleVector {
@@ -134,4 +138,37 @@ public final class RDoubleSequence extends RSequence implements RAbstractDoubleV
CompilerAsserts.neverPartOfCompilation();
return "[" + start + " - " + getEnd() + "]";
}
+
+ private static final class FastPathAccess extends FastPathFromDoubleAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected double getDouble(Object store, int index) {
+ RDoubleSequence vector = (RDoubleSequence) store;
+ assert index >= 0 && index < vector.getLength();
+ return vector.start + vector.stride * index;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromDoubleAccess SLOW_PATH_ACCESS = new SlowPathFromDoubleAccess() {
+ @Override
+ protected double getDouble(Object store, int index) {
+ RDoubleSequence vector = (RDoubleSequence) store;
+ assert index >= 0 && index < vector.getLength();
+ return vector.start + vector.stride * index;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDoubleVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDoubleVector.java
index cc84373f42..197d34d214 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDoubleVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RDoubleVector.java
@@ -29,8 +29,12 @@ import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.Utils;
import com.oracle.truffle.r.runtime.data.closures.RClosures;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractDoubleVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromDoubleAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromDoubleAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
import com.oracle.truffle.r.runtime.ops.na.NACheck;
public final class RDoubleVector extends RVector<double[]> implements RAbstractDoubleVector {
@@ -99,6 +103,10 @@ public final class RDoubleVector extends RVector<double[]> implements RAbstractD
NativeDataAccess.setData(this, (double[]) store, index, value);
}
+ public void setDataAt(int index, double value) {
+ NativeDataAccess.setData(this, data, index, value);
+ }
+
@Override
public double getDataAt(Object store, int index) {
assert data == store;
@@ -123,11 +131,6 @@ public final class RDoubleVector extends RVector<double[]> implements RAbstractD
return NativeDataAccess.getDataLength(this, data);
}
- @Override
- public String toString() {
- return toString(i -> Double.toString(getDataAt(i)));
- }
-
@Override
public boolean verify() {
if (isComplete()) {
@@ -238,4 +241,49 @@ public final class RDoubleVector extends RVector<double[]> implements RAbstractD
complete = false;
}
}
+
+ private static final class FastPathAccess extends FastPathFromDoubleAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected double getDouble(Object store, int index) {
+ return hasStore ? ((double[]) store)[index] : NativeDataAccess.getDoubleNativeMirrorData(store, index);
+ }
+
+ @Override
+ protected void setDouble(Object store, int index, double value) {
+ if (hasStore) {
+ ((double[]) store)[index] = value;
+ } else {
+ NativeDataAccess.setNativeMirrorDoubleData(store, index, value);
+ }
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromDoubleAccess SLOW_PATH_ACCESS = new SlowPathFromDoubleAccess() {
+ @Override
+ protected double getDouble(Object store, int index) {
+ RDoubleVector vector = (RDoubleVector) store;
+ return NativeDataAccess.getData(vector, vector.data, index);
+ }
+
+ @Override
+ protected void setDouble(Object store, int index, double value) {
+ RDoubleVector vector = (RDoubleVector) store;
+ NativeDataAccess.setData(vector, vector.data, index, value);
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RExpression.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RExpression.java
index f30f71ef14..1c9e240c9a 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RExpression.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RExpression.java
@@ -26,7 +26,11 @@ import java.util.Arrays;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
public final class RExpression extends RListBase implements RAbstractVector {
@@ -84,4 +88,53 @@ public final class RExpression extends RListBase implements RAbstractVector {
protected RExpression internalCopyResized(int size, boolean fillNA, int[] dimensions) {
return RDataFactory.createExpression(copyResizedData(size, fillNA), dimensions);
}
+
+ private static final class FastPathAccess extends FastPathFromListAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public RType getType() {
+ return RType.Expression;
+ }
+
+ @Override
+ protected Object getListElement(Object store, int index) {
+ return ((Object[]) store)[index];
+ }
+
+ @Override
+ protected void setListElement(Object store, int index, Object value) {
+ ((Object[]) store)[index] = value;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromListAccess SLOW_PATH_ACCESS = new SlowPathFromListAccess() {
+ @Override
+ public RType getType() {
+ return RType.Expression;
+ }
+
+ @Override
+ protected Object getListElement(Object store, int index) {
+ return ((RExpression) store).data[index];
+ }
+
+ @Override
+ protected void setListElement(Object store, int index, Object value) {
+ ((RExpression) store).data[index] = value;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RExternalPtr.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RExternalPtr.java
index 57aa7933b9..fa03686af9 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RExternalPtr.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RExternalPtr.java
@@ -28,7 +28,7 @@ import com.oracle.truffle.r.runtime.ffi.DLL.SymbolHandle;
/**
* The rarely seen {@code externalptr} type used in native code.
*/
-public class RExternalPtr extends RAttributeStorage implements RTypedValue {
+public final class RExternalPtr extends RAttributeStorage implements RTypedValue {
/**
* In GNU R, typically the address of some C structure, so a {@code void*}. Represented here as
* our abstraction of a "native symbol" (even though there may not actually be a symbol
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RFactor.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RFactor.java
index 3d0746749a..cbda3db37f 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RFactor.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RFactor.java
@@ -36,10 +36,7 @@ public final class RFactor {
* be replaced with FactorNodes.GetLevel in the future.
*/
public static RVector<?> getLevels(RAbstractIntVector factor) {
- return getLevelsImpl(factor.getAttr(RRuntime.LEVELS_ATTR_KEY));
- }
-
- private static RVector<?> getLevelsImpl(Object attr) {
+ Object attr = factor.getAttr(RRuntime.LEVELS_ATTR_KEY);
// convert scalar to RVector<?>if necessary
return attr instanceof RVector ? (RVector<?>) attr : (RVector<?>) RRuntime.asAbstractVector(attr);
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RIntSequence.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RIntSequence.java
index c0e25112c7..5182f8cba1 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RIntSequence.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RIntSequence.java
@@ -26,8 +26,12 @@ import com.oracle.truffle.api.CompilerAsserts;
import com.oracle.truffle.api.profiles.ConditionProfile;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.data.closures.RClosures;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractIntVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromIntAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromIntAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
public final class RIntSequence extends RSequence implements RAbstractIntVector {
@@ -143,4 +147,37 @@ public final class RIntSequence extends RSequence implements RAbstractIntVector
public RIntVector createEmptySameType(int newLength, boolean newIsComplete) {
return RDataFactory.createIntVector(new int[newLength], newIsComplete);
}
+
+ private static final class FastPathAccess extends FastPathFromIntAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected int getInt(Object store, int index) {
+ RIntSequence vector = (RIntSequence) store;
+ assert index >= 0 && index < vector.getLength();
+ return vector.start + vector.stride * index;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromIntAccess SLOW_PATH_ACCESS = new SlowPathFromIntAccess() {
+ @Override
+ protected int getInt(Object store, int index) {
+ RIntSequence vector = (RIntSequence) store;
+ assert index >= 0 && index < vector.getLength();
+ return vector.start + vector.stride * index;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RIntVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RIntVector.java
index f52c7cb614..450619ae32 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RIntVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RIntVector.java
@@ -29,8 +29,12 @@ import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.Utils;
import com.oracle.truffle.r.runtime.data.closures.RClosures;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractIntVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromIntAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromIntAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
import com.oracle.truffle.r.runtime.ops.na.NACheck;
public final class RIntVector extends RVector<int[]> implements RAbstractIntVector {
@@ -99,6 +103,10 @@ public final class RIntVector extends RVector<int[]> implements RAbstractIntVect
NativeDataAccess.setData(this, (int[]) store, index, value);
}
+ public void setDataAt(int index, int value) {
+ NativeDataAccess.setData(this, data, index, value);
+ }
+
@Override
protected RIntVector internalCopy() {
if (data != null) {
@@ -126,11 +134,6 @@ public final class RIntVector extends RVector<int[]> implements RAbstractIntVect
return NativeDataAccess.getDataLength(this, data);
}
- @Override
- public String toString() {
- return toString(i -> Double.toString(getDataAt(i)));
- }
-
@Override
public boolean verify() {
if (isComplete()) {
@@ -246,4 +249,49 @@ public final class RIntVector extends RVector<int[]> implements RAbstractIntVect
complete = false;
}
}
+
+ private static final class FastPathAccess extends FastPathFromIntAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected int getInt(Object store, int index) {
+ return hasStore ? ((int[]) store)[index] : NativeDataAccess.getIntNativeMirrorData(store, index);
+ }
+
+ @Override
+ protected void setInt(Object store, int index, int value) {
+ if (hasStore) {
+ ((int[]) store)[index] = value;
+ } else {
+ NativeDataAccess.setNativeMirrorIntData(store, index, value);
+ }
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromIntAccess SLOW_PATH_ACCESS = new SlowPathFromIntAccess() {
+ @Override
+ protected int getInt(Object store, int index) {
+ RIntVector vector = (RIntVector) store;
+ return NativeDataAccess.getData(vector, vector.data, index);
+ }
+
+ @Override
+ protected void setInt(Object store, int index, int value) {
+ RIntVector vector = (RIntVector) store;
+ NativeDataAccess.setData(vector, vector.data, index, value);
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RInteger.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RInteger.java
index eb0ea1f399..0eed431c3a 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RInteger.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RInteger.java
@@ -26,8 +26,12 @@ import com.oracle.truffle.api.CompilerDirectives.ValueType;
import com.oracle.truffle.api.profiles.ConditionProfile;
import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractIntVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromIntAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromIntAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
@ValueType
public final class RInteger extends RScalarVector implements RAbstractIntVector {
@@ -95,4 +99,35 @@ public final class RInteger extends RScalarVector implements RAbstractIntVector
public boolean isNA() {
return RRuntime.isNA(value);
}
+
+ private static final class FastPathAccess extends FastPathFromIntAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected int getInt(Object store, int index) {
+ assert index == 0;
+ return ((RInteger) store).value;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromIntAccess SLOW_PATH_ACCESS = new SlowPathFromIntAccess() {
+ @Override
+ protected int getInt(Object store, int index) {
+ assert index == 0;
+ return ((RInteger) store).value;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLanguage.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLanguage.java
index 7fa8714d7a..43c77e0ca5 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLanguage.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLanguage.java
@@ -30,6 +30,9 @@ import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.context.RContext;
import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
import com.oracle.truffle.r.runtime.nodes.RBaseNode;
/**
@@ -76,6 +79,11 @@ public final class RLanguage extends RSharingAttributeStorage implements RAbstra
this.length = length;
}
+ @Override
+ public Object getInternalStore() {
+ return this;
+ }
+
@TruffleBoundary
public static Object fromList(Object o, RLanguage.RepType type) {
RList l;
@@ -276,4 +284,45 @@ public final class RLanguage extends RSharingAttributeStorage implements RAbstra
private void setNamesOnPairList(RStringVector names) {
list.setNames(names);
}
+
+ private static final class FastPathAccess extends FastPathFromListAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public RType getType() {
+ return RType.Language;
+ }
+
+ @TruffleBoundary
+ @Override
+ protected Object getListElement(Object store, int index) {
+ return ((RLanguage) store).getDataAtAsObject(index);
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromListAccess SLOW_PATH_ACCESS = new SlowPathFromListAccess() {
+ @Override
+ public RType getType() {
+ return RType.Language;
+ }
+
+ @TruffleBoundary
+ @Override
+ protected Object getListElement(Object store, int index) {
+ return ((RLanguage) store).getDataAtAsObject(index);
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RList.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RList.java
index 650c2f1173..ee3847e78b 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RList.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RList.java
@@ -25,7 +25,12 @@ package com.oracle.truffle.r.runtime.data;
import java.util.Arrays;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractListVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
public final class RList extends RListBase implements RAbstractListVector {
@@ -83,4 +88,53 @@ public final class RList extends RListBase implements RAbstractListVector {
protected RList internalCopyResized(int size, boolean fillNA, int[] dimensions) {
return RDataFactory.createList(copyResizedData(size, fillNA), dimensions);
}
+
+ private static final class FastPathAccess extends FastPathFromListAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public RType getType() {
+ return RType.List;
+ }
+
+ @Override
+ protected Object getListElement(Object store, int index) {
+ return ((Object[]) store)[index];
+ }
+
+ @Override
+ protected void setListElement(Object store, int index, Object value) {
+ ((Object[]) store)[index] = value;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromListAccess SLOW_PATH_ACCESS = new SlowPathFromListAccess() {
+ @Override
+ public RType getType() {
+ return RType.List;
+ }
+
+ @Override
+ protected Object getListElement(Object store, int index) {
+ return ((RList) store).data[index];
+ }
+
+ @Override
+ protected void setListElement(Object store, int index, Object value) {
+ ((RList) store).data[index] = value;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RListBase.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RListBase.java
index 4538d1a4ee..504c6d4173 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RListBase.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RListBase.java
@@ -24,7 +24,6 @@ package com.oracle.truffle.r.runtime.data;
import java.util.Arrays;
-import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.Utils;
import com.oracle.truffle.r.runtime.data.model.RAbstractListBaseVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractListVector;
@@ -94,11 +93,6 @@ public abstract class RListBase extends RVector<Object[]> implements RAbstractLi
((Object[]) store)[index] = value;
}
- @Override
- public String toString() {
- return toString(i -> RRuntime.toString(getDataAt(i)));
- }
-
@Override
public final boolean verify() {
for (Object item : data) {
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLogical.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLogical.java
index 7fade92f1b..c65961c55e 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLogical.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLogical.java
@@ -26,8 +26,12 @@ import com.oracle.truffle.api.CompilerDirectives.ValueType;
import com.oracle.truffle.api.profiles.ConditionProfile;
import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractLogicalVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromLogicalAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromLogicalAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
@ValueType
public final class RLogical extends RScalarVector implements RAbstractLogicalVector {
@@ -105,4 +109,35 @@ public final class RLogical extends RScalarVector implements RAbstractLogicalVec
public static boolean isValid(byte left) {
return left == RRuntime.LOGICAL_NA || left == RRuntime.LOGICAL_FALSE || left == RRuntime.LOGICAL_TRUE;
}
+
+ private static final class FastPathAccess extends FastPathFromLogicalAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected byte getLogical(Object store, int index) {
+ assert index == 0;
+ return ((RLogical) store).value;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromLogicalAccess SLOW_PATH_ACCESS = new SlowPathFromLogicalAccess() {
+ @Override
+ protected byte getLogical(Object store, int index) {
+ assert index == 0;
+ return ((RLogical) store).value;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLogicalVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLogicalVector.java
index 1d5bcca090..048c4df3c3 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLogicalVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RLogicalVector.java
@@ -29,8 +29,12 @@ import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.Utils;
import com.oracle.truffle.r.runtime.data.closures.RClosures;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractLogicalVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromLogicalAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromLogicalAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
import com.oracle.truffle.r.runtime.ops.na.NACheck;
public final class RLogicalVector extends RVector<byte[]> implements RAbstractLogicalVector {
@@ -95,6 +99,10 @@ public final class RLogicalVector extends RVector<byte[]> implements RAbstractLo
NativeDataAccess.setData(this, (byte[]) store, index, value);
}
+ public void setDataAt(int index, byte value) {
+ NativeDataAccess.setData(this, data, index, value);
+ }
+
@Override
public byte getDataAt(Object store, int index) {
assert data == store;
@@ -128,11 +136,6 @@ public final class RLogicalVector extends RVector<byte[]> implements RAbstractLo
return NativeDataAccess.getDataLength(this, data);
}
- @Override
- public String toString() {
- return toString(i -> RRuntime.logicalToString(getDataAt(i)));
- }
-
@Override
public boolean verify() {
if (isComplete()) {
@@ -249,4 +252,49 @@ public final class RLogicalVector extends RVector<byte[]> implements RAbstractLo
}
return result;
}
+
+ private static final class FastPathAccess extends FastPathFromLogicalAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected byte getLogical(Object store, int index) {
+ return hasStore ? ((byte[]) store)[index] : NativeDataAccess.getLogicalNativeMirrorData(store, index);
+ }
+
+ @Override
+ protected void setLogical(Object store, int index, byte value) {
+ if (hasStore) {
+ ((byte[]) store)[index] = value;
+ } else {
+ NativeDataAccess.setNativeMirrorLogicalData(store, index, value);
+ }
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromLogicalAccess SLOW_PATH_ACCESS = new SlowPathFromLogicalAccess() {
+ @Override
+ protected byte getLogical(Object store, int index) {
+ RLogicalVector vector = (RLogicalVector) store;
+ return NativeDataAccess.getData(vector, vector.data, index);
+ }
+
+ @Override
+ protected void setLogical(Object store, int index, byte value) {
+ RLogicalVector vector = (RLogicalVector) store;
+ NativeDataAccess.setData(vector, vector.data, index, value);
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RPairList.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RPairList.java
index 18c853f56a..74765b994d 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RPairList.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RPairList.java
@@ -33,6 +33,9 @@ import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.Utils;
import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
import com.oracle.truffle.r.runtime.gnur.SEXPTYPE;
/**
@@ -73,6 +76,11 @@ public final class RPairList extends RSharingAttributeStorage implements RAbstra
this.type = type;
}
+ @Override
+ public Object getInternalStore() {
+ return this;
+ }
+
/**
* Creates a new pair list of given size > 0. Note: pair list of size 0 is NULL.
*/
@@ -375,4 +383,45 @@ public final class RPairList extends RSharingAttributeStorage implements RAbstra
}
};
}
+
+ private static final class FastPathAccess extends FastPathFromListAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public RType getType() {
+ return RType.PairList;
+ }
+
+ @TruffleBoundary
+ @Override
+ protected Object getListElement(Object store, int index) {
+ return ((RPairList) store).getDataAtAsObject(index);
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromListAccess SLOW_PATH_ACCESS = new SlowPathFromListAccess() {
+ @Override
+ public RType getType() {
+ return RType.PairList;
+ }
+
+ @TruffleBoundary
+ @Override
+ protected Object getListElement(Object store, int index) {
+ return ((RPairList) store).getDataAtAsObject(index);
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RRaw.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RRaw.java
index ff3e3945be..a99b64ca06 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RRaw.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RRaw.java
@@ -26,8 +26,12 @@ import com.oracle.truffle.api.CompilerDirectives.ValueType;
import com.oracle.truffle.api.profiles.ConditionProfile;
import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractRawVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromRawAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromRawAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
@ValueType
public final class RRaw extends RScalarVector implements RAbstractRawVector {
@@ -99,4 +103,35 @@ public final class RRaw extends RScalarVector implements RAbstractRawVector {
public static RRaw valueOf(byte value) {
return new RRaw(value);
}
+
+ private static final class FastPathAccess extends FastPathFromRawAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected byte getRaw(Object store, int index) {
+ assert index == 0;
+ return ((RRaw) store).value;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromRawAccess SLOW_PATH_ACCESS = new SlowPathFromRawAccess() {
+ @Override
+ protected byte getRaw(Object store, int index) {
+ assert index == 0;
+ return ((RRaw) store).value;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RRawVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RRawVector.java
index 97c9435c9d..d953368972 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RRawVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RRawVector.java
@@ -25,12 +25,15 @@ package com.oracle.truffle.r.runtime.data;
import java.util.Arrays;
import com.oracle.truffle.api.profiles.ConditionProfile;
-import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.Utils;
import com.oracle.truffle.r.runtime.data.closures.RClosures;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractRawVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromRawAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromRawAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
import com.oracle.truffle.r.runtime.ops.na.NACheck;
public final class RRawVector extends RVector<byte[]> implements RAbstractRawVector {
@@ -92,18 +95,16 @@ public final class RRawVector extends RVector<byte[]> implements RAbstractRawVec
return NativeDataAccess.getData(this, data, index);
}
- @Override
- public byte getRawDataAt(Object store, int index) {
- assert data == store;
- return NativeDataAccess.getData(this, (byte[]) store, index);
- }
-
@Override
public void setRawDataAt(Object store, int index, byte value) {
assert data == store;
NativeDataAccess.setData(this, (byte[]) store, index, value);
}
+ public void setRawDataAt(int index, byte value) {
+ NativeDataAccess.setData(this, data, index, value);
+ }
+
@Override
protected RRawVector internalCopy() {
if (data != null) {
@@ -118,11 +119,6 @@ public final class RRawVector extends RVector<byte[]> implements RAbstractRawVec
return NativeDataAccess.getDataLength(this, data);
}
- @Override
- public String toString() {
- return toString(i -> RRuntime.rawToString(getRawDataAt(i)));
- }
-
@Override
public boolean verify() {
return true;
@@ -202,4 +198,49 @@ public final class RRawVector extends RVector<byte[]> implements RAbstractRawVec
complete = false;
}
}
+
+ private static final class FastPathAccess extends FastPathFromRawAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected byte getRaw(Object store, int index) {
+ return hasStore ? ((byte[]) store)[index] : NativeDataAccess.getRawNativeMirrorData(store, index);
+ }
+
+ @Override
+ protected void setRaw(Object store, int index, byte value) {
+ if (hasStore) {
+ ((byte[]) store)[index] = value;
+ } else {
+ NativeDataAccess.setNativeMirrorRawData(store, index, value);
+ }
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromRawAccess SLOW_PATH_ACCESS = new SlowPathFromRawAccess() {
+ @Override
+ protected byte getRaw(Object store, int index) {
+ RRawVector vector = (RRawVector) store;
+ return NativeDataAccess.getData(vector, vector.data, index);
+ }
+
+ @Override
+ protected void setRaw(Object store, int index, byte value) {
+ RRawVector vector = (RRawVector) store;
+ NativeDataAccess.setData(vector, vector.data, index, value);
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RScalarList.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RScalarList.java
index 1ea23adc66..044cdffb58 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RScalarList.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RScalarList.java
@@ -25,8 +25,12 @@ package com.oracle.truffle.r.runtime.data;
import com.oracle.truffle.api.CompilerDirectives.ValueType;
import com.oracle.truffle.api.profiles.ConditionProfile;
import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractListVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromListAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
@ValueType
public final class RScalarList extends RScalarVector implements RAbstractListVector {
@@ -87,4 +91,45 @@ public final class RScalarList extends RScalarVector implements RAbstractListVec
public boolean isNA() {
return false;
}
+
+ private static final class FastPathAccess extends FastPathFromListAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public RType getType() {
+ return RType.List;
+ }
+
+ @Override
+ protected Object getListElement(Object store, int index) {
+ assert index == 0;
+ return ((RScalarList) store).value;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromListAccess SLOW_PATH_ACCESS = new SlowPathFromListAccess() {
+ @Override
+ public RType getType() {
+ return RType.List;
+ }
+
+ @Override
+ protected Object getListElement(Object store, int index) {
+ assert index == 0;
+ return ((RScalarList) store).value;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RScalarVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RScalarVector.java
index 80f1da3147..76ce7c6cfb 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RScalarVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RScalarVector.java
@@ -36,6 +36,11 @@ public abstract class RScalarVector extends RScalar implements RAbstractVector {
return this;
}
+ @Override
+ public Object getInternalStore() {
+ return this;
+ }
+
@Override
public void setComplete(boolean complete) {
// scalar vectors don't need this information.
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RSequence.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RSequence.java
index d9aa895489..8781775fad 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RSequence.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RSequence.java
@@ -41,6 +41,11 @@ public abstract class RSequence implements RAbstractVector {
this.length = length;
}
+ @Override
+ public Object getInternalStore() {
+ return this;
+ }
+
@Override
public final int getLength() {
return length;
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RString.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RString.java
index abf51a343f..2929ffb79f 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RString.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RString.java
@@ -27,8 +27,12 @@ import com.oracle.truffle.api.CompilerDirectives.ValueType;
import com.oracle.truffle.api.profiles.ConditionProfile;
import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractStringVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromStringAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromStringAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
@ValueType
public final class RString extends RScalarVector implements RAbstractStringVector {
@@ -95,4 +99,35 @@ public final class RString extends RScalarVector implements RAbstractStringVecto
throw new AssertionError();
}
}
+
+ private static final class FastPathAccess extends FastPathFromStringAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected String getString(Object store, int index) {
+ assert index == 0;
+ return ((RString) store).value;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromStringAccess SLOW_PATH_ACCESS = new SlowPathFromStringAccess() {
+ @Override
+ protected String getString(Object store, int index) {
+ assert index == 0;
+ return ((RString) store).value;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RStringSequence.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RStringSequence.java
index 1b90cafe41..220df12974 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RStringSequence.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RStringSequence.java
@@ -29,8 +29,12 @@ import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.Utils;
import com.oracle.truffle.r.runtime.data.closures.RClosures;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractStringVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromStringAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromStringAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
public final class RStringSequence extends RSequence implements RAbstractStringVector {
@@ -168,4 +172,37 @@ public final class RStringSequence extends RSequence implements RAbstractStringV
CompilerAsserts.neverPartOfCompilation();
return "[\"" + getStartObject() + "\" - \"" + prefix + getEnd() + suffix + "\"]";
}
+
+ private static final class FastPathAccess extends FastPathFromStringAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected String getString(Object store, int index) {
+ RStringSequence vector = (RStringSequence) store;
+ assert index >= 0 && index < vector.getLength();
+ return vector.prefix + (vector.start + vector.stride * index) + vector.suffix;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromStringAccess SLOW_PATH_ACCESS = new SlowPathFromStringAccess() {
+ @Override
+ protected String getString(Object store, int index) {
+ RStringSequence vector = (RStringSequence) store;
+ assert index >= 0 && index < vector.getLength();
+ return vector.prefix + (vector.start + vector.stride * index) + vector.suffix;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RStringVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RStringVector.java
index 4a0374063a..682431c382 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RStringVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RStringVector.java
@@ -30,8 +30,12 @@ import com.oracle.truffle.r.runtime.RRuntime;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.Utils;
import com.oracle.truffle.r.runtime.data.closures.RClosures;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractStringVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.FastPathVectorAccess.FastPathFromStringAccess;
+import com.oracle.truffle.r.runtime.data.nodes.SlowPathVectorAccess.SlowPathFromStringAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
import com.oracle.truffle.r.runtime.ops.na.NACheck;
public final class RStringVector extends RVector<String[]> implements RAbstractStringVector {
@@ -78,6 +82,10 @@ public final class RStringVector extends RVector<String[]> implements RAbstractS
((String[]) store)[index] = value;
}
+ public void setDataAt(int index, String value) {
+ data[index] = value;
+ }
+
@Override
public String getDataAt(Object store, int index) {
assert data == store;
@@ -119,11 +127,6 @@ public final class RStringVector extends RVector<String[]> implements RAbstractS
return data;
}
- @Override
- public String toString() {
- return toString(i -> getDataAt(i));
- }
-
@Override
public boolean verify() {
if (isComplete()) {
@@ -219,4 +222,45 @@ public final class RStringVector extends RVector<String[]> implements RAbstractS
public void setElement(int i, Object value) {
data[i] = (String) value;
}
+
+ private static final class FastPathAccess extends FastPathFromStringAccess {
+
+ FastPathAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected String getString(Object store, int index) {
+ assert hasStore;
+ return ((String[]) store)[index];
+ }
+
+ @Override
+ protected void setString(Object store, int index, String value) {
+ assert hasStore;
+ ((String[]) store)[index] = value;
+ }
+ }
+
+ @Override
+ public VectorAccess access() {
+ return new FastPathAccess(this);
+ }
+
+ private static final SlowPathFromStringAccess SLOW_PATH_ACCESS = new SlowPathFromStringAccess() {
+ @Override
+ protected String getString(Object store, int index) {
+ return ((RStringVector) store).data[index];
+ }
+
+ @Override
+ protected void setString(Object store, int index, String value) {
+ ((RStringVector) store).data[index] = value;
+ }
+ };
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ return SLOW_PATH_ACCESS;
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RVector.java
index 8956b2df5d..47b40aec93 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/RVector.java
@@ -24,8 +24,6 @@ package com.oracle.truffle.r.runtime.data;
import static com.oracle.truffle.r.runtime.RError.NO_CALLER;
-import java.util.function.Function;
-
import com.oracle.truffle.api.CompilerAsserts;
import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
@@ -40,6 +38,8 @@ import com.oracle.truffle.r.runtime.data.model.RAbstractIntVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractStringVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
import com.oracle.truffle.r.runtime.data.nodes.GetReadonlyData;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess.SequentialIterator;
import com.oracle.truffle.r.runtime.nodes.RBaseNode;
import com.oracle.truffle.r.runtime.ops.na.NACheck;
@@ -780,18 +780,25 @@ public abstract class RVector<ArrayT> extends RSharingAttributeStorage implement
private static final int MAX_TOSTRING_LENGTH = 100;
- protected final String toString(Function<Integer, String> element) {
+ @Override
+ public final String toString() {
CompilerAsserts.neverPartOfCompilation();
StringBuilder str = new StringBuilder("[");
- for (int i = 0; i < getLength(); i++) {
- if (i > 0) {
- str.append(", ");
- }
- str.append(element.apply(i));
- if (str.length() > MAX_TOSTRING_LENGTH - 1) {
- str.setLength(MAX_TOSTRING_LENGTH - 4);
- str.append("...");
- break;
+ VectorAccess access = slowPathAccess();
+ try (SequentialIterator iter = access.access(this)) {
+ if (access.next(iter)) {
+ while (true) {
+ str.append(access.getType().isAtomic() ? access.getString(iter) : access.getListElement(iter).toString());
+ if (!access.next(iter)) {
+ break;
+ }
+ str.append(", ");
+ if (str.length() > MAX_TOSTRING_LENGTH - 1) {
+ str.setLength(MAX_TOSTRING_LENGTH - 4);
+ str.append("...");
+ break;
+ }
+ }
}
}
return str.append(']').toString();
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/closures/RToVectorClosure.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/closures/RToVectorClosure.java
index e8c5104485..7495f52ae8 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/closures/RToVectorClosure.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/closures/RToVectorClosure.java
@@ -24,6 +24,7 @@ package com.oracle.truffle.r.runtime.data.closures;
import com.oracle.truffle.api.object.DynamicObject;
import com.oracle.truffle.api.profiles.ConditionProfile;
+import com.oracle.truffle.r.runtime.RInternalError;
import com.oracle.truffle.r.runtime.RType;
import com.oracle.truffle.r.runtime.data.RList;
import com.oracle.truffle.r.runtime.data.RStringVector;
@@ -31,6 +32,7 @@ import com.oracle.truffle.r.runtime.data.RTypedValue;
import com.oracle.truffle.r.runtime.data.RVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
abstract class RToVectorClosure implements RAbstractVector {
@@ -49,8 +51,8 @@ abstract class RToVectorClosure implements RAbstractVector {
}
@Override
- public EmptyInternalStore getInternalStore() {
- return EmptyInternalStore.INSTANCE;
+ public Object getInternalStore() {
+ return this;
}
@Override
@@ -184,4 +186,14 @@ abstract class RToVectorClosure implements RAbstractVector {
// first materialize and then cast and do not create a closure over a closure.
return materialize().castSafe(type, isNAProfile, keepAttrs);
}
+
+ @Override
+ public final VectorAccess access() {
+ throw RInternalError.shouldNotReachHere("access() for " + getClass().getSimpleName());
+ }
+
+ @Override
+ public final VectorAccess slowPathAccess() {
+ throw RInternalError.shouldNotReachHere("slowPathAccess() for " + getClass().getSimpleName());
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractComplexVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractComplexVector.java
index b2d9e6cd06..4e1a9ef486 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractComplexVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractComplexVector.java
@@ -36,10 +36,6 @@ public interface RAbstractComplexVector extends RAbstractAtomicVector {
RComplex getDataAt(int index);
- default RComplex getDataAt(@SuppressWarnings("unused") Object store, int index) {
- return getDataAt(index);
- }
-
@Override
RComplexVector materialize();
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractContainer.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractContainer.java
index 8723bed3da..93742f57b5 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractContainer.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractContainer.java
@@ -28,6 +28,7 @@ import com.oracle.truffle.r.runtime.data.RAttributable;
import com.oracle.truffle.r.runtime.data.RList;
import com.oracle.truffle.r.runtime.data.RStringVector;
import com.oracle.truffle.r.runtime.data.RTypedValue;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
public interface RAbstractContainer extends RAttributable, RTypedValue {
@@ -67,9 +68,7 @@ public interface RAbstractContainer extends RAttributable, RTypedValue {
* vector's fields, but instead read the necessary data from a local variable, which could be
* beneficial when in loop.
*/
- default Object getInternalStore() {
- return EmptyInternalStore.INSTANCE;
- }
+ Object getInternalStore();
default RStringVector getNames() {
CompilerAsserts.neverPartOfCompilation();
@@ -101,10 +100,7 @@ public interface RAbstractContainer extends RAttributable, RTypedValue {
setAttr(RRuntime.ROWNAMES_ATTR_KEY, rowNames);
}
- final class EmptyInternalStore {
- private EmptyInternalStore() {
- }
+ VectorAccess access();
- public static final EmptyInternalStore INSTANCE = new EmptyInternalStore();
- }
+ VectorAccess slowPathAccess();
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractRawVector.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractRawVector.java
index 5f8697e39d..53f2c49bd1 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractRawVector.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/model/RAbstractRawVector.java
@@ -33,10 +33,6 @@ public interface RAbstractRawVector extends RAbstractAtomicVector {
return RRaw.valueOf(getRawDataAt(index));
}
- default byte getRawDataAt(@SuppressWarnings("unused") Object store, int index) {
- return getRawDataAt(index);
- }
-
@SuppressWarnings("unused")
default void setRawDataAt(Object store, int index, byte value) {
throw new UnsupportedOperationException();
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/FastPathVectorAccess.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/FastPathVectorAccess.java
new file mode 100644
index 0000000000..e17d63ac7c
--- /dev/null
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/FastPathVectorAccess.java
@@ -0,0 +1,635 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.r.runtime.data.nodes;
+
+import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.r.runtime.RError;
+import com.oracle.truffle.r.runtime.RError.Message;
+import com.oracle.truffle.r.runtime.RInternalError;
+import com.oracle.truffle.r.runtime.RRuntime;
+import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.context.RContext;
+import com.oracle.truffle.r.runtime.data.RComplex;
+import com.oracle.truffle.r.runtime.data.RNull;
+import com.oracle.truffle.r.runtime.data.RRaw;
+import com.oracle.truffle.r.runtime.data.RVector;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
+
+/**
+ * Base classes for {@link VectorAccess} implementations that are used on the fast path. For
+ * implementation reasons, most of this code is mirrored in {@link SlowPathVectorAccess}, so that
+ * any changes need to be mirrored there.
+ */
+public abstract class FastPathVectorAccess extends VectorAccess {
+
+ protected boolean naReported; // TODO: move this into the iterator
+
+ protected FastPathVectorAccess(RAbstractContainer value) {
+ super(value.getClass(), value.getInternalStore() != null);
+ }
+
+ @Override
+ protected final Object getStore(RAbstractContainer vector) {
+ return hasStore ? vector.getInternalStore() : ((RVector<?>) vector).getNativeMirror();
+ }
+
+ protected final void warning(RError.Message message) {
+ CompilerAsserts.neverPartOfCompilation();
+ if (!naReported) {
+ RError.warning(RError.SHOW_CALLER, message);
+ naReported = true;
+ }
+ }
+
+ public abstract static class FastPathFromIntAccess extends FastPathVectorAccess {
+
+ public FastPathFromIntAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public final RType getType() {
+ return RType.Integer;
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.DOUBLE_NA : RRuntime.int2doubleNoCheck(value);
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ int value = getInt(store, index);
+ byte result = (byte) value;
+ if ((result & 0xff) != value) {
+ warning(Message.OUT_OF_RANGE);
+ return 0;
+ }
+ return result;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.LOGICAL_NA : RRuntime.int2logicalNoCheck(value);
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RComplex.createNA() : RRuntime.int2complexNoCheck(value);
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_REAL_PART : value;
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_IMAGINARY_PART : 0;
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.STRING_NA : RRuntime.intToStringNoCheck(value);
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getInt(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setInt(store, index, sourceAccess.getInt(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setInt(store, index, sourceAccess.getInt(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setInt(store, index, RRuntime.INT_NA);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getInt(store, index));
+ }
+ }
+
+ public abstract static class FastPathFromDoubleAccess extends FastPathVectorAccess {
+
+ public FastPathFromDoubleAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public final RType getType() {
+ return RType.Double;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ double value = getDouble(store, index);
+ if (Double.isNaN(value)) {
+ na.enable(true);
+ return RRuntime.INT_NA;
+ }
+ if (value > Integer.MAX_VALUE || value <= Integer.MIN_VALUE) {
+ na.enable(true);
+ warning(Message.NA_INTRODUCED_COERCION_INT);
+ return RRuntime.INT_NA;
+ }
+ return (int) value;
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ int value = (int) getDouble(store, index);
+ byte result = (byte) value;
+ if ((result & 0xff) != value) {
+ warning(Message.OUT_OF_RANGE);
+ return 0;
+ }
+ return result;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RRuntime.LOGICAL_NA : RRuntime.double2logicalNoCheck(value);
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RComplex.createNA() : RRuntime.double2complexNoCheck(value);
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_REAL_PART : value;
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_IMAGINARY_PART : 0;
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RRuntime.STRING_NA : RContext.getRRuntimeASTAccess().encodeDouble(value);
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getDouble(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setDouble(store, index, sourceAccess.getDouble(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setDouble(store, index, sourceAccess.getDouble(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setDouble(store, index, RRuntime.DOUBLE_NA);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getDouble(store, index));
+ }
+ }
+
+ public abstract static class FastPathFromLogicalAccess extends FastPathVectorAccess {
+
+ public FastPathFromLogicalAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public final RType getType() {
+ return RType.Logical;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.INT_NA : RRuntime.logical2intNoCheck(value);
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.DOUBLE_NA : RRuntime.logical2doubleNoCheck(value);
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ byte value = getLogical(store, index);
+ if (na.check(value)) {
+ warning(Message.OUT_OF_RANGE);
+ return 0;
+ }
+ return value;
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RComplex.createNA() : RRuntime.logical2complexNoCheck(value);
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_REAL_PART : value;
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_IMAGINARY_PART : 0;
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.STRING_NA : RRuntime.logicalToStringNoCheck(value);
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getLogical(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setLogical(store, index, sourceAccess.getLogical(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setLogical(store, index, sourceAccess.getLogical(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setLogical(store, index, RRuntime.LOGICAL_NA);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getLogical(store, index));
+ }
+ }
+
+ public abstract static class FastPathFromRawAccess extends FastPathVectorAccess {
+
+ public FastPathFromRawAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public final RType getType() {
+ return RType.Raw;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ return getRaw(store, index) & 0xff;
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ return getRaw(store, index) & 0xff;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ return getRaw(store, index) == 0 ? RRuntime.LOGICAL_FALSE : RRuntime.LOGICAL_TRUE;
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ return RComplex.valueOf(getRaw(store, index) & 0xff, 0);
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ return getRaw(store, index) & 0xff;
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ return 0;
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ return RRuntime.rawToHexString(getRaw(store, index));
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return RRaw.valueOf(getRaw(store, index));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setRaw(store, index, sourceAccess.getRaw(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setRaw(store, index, sourceAccess.getRaw(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ /*
+ * There is no raw NA, but places that write NA for other types usually write 0 for raw.
+ */
+ setRaw(store, index, (byte) 0);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return false;
+ }
+ }
+
+ public abstract static class FastPathFromComplexAccess extends FastPathVectorAccess {
+
+ public FastPathFromComplexAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public final RType getType() {
+ return RType.Complex;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ double value = getComplexR(store, index);
+ if (Double.isNaN(value)) {
+ na.enable(true);
+ return RRuntime.INT_NA;
+ }
+ if (value > Integer.MAX_VALUE || value <= Integer.MIN_VALUE) {
+ na.enable(true);
+ warning(Message.NA_INTRODUCED_COERCION_INT);
+ return RRuntime.INT_NA;
+ }
+ if (getComplexI(store, index) != 0) {
+ warning(Message.IMAGINARY_PARTS_DISCARDED_IN_COERCION);
+ }
+ return (int) value;
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ double value = getComplexR(store, index);
+ if (Double.isNaN(value)) {
+ na.enable(true);
+ return RRuntime.DOUBLE_NA;
+ }
+ if (getComplexI(store, index) != 0) {
+ warning(Message.IMAGINARY_PARTS_DISCARDED_IN_COERCION);
+ }
+ return value;
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ double value = getComplexR(store, index);
+ if (Double.isNaN(value) || value < 0 || value >= 256) {
+ warning(Message.OUT_OF_RANGE);
+ return 0;
+ }
+ if (getComplexI(store, index) != 0) {
+ warning(Message.IMAGINARY_PARTS_DISCARDED_IN_COERCION);
+ }
+ return (byte) value;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ RComplex value = getComplex(store, index);
+ return na.check(value) ? RRuntime.LOGICAL_NA : RRuntime.complex2logicalNoCheck(value);
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ RComplex value = getComplex(store, index);
+ return na.check(value) ? RRuntime.STRING_NA : RContext.getRRuntimeASTAccess().encodeComplex(value);
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getComplex(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setComplex(store, index, sourceAccess.getComplexR(sourceIter), sourceAccess.getComplexI(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setComplex(store, index, sourceAccess.getComplexR(sourceIter, sourceIndex), sourceAccess.getComplexI(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setComplex(store, index, RRuntime.COMPLEX_NA_REAL_PART, RRuntime.COMPLEX_NA_IMAGINARY_PART);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getComplexR(store, index), getComplexI(store, index));
+ }
+ }
+
+ public abstract static class FastPathFromStringAccess extends FastPathVectorAccess {
+
+ public FastPathFromStringAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ public final RType getType() {
+ return RType.Character;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ return na.convertStringToInt(getString(store, index));
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ return na.convertStringToDouble(getString(store, index));
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ int value = na.convertStringToInt(getString(store, index));
+ return value >= 0 && value <= 255 ? (byte) value : 0;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ return na.convertStringToLogical(getString(store, index));
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ return na.convertStringToComplex(getString(store, index));
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ return na.convertStringToComplex(getString(store, index)).getRealPart();
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ return na.convertStringToComplex(getString(store, index)).getImaginaryPart();
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getString(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setString(store, index, sourceAccess.getString(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setString(store, index, sourceAccess.getString(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setString(store, index, RRuntime.STRING_NA);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getString(store, index));
+ }
+ }
+
+ public abstract static class FastPathFromListAccess extends FastPathVectorAccess {
+
+ public FastPathFromListAccess(RAbstractContainer value) {
+ super(value);
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setListElement(store, index, sourceAccess.getListElement(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setListElement(store, index, sourceAccess.getListElement(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ /*
+ * There is no list NA, but places that write NA for other types usually write NULL for
+ * lists.
+ */
+ setListElement(store, index, RNull.instance);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.checkListElement(getListElement(store, index));
+ }
+ }
+}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/SlowPathVectorAccess.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/SlowPathVectorAccess.java
new file mode 100644
index 0000000000..18fb51f466
--- /dev/null
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/SlowPathVectorAccess.java
@@ -0,0 +1,606 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.r.runtime.data.nodes;
+
+import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.r.runtime.RError;
+import com.oracle.truffle.r.runtime.RError.Message;
+import com.oracle.truffle.r.runtime.RInternalError;
+import com.oracle.truffle.r.runtime.RRuntime;
+import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.context.RContext;
+import com.oracle.truffle.r.runtime.data.RComplex;
+import com.oracle.truffle.r.runtime.data.RNull;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
+
+/**
+ * Base classes for {@link VectorAccess} implementations that are used on the slow path, i.e., that
+ * are created as singletons. For implementation reasons, most of this code is mirrored in
+ * {@link FastPathVectorAccess}, so that any changes need to be mirrored there.
+ */
+public abstract class SlowPathVectorAccess extends VectorAccess {
+
+ protected boolean naReported; // TODO: move this into the iterator
+
+ protected SlowPathVectorAccess() {
+ // VectorAccess.supports has an assertion that relies on this being RAbstractContainer.class
+ super(RAbstractContainer.class, true);
+ }
+
+ @Override
+ protected final Object getStore(RAbstractContainer vector) {
+ return vector;
+ }
+
+ protected final void warning(RError.Message message) {
+ CompilerAsserts.neverPartOfCompilation();
+ if (!naReported) {
+ RError.warning(RError.SHOW_CALLER, message);
+ naReported = true;
+ }
+ }
+
+ public abstract static class SlowPathFromIntAccess extends SlowPathVectorAccess {
+
+ @Override
+ public final RType getType() {
+ return RType.Integer;
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.DOUBLE_NA : RRuntime.int2doubleNoCheck(value);
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ int value = getInt(store, index);
+ byte result = (byte) value;
+ if ((result & 0xff) != value) {
+ warning(Message.OUT_OF_RANGE);
+ return 0;
+ }
+ return result;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.LOGICAL_NA : RRuntime.int2logicalNoCheck(value);
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RComplex.createNA() : RRuntime.int2complexNoCheck(value);
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_REAL_PART : value;
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_IMAGINARY_PART : 0;
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ int value = getInt(store, index);
+ return na.check(value) ? RRuntime.STRING_NA : RRuntime.intToStringNoCheck(value);
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getInt(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setInt(store, index, sourceAccess.getInt(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setInt(store, index, sourceAccess.getInt(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setInt(store, index, RRuntime.INT_NA);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getInt(store, index));
+ }
+ }
+
+ public abstract static class SlowPathFromDoubleAccess extends SlowPathVectorAccess {
+
+ @Override
+ public final RType getType() {
+ return RType.Double;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ double value = getDouble(store, index);
+ if (Double.isNaN(value)) {
+ na.enable(true);
+ return RRuntime.INT_NA;
+ }
+ if (value > Integer.MAX_VALUE || value <= Integer.MIN_VALUE) {
+ na.enable(true);
+ warning(Message.NA_INTRODUCED_COERCION_INT);
+ return RRuntime.INT_NA;
+ }
+ return (int) value;
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ int value = (int) getDouble(store, index);
+ byte result = (byte) value;
+ if ((result & 0xff) != value) {
+ warning(Message.OUT_OF_RANGE);
+ return 0;
+ }
+ return result;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RRuntime.LOGICAL_NA : RRuntime.double2logicalNoCheck(value);
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RComplex.createNA() : RRuntime.double2complexNoCheck(value);
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_REAL_PART : value;
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_IMAGINARY_PART : 0;
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ double value = getDouble(store, index);
+ return na.check(value) ? RRuntime.STRING_NA : RContext.getRRuntimeASTAccess().encodeDouble(value);
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getDouble(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setDouble(store, index, sourceAccess.getDouble(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setDouble(store, index, sourceAccess.getDouble(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setDouble(store, index, RRuntime.DOUBLE_NA);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getDouble(store, index));
+ }
+ }
+
+ public abstract static class SlowPathFromLogicalAccess extends SlowPathVectorAccess {
+
+ @Override
+ public final RType getType() {
+ return RType.Logical;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.INT_NA : RRuntime.logical2intNoCheck(value);
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.DOUBLE_NA : RRuntime.logical2doubleNoCheck(value);
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ byte value = getLogical(store, index);
+ if (na.check(value)) {
+ warning(Message.OUT_OF_RANGE);
+ return 0;
+ }
+ return value;
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RComplex.createNA() : RRuntime.logical2complexNoCheck(value);
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_REAL_PART : value;
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.COMPLEX_NA_IMAGINARY_PART : 0;
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ byte value = getLogical(store, index);
+ return na.check(value) ? RRuntime.STRING_NA : RRuntime.logicalToStringNoCheck(value);
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getLogical(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setLogical(store, index, sourceAccess.getLogical(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setLogical(store, index, sourceAccess.getLogical(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setLogical(store, index, RRuntime.LOGICAL_NA);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getLogical(store, index));
+ }
+ }
+
+ public abstract static class SlowPathFromRawAccess extends SlowPathVectorAccess {
+
+ @Override
+ public final RType getType() {
+ return RType.Raw;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ return getRaw(store, index) & 0xff;
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ return getRaw(store, index) & 0xff;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ return getRaw(store, index) == 0 ? RRuntime.LOGICAL_FALSE : RRuntime.LOGICAL_TRUE;
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ return RComplex.valueOf(getRaw(store, index) & 0xff, 0);
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ return getRaw(store, index) & 0xff;
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ return 0;
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ return RRuntime.rawToHexString(getRaw(store, index));
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getRaw(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setRaw(store, index, sourceAccess.getRaw(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setRaw(store, index, sourceAccess.getRaw(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ /*
+ * There is no raw NA, but places that write NA for other types usually write 0 for raw.
+ */
+ setRaw(store, index, (byte) 0);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return false;
+ }
+ }
+
+ public abstract static class SlowPathFromComplexAccess extends SlowPathVectorAccess {
+
+ @Override
+ public final RType getType() {
+ return RType.Complex;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ double value = getComplexR(store, index);
+ if (Double.isNaN(value)) {
+ na.enable(true);
+ return RRuntime.INT_NA;
+ }
+ if (value > Integer.MAX_VALUE || value <= Integer.MIN_VALUE) {
+ na.enable(true);
+ warning(Message.NA_INTRODUCED_COERCION_INT);
+ return RRuntime.INT_NA;
+ }
+ if (getComplexI(store, index) != 0) {
+ warning(Message.IMAGINARY_PARTS_DISCARDED_IN_COERCION);
+ }
+ return (int) value;
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ double value = getComplexR(store, index);
+ if (Double.isNaN(value)) {
+ na.enable(true);
+ return RRuntime.DOUBLE_NA;
+ }
+ if (getComplexI(store, index) != 0) {
+ warning(Message.IMAGINARY_PARTS_DISCARDED_IN_COERCION);
+ }
+ return value;
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ double value = getComplexR(store, index);
+ if (Double.isNaN(value) || value < 0 || value >= 256) {
+ warning(Message.OUT_OF_RANGE);
+ return 0;
+ }
+ if (getComplexI(store, index) != 0) {
+ warning(Message.IMAGINARY_PARTS_DISCARDED_IN_COERCION);
+ }
+ return (byte) value;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ RComplex value = getComplex(store, index);
+ return na.check(value) ? RRuntime.LOGICAL_NA : RRuntime.complex2logicalNoCheck(value);
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ RComplex value = getComplex(store, index);
+ return na.check(value) ? RRuntime.STRING_NA : RContext.getRRuntimeASTAccess().encodeComplex(value);
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getComplex(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setComplex(store, index, sourceAccess.getComplexR(sourceIter), sourceAccess.getComplexI(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setComplex(store, index, sourceAccess.getComplexR(sourceIter, sourceIndex), sourceAccess.getComplexI(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setComplex(store, index, RRuntime.COMPLEX_NA_REAL_PART, RRuntime.COMPLEX_NA_IMAGINARY_PART);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getComplexR(store, index), getComplexI(store, index));
+ }
+ }
+
+ public abstract static class SlowPathFromStringAccess extends SlowPathVectorAccess {
+
+ @Override
+ public final RType getType() {
+ return RType.Character;
+ }
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ return na.convertStringToInt(getString(store, index));
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ return na.convertStringToDouble(getString(store, index));
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ int value = na.convertStringToInt(getString(store, index));
+ return value >= 0 && value <= 255 ? (byte) value : 0;
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ return na.convertStringToLogical(getString(store, index));
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ return na.convertStringToComplex(getString(store, index));
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ return na.convertStringToComplex(getString(store, index)).getRealPart();
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ return na.convertStringToComplex(getString(store, index)).getImaginaryPart();
+ }
+
+ @Override
+ protected final Object getListElement(Object store, int index) {
+ return getString(store, index);
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setString(store, index, sourceAccess.getString(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setString(store, index, sourceAccess.getString(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ setString(store, index, RRuntime.STRING_NA);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.check(getString(store, index));
+ }
+ }
+
+ public abstract static class SlowPathFromListAccess extends SlowPathVectorAccess {
+
+ @Override
+ protected final int getInt(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final double getDouble(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final byte getRaw(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final byte getLogical(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final RComplex getComplex(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final double getComplexR(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final double getComplexI(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final String getString(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setListElement(store, index, sourceAccess.getListElement(sourceIter));
+ }
+
+ @Override
+ protected final void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setListElement(store, index, sourceAccess.getListElement(sourceIter, sourceIndex));
+ }
+
+ @Override
+ protected void setNA(Object store, int index) {
+ /*
+ * There is no list NA, but places that write NA for other types usually write NULL for
+ * lists.
+ */
+ setListElement(store, index, RNull.instance);
+ }
+
+ @Override
+ protected boolean isNA(Object store, int index) {
+ return na.checkListElement(getListElement(store, index));
+ }
+ }
+}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/VectorAccess.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/VectorAccess.java
new file mode 100644
index 0000000000..27bba89617
--- /dev/null
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/data/nodes/VectorAccess.java
@@ -0,0 +1,501 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.r.runtime.data.nodes;
+
+import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.r.runtime.RInternalError;
+import com.oracle.truffle.r.runtime.RType;
+import com.oracle.truffle.r.runtime.data.RComplex;
+import com.oracle.truffle.r.runtime.data.RComplexVector;
+import com.oracle.truffle.r.runtime.data.RDataFactory;
+import com.oracle.truffle.r.runtime.data.RDoubleVector;
+import com.oracle.truffle.r.runtime.data.RExpression;
+import com.oracle.truffle.r.runtime.data.RIntVector;
+import com.oracle.truffle.r.runtime.data.RList;
+import com.oracle.truffle.r.runtime.data.RLogicalVector;
+import com.oracle.truffle.r.runtime.data.RRawVector;
+import com.oracle.truffle.r.runtime.data.RStringVector;
+import com.oracle.truffle.r.runtime.data.model.RAbstractContainer;
+import com.oracle.truffle.r.runtime.nodes.RBaseNode;
+import com.oracle.truffle.r.runtime.ops.na.NACheck;
+
+/**
+ * This class is the main access point for reading and writing vectors. Every implementation of
+ * {@link RAbstractContainer} needs to be able to supply an instance of {@link VectorAccess} via the
+ * {@link RAbstractContainer#access()} function. These instances can be asked, via the
+ * {@link #supports(Object)} function, whether they support a specific object.<br/>
+ *
+ * The usual interaction with vectors looks like this:
+ * <ul>
+ * <li>{@link Specialization} {@code foo} has a vector as a parameter, and adds a {@link Cached}
+ * parameter of type {@link VectorAccess} that is initialized by {@link RAbstractContainer#access()}
+ * .</li>
+ * <li>The specialization guards with {@code access.supports(vector)} so that it only handles cases
+ * that it actually supports.</li>
+ * <li>try-with-resources is used to open an access (either sequential or random) on the vector:
+ * <br/>
+ * {@code try (SequentialIterator iter = access.access(vector))...}</li>
+ * <li>Inside the try-with-resources, individual elements can be accessed using the
+ * {@link VectorAccess#getInt(SequentialIterator)}, etc. functions</li>
+ * <li>A fallback specialization, which {@link Specialization#replaces()} the original one and
+ * creates the {@link VectorAccess} via {@link RAbstractContainer#slowPathAccess()}, calls the first
+ * specialization with the slow path vector access.</li>
+ * </ul>
+ */
+public abstract class VectorAccess extends Node {
+
+ public final NACheck na = NACheck.create();
+
+ protected final Class<? extends RAbstractContainer> clazz;
+ protected final boolean hasStore;
+
+ public VectorAccess(Class<? extends RAbstractContainer> clazz, boolean hasStore) {
+ CompilerAsserts.neverPartOfCompilation();
+ this.clazz = clazz;
+ this.hasStore = hasStore;
+ }
+
+ public static final class SequentialIterator implements AutoCloseable {
+
+ protected final Object store; // internal store, native mirror or vector
+ protected final int length;
+ protected int index;
+
+ private SequentialIterator(Object store, int length) {
+ this.store = store;
+ this.length = length;
+ this.index = -1;
+ }
+
+ @Override
+ public void close() {
+ // nothing to do
+ }
+
+ public int getIndex() {
+ return index;
+ }
+
+ Object getStore() {
+ return store;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("<iterator %d of %d, %s>", index, length, store == null ? "null" : store.getClass().getSimpleName());
+ }
+ }
+
+ public static final class RandomIterator implements AutoCloseable {
+
+ protected final Object store; // internal store, native mirror or vector
+ protected final int length;
+
+ private RandomIterator(Object store, int length) {
+ this.store = store;
+ this.length = length;
+ }
+
+ @Override
+ public void close() {
+ // nothing to do
+ }
+
+ Object getStore() {
+ return store;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("<random access %s>", store == null ? "null" : store.getClass().getSimpleName());
+ }
+ }
+
+ protected abstract int getInt(Object store, int index);
+
+ protected abstract double getDouble(Object store, int index);
+
+ protected abstract RComplex getComplex(Object store, int index);
+
+ protected abstract double getComplexR(Object store, int index);
+
+ protected abstract double getComplexI(Object store, int index);
+
+ protected abstract byte getRaw(Object store, int index);
+
+ protected abstract byte getLogical(Object store, int index);
+
+ protected abstract String getString(Object store, int index);
+
+ protected abstract Object getListElement(Object store, int index);
+
+ @SuppressWarnings("unused")
+ protected void setInt(Object store, int index, int value) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @SuppressWarnings("unused")
+ protected void setDouble(Object store, int index, double value) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @SuppressWarnings("unused")
+ protected void setComplex(Object store, int index, double real, double imaginary) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @SuppressWarnings("unused")
+ protected void setRaw(Object store, int index, byte value) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @SuppressWarnings("unused")
+ protected void setLogical(Object store, int index, byte value) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @SuppressWarnings("unused")
+ protected void setString(Object store, int index, String value) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @SuppressWarnings("unused")
+ protected void setListElement(Object store, int index, Object value) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @SuppressWarnings("unused")
+ protected void setFromSameType(Object store, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @SuppressWarnings("unused")
+ protected void setFromSameType(Object store, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ @SuppressWarnings("unused")
+ protected void setNA(Object store, int index) {
+ throw RInternalError.shouldNotReachHere();
+ }
+
+ protected abstract boolean isNA(Object store, int index);
+
+ public final RAbstractContainer cast(Object value) {
+ return clazz.cast(value);
+ }
+
+ public final boolean supports(Object value) {
+ assert clazz != RAbstractContainer.class : "cannot call 'supports' on slow path vector access";
+ return value.getClass() == clazz && (cast(value).getInternalStore() != null) == hasStore;
+ }
+
+ protected abstract Object getStore(RAbstractContainer vector);
+
+ protected int getLength(RAbstractContainer vector) {
+ return vector.getLength();
+ }
+
+ /**
+ * Creates a new iterator that will point to before the beginning of the vector, so that
+ * {@link #next(SequentialIterator)} will move it to the first element.
+ */
+ public final SequentialIterator access(RAbstractContainer vector) {
+ RAbstractContainer castVector = cast(vector);
+ int length = getLength(castVector);
+ RBaseNode.reportWork(this, length);
+ na.enable(castVector);
+ return new SequentialIterator(getStore(castVector), length);
+ }
+
+ @SuppressWarnings("static-method")
+ public final boolean next(SequentialIterator iter) {
+ return ++iter.index < iter.length;
+ }
+
+ @SuppressWarnings("static-method")
+ public final void nextWithWrap(SequentialIterator iter) {
+ assert iter.length > 0;
+ if (++iter.index >= iter.length) {
+ iter.index = 0;
+ }
+ }
+
+ @SuppressWarnings("static-method")
+ public final int getLength(SequentialIterator iter) {
+ return iter.length;
+ }
+
+ /**
+ * Resets the iterator to point to before the first element, calling
+ * {@link #next(SequentialIterator)} will move it to the first element.
+ */
+ @SuppressWarnings("static-method")
+ public final void reset(SequentialIterator iter) {
+ iter.index = -1;
+ }
+
+ public abstract RType getType();
+
+ public final int getInt(SequentialIterator iter) {
+ return getInt(iter.store, iter.index);
+ }
+
+ public final double getDouble(SequentialIterator iter) {
+ return getDouble(iter.store, iter.index);
+ }
+
+ public final RComplex getComplex(SequentialIterator iter) {
+ return getComplex(iter.store, iter.index);
+ }
+
+ public final double getComplexR(SequentialIterator iter) {
+ return getComplexR(iter.store, iter.index);
+ }
+
+ public final double getComplexI(SequentialIterator iter) {
+ return getComplexI(iter.store, iter.index);
+ }
+
+ public final byte getRaw(SequentialIterator iter) {
+ return getRaw(iter.store, iter.index);
+ }
+
+ public final byte getLogical(SequentialIterator iter) {
+ return getLogical(iter.store, iter.index);
+ }
+
+ public final String getString(SequentialIterator iter) {
+ return getString(iter.store, iter.index);
+ }
+
+ public final Object getListElement(SequentialIterator iter) {
+ return getListElement(iter.store, iter.index);
+ }
+
+ public final void setInt(SequentialIterator iter, int value) {
+ setInt(iter.store, iter.index, value);
+ }
+
+ public final void setDouble(SequentialIterator iter, double value) {
+ setDouble(iter.store, iter.index, value);
+ }
+
+ public final void setComplex(SequentialIterator iter, double real, double imaginary) {
+ setComplex(iter.store, iter.index, real, imaginary);
+ }
+
+ public final void setRaw(SequentialIterator iter, byte value) {
+ setRaw(iter.store, iter.index, value);
+ }
+
+ public final void setLogical(SequentialIterator iter, byte value) {
+ setLogical(iter.store, iter.index, value);
+ }
+
+ public final void setString(SequentialIterator iter, String value) {
+ setString(iter.store, iter.index, value);
+ }
+
+ public final void setListElement(SequentialIterator iter, Object value) {
+ setListElement(iter.store, iter.index, value);
+ }
+
+ public final void setFromSameType(SequentialIterator iter, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setFromSameType(iter.store, iter.index, sourceAccess, sourceIter);
+ }
+
+ public final void setFromSameType(SequentialIterator iter, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setFromSameType(iter.store, iter.index, sourceAccess, sourceIter, sourceIndex);
+ }
+
+ public final void setNA(SequentialIterator iter) {
+ setNA(iter.store, iter.index);
+ }
+
+ public final boolean isNA(SequentialIterator iter) {
+ return isNA(iter.store, iter.index);
+ }
+
+ /**
+ * Creates a new random access on the given vector.
+ */
+ public final RandomIterator randomAccess(RAbstractContainer vector) {
+ RAbstractContainer castVector = cast(vector);
+ int length = getLength(castVector);
+ RBaseNode.reportWork(this, length);
+ na.enable(castVector);
+ return new RandomIterator(getStore(castVector), length);
+ }
+
+ @SuppressWarnings("static-method")
+ public final int getLength(RandomIterator iter) {
+ return iter.length;
+ }
+
+ public final int getInt(RandomIterator iter, int index) {
+ return getInt(iter.store, index);
+ }
+
+ public final double getDouble(RandomIterator iter, int index) {
+ return getDouble(iter.store, index);
+ }
+
+ public final RComplex getComplex(RandomIterator iter, int index) {
+ return getComplex(iter.store, index);
+ }
+
+ public final double getComplexR(RandomIterator iter, int index) {
+ return getComplexR(iter.store, index);
+ }
+
+ public final double getComplexI(RandomIterator iter, int index) {
+ return getComplexI(iter.store, index);
+ }
+
+ public final byte getRaw(RandomIterator iter, int index) {
+ return getRaw(iter.store, index);
+ }
+
+ public final byte getLogical(RandomIterator iter, int index) {
+ return getLogical(iter.store, index);
+ }
+
+ public final String getString(RandomIterator iter, int index) {
+ return getString(iter.store, index);
+ }
+
+ public final Object getListElement(RandomIterator iter, int index) {
+ return getListElement(iter.store, index);
+ }
+
+ public final void setInt(RandomIterator iter, int index, int value) {
+ setInt(iter.store, index, value);
+ }
+
+ public final void setDouble(RandomIterator iter, int index, double value) {
+ setDouble(iter.store, index, value);
+ }
+
+ public final void setComplex(RandomIterator iter, int index, double real, double imaginary) {
+ setComplex(iter.store, index, real, imaginary);
+ }
+
+ public final void setRaw(RandomIterator iter, int index, byte value) {
+ setRaw(iter.store, index, value);
+ }
+
+ public final void setLogical(RandomIterator iter, int index, byte value) {
+ setLogical(iter.store, index, value);
+ }
+
+ public final void setString(RandomIterator iter, int index, String value) {
+ setString(iter.store, index, value);
+ }
+
+ public final void setListElement(RandomIterator iter, int index, Object value) {
+ setListElement(iter.store, index, value);
+ }
+
+ public final void setFromSameType(RandomIterator iter, int index, VectorAccess sourceAccess, SequentialIterator sourceIter) {
+ setFromSameType(iter.store, index, sourceAccess, sourceIter);
+ }
+
+ public final void setFromSameType(RandomIterator iter, int index, VectorAccess sourceAccess, RandomIterator sourceIter, int sourceIndex) {
+ setFromSameType(iter.store, index, sourceAccess, sourceIter, sourceIndex);
+ }
+
+ public final void setNA(RandomIterator iter, int index) {
+ setNA(iter.store, index);
+ }
+
+ public final boolean isNA(RandomIterator iter, int index) {
+ return isNA(iter.store, index);
+ }
+
+ private static final RStringVector TEMPLATE_CHARACTER = RDataFactory.getPermanent().createStringVector(4);
+ private static final RComplexVector TEMPLATE_COMPLEX = RDataFactory.getPermanent().createComplexVector(4);
+ private static final RDoubleVector TEMPLATE_DOUBLE = RDataFactory.getPermanent().createDoubleVector(4);
+ private static final RIntVector TEMPLATE_INTEGER = RDataFactory.getPermanent().createIntVector(4);
+ private static final RList TEMPLATE_LIST = RDataFactory.getPermanent().createList(4);
+ private static final RExpression TEMPLATE_EXPRESSION = RDataFactory.createExpression(4);
+ private static final RLogicalVector TEMPLATE_LOGICAL = RDataFactory.getPermanent().createLogicalVector(4);
+ private static final RRawVector TEMPLATE_RAW = RDataFactory.getPermanent().createRawVector(4);
+
+ public static VectorAccess createNew(RType type) {
+ switch (type) {
+ case Character:
+ return TEMPLATE_CHARACTER.access();
+ case Complex:
+ return TEMPLATE_COMPLEX.access();
+ case Double:
+ return TEMPLATE_DOUBLE.access();
+ case Integer:
+ return TEMPLATE_INTEGER.access();
+ case List:
+ return TEMPLATE_LIST.access();
+ case Expression:
+ return TEMPLATE_EXPRESSION.access();
+ case Logical:
+ return TEMPLATE_LOGICAL.access();
+ case Raw:
+ return TEMPLATE_RAW.access();
+ case RInteropChar:
+ case RInteropFloat:
+ case RInteropLong:
+ case RInteropShort:
+ default:
+ throw RInternalError.shouldNotReachHere();
+ }
+ }
+
+ public static VectorAccess createSlowPathNew(RType type) {
+ switch (type) {
+ case Character:
+ return TEMPLATE_CHARACTER.slowPathAccess();
+ case Complex:
+ return TEMPLATE_COMPLEX.slowPathAccess();
+ case Double:
+ return TEMPLATE_DOUBLE.slowPathAccess();
+ case Integer:
+ return TEMPLATE_INTEGER.slowPathAccess();
+ case List:
+ return TEMPLATE_LIST.slowPathAccess();
+ case Expression:
+ return TEMPLATE_EXPRESSION.slowPathAccess();
+ case Logical:
+ return TEMPLATE_LOGICAL.slowPathAccess();
+ case Raw:
+ return TEMPLATE_RAW.slowPathAccess();
+ case RInteropChar:
+ case RInteropFloat:
+ case RInteropLong:
+ case RInteropShort:
+ default:
+ throw RInternalError.shouldNotReachHere();
+ }
+ }
+}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/interop/TruffleObjectConverter.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/interop/TruffleObjectConverter.java
index 2bb74514a0..96de1c9491 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/interop/TruffleObjectConverter.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/interop/TruffleObjectConverter.java
@@ -49,6 +49,7 @@ import com.oracle.truffle.r.runtime.data.model.RAbstractListVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractLogicalVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractStringVector;
import com.oracle.truffle.r.runtime.data.model.RAbstractVector;
+import com.oracle.truffle.r.runtime.data.nodes.VectorAccess;
public final class TruffleObjectConverter {
@@ -288,6 +289,11 @@ public final class TruffleObjectConverter {
this.length = length;
}
+ @Override
+ public Object getInternalStore() {
+ return this;
+ }
+
@Override
public RAbstractVector copy() {
throw RInternalError.shouldNotReachHere();
@@ -407,6 +413,15 @@ public final class TruffleObjectConverter {
public ForeignAccess getForeignAccess() {
throw RInternalError.shouldNotReachHere();
}
- }
+ @Override
+ public VectorAccess access() {
+ throw RInternalError.unimplemented("access() for " + getClass().getSimpleName());
+ }
+
+ @Override
+ public VectorAccess slowPathAccess() {
+ throw RInternalError.unimplemented("slowPathAccess() for " + getClass().getSimpleName());
+ }
+ }
}
diff --git a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ops/na/NACheck.java b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ops/na/NACheck.java
index cbf0f6f606..cdb561977c 100644
--- a/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ops/na/NACheck.java
+++ b/com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ops/na/NACheck.java
@@ -120,6 +120,17 @@ public final class NACheck {
return false;
}
+ public boolean check(double real, double imag) {
+ if (state != NO_CHECK && RRuntime.isNA(real, imag)) {
+ if (state == CHECK_DEOPT) {
+ CompilerDirectives.transferToInterpreterAndInvalidate();
+ state = CHECK;
+ }
+ return true;
+ }
+ return false;
+ }
+
public void seenNA() {
if (state != CHECK) {
CompilerDirectives.transferToInterpreterAndInvalidate();
--
GitLab