feat: simplify thread storage & remove debug

xxDark · Mar 19, 2022 · 909dc62 · 909dc62
1 parent 11b912d
commit 909dc62
Show file tree

Hide file tree

Showing 4 changed files with 24 additions and 31 deletions.
diff --git a/src/main/java/dev/xdark/ssvm/natives/MethodHandleNatives.java b/src/main/java/dev/xdark/ssvm/natives/MethodHandleNatives.java
@@ -183,11 +183,6 @@ public void init(VirtualMachine vm) {
 
 				val owner = jm.getOwner();
 				lvt = compactForExecution(lvt);
-				try {
-					Util.convertInvokeDynamicArgs(vm, jm.getArgumentTypes(), lvt);
-				} catch (ArrayIndexOutOfBoundsException dbg) {
-					int x = 5;
-				}
 				Value result;
 				if ((jm.getAccess() & ACC_STATIC) == 0) {
 					int flags = vmentry.getInt("flags");

diff --git a/src/main/java/dev/xdark/ssvm/thread/SimpleThreadStorage.java b/src/main/java/dev/xdark/ssvm/thread/SimpleThreadStorage.java
@@ -5,9 +5,6 @@
 import dev.xdark.ssvm.value.Value;
 import lombok.val;
 
-import java.util.Arrays;
-import java.util.List;
-
 /**
  * Thread cache for VM.
  *
@@ -17,22 +14,23 @@ public class SimpleThreadStorage implements ThreadStorage {
 
 	private static final ThreadLocal<SimpleThreadStorage> THREAD_LOCAL = ThreadLocal.withInitial(SimpleThreadStorage::create);
 	private static final int DEFAULT_STORAGE_SIZE = 65536;
-	private final List<Value> storage;
+	private final Value[] storage;
 	private int currentIndex;
 
 	private SimpleThreadStorage(int maxSize) {
-		storage = Arrays.asList(new Value[maxSize]);
+		storage = new Value[maxSize];
 	}
 
 	@Override
 	public ThreadRegion push(int size) {
 		int currentIndex = this.currentIndex;
 		int toIndex = currentIndex + size;
 		val storage = this.storage;
-		if (toIndex >= storage.size()) {
+		if (toIndex >= storage.length) {
 			throw new IndexOutOfBoundsException();
 		}
-		val region = new ThreadRegion(storage.subList(currentIndex, toIndex), this);
+
+		val region = new ThreadRegion(storage, currentIndex, toIndex, this);
 		this.currentIndex = toIndex;
 		return region;
 	}

diff --git a/src/main/java/dev/xdark/ssvm/thread/ThreadRegion.java b/src/main/java/dev/xdark/ssvm/thread/ThreadRegion.java
@@ -3,23 +3,21 @@
 import dev.xdark.ssvm.util.ArraySlice;
 import dev.xdark.ssvm.value.Value;
 
-import java.util.List;
-
 /**
  * @see ArraySlice
  */
 public final class ThreadRegion extends ArraySlice<Value> implements AutoCloseable {
 
 	private final ThreadStorage storage;
 
-	ThreadRegion(List<Value> array, ThreadStorage storage) {
-		super(array);
+	public ThreadRegion(Value[] array, int fromIndex, int toIndex, ThreadStorage storage) {
+		super(array, fromIndex, toIndex);
 		this.storage = storage;
 	}
 
 	@Override
 	public ThreadRegion slice(int fromIndex, int toIndex) {
-		return new ThreadRegion(array.subList(fromIndex, toIndex), storage);
+		return new ThreadRegion(array, map(fromIndex), map(toIndex), storage);
 	}
 
 	@Override

diff --git a/src/main/java/dev/xdark/ssvm/util/ArraySlice.java b/src/main/java/dev/xdark/ssvm/util/ArraySlice.java
@@ -4,11 +4,10 @@
 import lombok.RequiredArgsConstructor;
 import lombok.experimental.FieldDefaults;
 
-import java.lang.reflect.Array;
-import java.util.List;
+import java.util.Arrays;
 
 /**
- * Slice of the array
+ * Slice of the array.
  *
  * @param <V>
  *      Component type.
@@ -19,18 +18,20 @@
 @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
 public class ArraySlice<V> {
 
-	protected List<V> array;
+	protected V[] array;
+	private final int fromIndex;
+	private final int toIndex;
 
 	/**
 	 * Sets element.
 	 *
 	 * @param index
 	 *      Element index.
 	 * @param value
-	 *      Eleemnt value.
+	 *      Element value.
 	 */
 	public void set(int index, V value) {
-		array.set(index, value);
+		array[map(index)] = value;
 	}
 
 	/**
@@ -40,24 +41,21 @@ public void set(int index, V value) {
 	 * @return element by it's index.
 	 */
 	public V get(int index) {
-		return array.get(index);
+		return array[map(index)];
 	}
 
 	/**
 	 * @return size of array slice.
 	 */
 	public int length() {
-		return array.size();
+		return toIndex - fromIndex;
 	}
 
 	/**
-	 * @param typeHint
-	 *      Type hint to create an array.
-	 *
 	 * @return backing array.
 	 */
-	public V[] unwrap(V... typeHint) {
-		return array.toArray((V[]) Array.newInstance(typeHint.getClass().getComponentType(), 0));
+	public V[] unwrap() {
+		return Arrays.copyOfRange(array, fromIndex, toIndex);
 	}
 
 	/**
@@ -69,6 +67,10 @@ public V[] unwrap(V... typeHint) {
 	 * @return slice of this slice.
 	 */
 	public ArraySlice<V> slice(int fromIndex, int toIndex) {
-		return new ArraySlice<>(array.subList(fromIndex, toIndex));
+		return new ArraySlice<>(array, map(fromIndex), map(toIndex));
+	}
+
+	protected int map(int index) {
+		return index + fromIndex;
 	}
 }