ADD: SMod operation with UInt256

Signed-off-by: Thomas Zamojski <thomas.zamojski@quadratic-labs.com>

Author: thomas-quadratic

ethereum/core/src/jmh/java/org/hyperledger/besu/ethereum/vm/operations/SModOperationBenchmark.java

@@ -18,7 +18,113 @@
 import org.hyperledger.besu.evm.operation.Operation;
 import org.hyperledger.besu.evm.operation.SModOperation;
 
+import java.math.BigInteger;
+import java.util.concurrent.ThreadLocalRandom;
+
+import org.apache.tuweni.bytes.Bytes;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Setup;
+
 public class SModOperationBenchmark extends BinaryOperationBenchmark {
+  // Benches for a % b
+
+  // Define available scenarios
+  public enum Case {
+    SMOD_32_32(1, 1),
+    SMOD_64_32(2, 1),
+    SMOD_64_64(2, 2),
+    SMOD_128_32(4, 1),
+    SMOD_128_64(4, 2),
+    SMOD_128_128(4, 4),
+    SMOD_192_32(6, 1),
+    SMOD_192_64(6, 2),
+    SMOD_192_128(6, 4),
+    SMOD_192_192(6, 6),
+    SMOD_256_32(8, 1),
+    SMOD_256_64(8, 2),
+    SMOD_256_128(8, 4),
+    SMOD_256_192(8, 6),
+    SMOD_256_256(8, 8),
+    LARGER_SMOD_64_128(2, 4),
+    LARGER_SMOD_192_256(6, 8),
+    ZERO_SMOD_128_0(4, 0),
+    FULL_RANDOM(-1, -1);
+
+    final int divSize;
+    final int modSize;
+
+    Case(final int divSize, final int modSize) {
+      this.divSize = divSize;
+      this.modSize = modSize;
+    }
+  }
+
+  @Param({
+    "SMOD_32_32",
+    "SMOD_64_32",
+    "SMOD_64_64",
+    "SMOD_128_32",
+    "SMOD_128_64",
+    "SMOD_128_128",
+    "SMOD_192_32",
+    "SMOD_192_64",
+    "SMOD_192_128",
+    "SMOD_192_192",
+    "SMOD_256_32",
+    "SMOD_256_64",
+    "SMOD_256_128",
+    "SMOD_256_192",
+    "SMOD_256_256",
+    "LARGER_SMOD_64_128",
+    "LARGER_SMOD_192_256",
+    "ZERO_SMOD_128_0",
+    "FULL_RANDOM"
+  })
+  private String caseName;
+
+  @Setup(Level.Iteration)
+  @Override
+  public void setUp() {
+    frame = BenchmarkHelper.createMessageCallFrame();
+
+    Case scenario = Case.valueOf(caseName);
+    aPool = new Bytes[SAMPLE_SIZE];
+    bPool = new Bytes[SAMPLE_SIZE];
+
+    final ThreadLocalRandom random = ThreadLocalRandom.current();
+    int aSize;
+    int bSize;
+
+    for (int i = 0; i < SAMPLE_SIZE; i++) {
+      if (scenario.divSize < 0) aSize = random.nextInt(1, 33);
+      else aSize = scenario.divSize * 4;
+      if (scenario.modSize < 0) bSize = random.nextInt(1, 33);
+      else bSize = scenario.modSize * 4;
+
+      final byte[] a = new byte[aSize];
+      final byte[] b = new byte[bSize];
+      random.nextBytes(a);
+      random.nextBytes(b);
+
+      // Swap a and b if necessary
+      if ((scenario.divSize != scenario.modSize)) {
+        aPool[i] = Bytes.wrap(a);
+        bPool[i] = Bytes.wrap(b);
+      } else {
+        BigInteger aInt = new BigInteger(a);
+        BigInteger bInt = new BigInteger(b);
+        if ((aInt.abs().compareTo(bInt.abs()) < 0)) {
+          aPool[i] = Bytes.wrap(b);
+          bPool[i] = Bytes.wrap(a);
+        } else {
+          aPool[i] = Bytes.wrap(a);
+          bPool[i] = Bytes.wrap(b);
+        }
+      }
+    }
+    index = 0;
+  }
 
   @Override
   protected Operation.OperationResult invoke(final MessageFrame frame) {

evm/src/main/java/org/hyperledger/besu/evm/UInt256.java

@@ -14,6 +14,8 @@
  */
 package org.hyperledger.besu.evm;
 
+import java.util.Arrays;
+
 /**
  * 256-bits wide unsigned integer class.
  *
@@ -141,6 +143,45 @@ public static UInt256 fromBytesBE(final byte[] bytes) {
     return new UInt256(limbs, len);
   }
 
+  /**
+   * Instantiates a new UInt256 from byte[].
+   *
+   * @param bytes raw bytes in BigEndian order.
+   * @return Big-endian UInt256 represented by the bytes.
+   */
+  public static UInt256 fromSignedBytesBE(final byte[] bytes) {
+    int nBytes = bytes.length;
+    if (nBytes == 0) return ZERO;
+    int len = (nBytes + 3) / 4;
+    int[] limbs = new int[len];
+    // int[] limbs = new int[N_LIMBS];
+
+    int i;
+    int base;
+    // Up to most significant limb take 4 bytes.
+    for (i = 0, base = bytes.length - 4; i < len - 1; ++i, base = base - 4) {
+      limbs[i] =
+          (bytes[base] << 24)
+              | ((bytes[base + 1] & 0xFF) << 16)
+              | ((bytes[base + 2] & 0xFF) << 8)
+              | ((bytes[base + 3] & 0xFF));
+    }
+    // Last effective limb
+    limbs[i] =
+        switch (nBytes - i * 4) {
+          case 1 -> ((bytes[0]));
+          case 2 -> (((bytes[0]) << 8) | (bytes[1] & 0xFF));
+          case 3 -> (((bytes[0]) << 16) | ((bytes[1] & 0xFF) << 8) | (bytes[2] & 0xFF));
+          case 4 ->
+              ((bytes[0] << 24)
+                  | ((bytes[1] & 0xFF) << 16)
+                  | ((bytes[2] & 0xFF) << 8)
+                  | (bytes[3] & 0xFF));
+          default -> throw new IllegalStateException("Unexpected value");
+        };
+    return new UInt256(limbs, len);
+  }
+
   /**
    * Instantiates a new UInt256 from an int.
    *
@@ -168,7 +209,6 @@ public static UInt256 fromLong(final long value) {
 
   // region Conversions
   // --------------------------------------------------------------------------
-
   /**
    * Convert to int.
    *
@@ -214,6 +254,43 @@ public byte[] toBytesBE() {
     return out;
   }
 
+  /**
+   * Convert to BigEndian byte array.
+   *
+   * @return Big-endian ordered bytes for this UInt256 value.
+   */
+  public byte[] toSignedBytesBE() {
+    byte[] out = new byte[32];
+    if (length > 0 && limbs[length - 1] < 0) Arrays.fill(out, (byte) 0xFF);
+    for (int i = 0, offset = 28; i < length; i++, offset -= 4) {
+      int v = limbs[i];
+      out[offset] = (byte) (v >>> 24);
+      out[offset + 1] = (byte) (v >>> 16);
+      out[offset + 2] = (byte) (v >>> 8);
+      out[offset + 3] = (byte) v;
+    }
+    return out;
+  }
+
+  /**
+   * Convert to BigEndian byte array.
+   *
+   * @param sign if sign is negative, pad with 1s, else pad with 0s.
+   * @return Big-endian ordered bytes for this UInt256 value.
+   */
+  public byte[] toSignedBytesBE(final int sign) {
+    byte[] out = new byte[32];
+    if (sign < 0) Arrays.fill(out, (byte) 0xFF);
+    for (int i = 0, offset = 28; i < length; i++, offset -= 4) {
+      int v = limbs[i];
+      out[offset] = (byte) (v >>> 24);
+      out[offset + 1] = (byte) (v >>> 16);
+      out[offset + 2] = (byte) (v >>> 8);
+      out[offset + 3] = (byte) v;
+    }
+    return out;
+  }
+
   @Override
   public String toString() {
     StringBuilder sb = new StringBuilder("0x");
@@ -231,6 +308,33 @@ public String toString() {
     return sb.toString();
   }
 
+  /**
+   * Convert to hexstring according to sign.
+   *
+   * <p>If sign is negative, pad with 1s, else pad with 0s.
+   * </p>
+   *
+   * @param sign padding with 0s or 1s whether sign is non-negative.
+   * @return HexString
+   */
+  public String toString(final int sign) {
+    if (sign >= 0) return toString();
+    StringBuilder sb = new StringBuilder("0x");
+    byte[] out = new byte[length * 4];
+    Arrays.fill(out, (byte) 0xFF);
+    for (int i = 0, offset = 4 * (length - 1); i < length; i++, offset -= 4) {
+      int v = limbs[i];
+      out[offset] = (byte) (v >>> 24);
+      out[offset + 1] = (byte) (v >>> 16);
+      out[offset + 2] = (byte) (v >>> 8);
+      out[offset + 3] = (byte) v;
+    }
+    for (byte b : out) {
+      sb.append(String.format("%02x", b));
+    }
+    return sb.toString();
+  }
+
   // --------------------------------------------------------------------------
   // endregion
 
@@ -330,6 +434,17 @@ public UInt256 shiftRight(final int shift) {
   // region Arithmetic Operations
   // --------------------------------------------------------------------------
 
+  /**
+   * (Signed) absolute value
+   *
+   * @return The absolute value of this signed integer.
+   */
+  public UInt256 abs() {
+    int[] newLimbs = Arrays.copyOf(limbs, length);
+    absInplace(newLimbs);
+    return new UInt256(newLimbs, length);
+  }
+
   /**
    * Addition (modulo 2**256).
    *
@@ -356,7 +471,7 @@ public UInt256 mul(final UInt256 other) {
   }
 
   /**
-   * Reduce modulo modulus.
+   * Unsigned modulo reduction.
    *
    * @param modulus The modulus of the reduction
    * @return The remainder modulo {@code modulus}.
@@ -368,6 +483,28 @@ public UInt256 mod(final UInt256 modulus) {
     return new UInt256(knuthRemainder(this.limbs, modulus.limbs));
   }
 
+  /**
+   * Signed modulo reduction.
+   *
+   * @param modulus The modulus of the reduction
+   * @return The remainder modulo {@code modulus}.
+   */
+  public UInt256 signedMod(final UInt256 modulus) {
+    if (this.isZero() || modulus.isZero()) return ZERO;
+    int[] x = new int[this.length];
+    int[] y = new int[modulus.length];
+    absInto(x, this.limbs);
+    absInto(y, modulus.limbs);
+    int[] r = knuthRemainder(x, y);
+    if (isNegative(this.limbs)) {
+      int[] s = new int[N_LIMBS];
+      System.arraycopy(r, 0, s, 0, r.length);
+      negate(s);
+      return new UInt256(s);
+    }
+    return new UInt256(r);
+  }
+
   /**
    * Modular addition.
    *
@@ -404,6 +541,27 @@ public UInt256 mulMod(final UInt256 other, final UInt256 modulus) {
 
   // region Support (private) Algorithms
   // --------------------------------------------------------------------------
+  private static boolean isNegative(final int[] x) {
+    return x[x.length - 1] < 0;
+  }
+
+  private static void negate(final int[] x) {
+    int carry = 1;
+    for (int i = 0; i < x.length; i++) {
+      x[i] = ~x[i] + carry;
+      carry = (x[i] == 0 && carry == 1) ? 1 : 0;
+    }
+  }
+
+  private static void absInplace(final int[] x) {
+    if (isNegative(x)) negate(x);
+  }
+
+  private static void absInto(final int[] dst, final int[] src) {
+    System.arraycopy(src, 0, dst, 0, Math.min(dst.length, src.length));
+    absInplace(dst);
+  }
+
   private static int numberOfLeadingZeros(final int[] x, final int limit) {
     int leadingIndex = limit - 1;
     while ((leadingIndex >= 0) && (x[leadingIndex] == 0)) leadingIndex--;
@@ -529,6 +687,7 @@ private static int[] knuthRemainder(final int[] dividend, final int[] modulus) {
     int n = modulus.length - limbShift;
     if (n == 0) return new int[0];
     if (n == 1) {
+      if (dividend.length == 1) return (new int[] {dividend[0] % modulus[0]});
       long d = modulus[0] & MASK_L;
       long rem = 0;
       // Process from most significant limb downwards