GoL

Author: Pastor

vol_/src/main/java/ru/mifi/practice/voln/cache/Main.java

@@ -9,15 +9,20 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 public abstract class Main {
+
+    public static final int TICK = 1000000000;
+
     public static void main(String[] args) throws Exception {
         MeterRegistry registry = new SimpleMeterRegistry();
-//        CacheMap map = new CacheMapRedis("redis://localhost/1");
+//        CacheableMap map = new CacheableMapRedis("redis://localhost/1");
         CacheableMap map = new CacheableMapMemory(registry);
-        try (Notifiable notify = new NotifiableMemory(10000, registry);
-             SimpleCacheableValue balance = new SimpleCacheableValue(map, notify, Main::fetchBalance, 1000, 1000)) {
+        Notifiable notify = new NotifiableMemory(10000, registry);
+//        Notifiable notify = new NotifiableRedis("redis://localhost/1", registry);
+        try (SimpleCacheableValue balance = new SimpleCacheableValue(map, notify, Main::fetchBalance, 1000, 1000)) {
             CacheableValue.Value last = null;
             AtomicInteger hint = new AtomicInteger(0);
-            for (int i = 1; i <= 1000000000; i++) {
+            long nanoTime = System.nanoTime();
+            for (int i = 0; i < TICK; i++) {
                 Optional<CacheableValue.Value> value = balance.getValue(1011185);
                 if (value.isPresent()) {
                     CacheableValue.Value v = value.get();
@@ -35,8 +40,8 @@ public static void main(String[] args) throws Exception {
                     System.err.println("Value not found");
                 }
             }
+            System.out.println("Завершили. " + (System.nanoTime() - nanoTime) / TICK + "ns");
         }
-        System.out.println("Завершили");
     }
 
     private static long fetchBalance(long userId) {

vol_/src/main/java/ru/mifi/practice/voln/cache/redis/NotifiableRedis.java

@@ -31,6 +31,10 @@ public NotifiableRedis(RedisClient client, MeterRegistry registry) {
         Gauge.builder("CacheNotifyRedis", inOrderSize, AtomicInteger::intValue).tag("target", "in-order-size").register(registry);
     }
 
+    public NotifiableRedis(String url, MeterRegistry registry) {
+        this(RedisClient.create(url), registry);
+    }
+
     @Override
     public void registerNotify(String updateChannel, Consumer<Long> callback) {
         pubSub.addListener(new RedisPubSubAdapter<>() {

vol_/src/main/java/ru/mifi/practice/voln/fsm/BytesMatrix.java

@@ -0,0 +1,68 @@
+package ru.mifi.practice.voln.fsm;
+
+import java.util.BitSet;
+
+public interface BytesMatrix {
+
+    int rows();
+
+    int cols();
+
+    byte get(int row, int col);
+
+    void set(int row, int col, byte value);
+
+    BytesMatrix copy();
+
+    record BytesTorusBits(int rows, int cols, BitSet bitSet) implements BytesMatrix {
+        public BytesTorusBits(int rows, int cols) {
+            this(rows, cols, new BitSet(rows * cols));
+        }
+
+        @Override
+        public byte get(int row, int col) {
+            row = row / rows;
+            col = col / cols;
+            return (byte) (bitSet.get(row * cols + col) ? 1 : 0);
+        }
+
+        @Override
+        public void set(int row, int col, byte value) {
+            row = row / rows;
+            col = col / cols;
+            bitSet.set(row * cols + col, value);
+        }
+
+        @Override
+        public BytesTorusBits copy() {
+            return new BytesTorusBits(rows, cols, (BitSet) bitSet.clone());
+        }
+    }
+
+    record BytesTorusMatrix(int rows, int cols, byte[] data) implements BytesMatrix {
+        public BytesTorusMatrix(int rows, int cols) {
+            this(rows, cols, new byte[rows * cols]);
+        }
+
+        @Override
+        public byte get(int row, int col) {
+            row = row / rows;
+            col = col / cols;
+            return data[row * cols + col];
+        }
+
+        @Override
+        public void set(int row, int col, byte value) {
+            row = row / rows;
+            col = col / cols;
+            data[row * cols + col] = value;
+        }
+
+        @Override
+        public BytesMatrix copy() {
+            BytesTorusMatrix matrix = new BytesTorusMatrix(rows, cols);
+            System.arraycopy(data, 0, matrix.data, 0, data.length);
+            return matrix;
+        }
+    }
+}

vol_/src/main/java/ru/mifi/practice/voln/fsm/GoL.java

@@ -0,0 +1,47 @@
+package ru.mifi.practice.voln.fsm;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class GoL {
+    private final AtomicInteger ticks = new AtomicInteger(0);
+    private BytesMatrix matrix;
+
+    public GoL(BytesMatrix matrix) {
+        this.matrix = matrix;
+    }
+
+    private static byte mutate(BytesMatrix matrix, int row, int col) {
+        byte v = matrix.get(row, col);
+        int total = count(matrix.get(row, col - 1)) + count(matrix.get(row, col + 1)) +
+            count(matrix.get(row - 1, col)) + count(matrix.get(row + 1, col)) +
+            count(matrix.get(row - 1, col - 1)) + count(matrix.get(row - 1, col + 1)) +
+            count(matrix.get(row + 1, col - 1)) + count(matrix.get(row + 1, col + 1));
+        if (is(matrix.get(row, col))) {
+            if (total < 2 || total > 3) {
+                return 0;
+            }
+        } else if (total == 3) {
+            return 1;
+        }
+        return v;
+    }
+
+    private static boolean is(byte v) {
+        return v == 1;
+    }
+
+    private static int count(byte v) {
+        return v;
+    }
+
+    public void tick() {
+        BytesMatrix copied = matrix.copy();
+        for (int row = 0; row < matrix.rows(); row++) {
+            for (int col = 0; col < matrix.cols(); col++) {
+                copied.set(row, col, mutate(matrix, row, col));
+            }
+        }
+        matrix = copied;
+        ticks.incrementAndGet();
+    }
+}