Model by Path(URI) and with Chunking (#38)

* Model by Path(URI) and with Chunking

* Address DeepSource and Deprecate future final(s)

* default 512mb

* add doc

Author: sazzad16

README.md

@@ -58,3 +58,10 @@ and
 
    client.runModel("model", new String[] {"a", "b"}, new String[] {"c"});
 ```
+
+### Note
+
+Since version `0.10.0`, the chunk size of model (blob) is set to 512mb (536870912 bytes) based on default Redis 
+configuration. This behavior can be changed by `redisai.blob.chunkSize` system property at the beginning of the 
+application. For example, chunk size can be limited to 8mb by setting `-Dredisai.blob.chunkSize=8388608` or 
+`System.setProperty(Model.BLOB_CHUNK_SIZE_PROPERTY, "8388608");`. A limit of 0 (zero) would disable chunking.

src/main/java/com/redislabs/redisai/Model.java

@@ -1,24 +1,47 @@
 package com.redislabs.redisai;
 
 import com.redislabs.redisai.exceptions.JRedisAIRunTimeException;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import redis.clients.jedis.Protocol;
 import redis.clients.jedis.util.SafeEncoder;
 
 /** Direct mapping to RedisAI Model */
 public class Model {
 
-  private Backend backend;
-  private Device device;
+  public static final String BLOB_CHUNK_SIZE_PROPERTY = "redisai.blob.chunkSize";
+
+  private static final int BLOB_CHUNK_SIZE =
+      Integer.parseInt(System.getProperty(BLOB_CHUNK_SIZE_PROPERTY, "536870912"));
+
+  private Backend backend; // TODO: final
+  private Device device; // TODO: final
   private String[] inputs;
   private String[] outputs;
-  private byte[] blob;
+  private byte[] blob; // TODO: final
   private String tag;
   private long batchSize;
   private long minBatchSize;
   private long minBatchTimeout;
 
+  /**
+   * @param backend - the backend for the model. can be one of TF, TFLITE, TORCH or ONNX
+   * @param device - the device that will execute the model. can be of CPU or GPU
+   * @param modelUri - filepath of the Protobuf-serialized model
+   * @throws java.io.IOException
+   * @see #Model(com.redislabs.redisai.Backend, com.redislabs.redisai.Device, byte[])
+   * @see Files#readAllBytes(java.nio.file.Path)
+   * @see Paths#get(java.net.URI)
+   */
+  public Model(Backend backend, Device device, URI modelUri) throws IOException {
+    this(backend, device, Files.readAllBytes(Paths.get(modelUri)));
+  }
+
   /**
    * @param backend - the backend for the model. can be one of TF, TFLITE, TORCH or ONNX
    * @param device - the device that will execute the model. can be of CPU or GPU
@@ -166,6 +189,11 @@ public byte[] getBlob() {
     return blob;
   }
 
+  /**
+   * @param blob
+   * @deprecated This variable will be final. Use any constructor.
+   */
+  @Deprecated
   public void setBlob(byte[] blob) {
     this.blob = blob;
   }
@@ -192,6 +220,11 @@ public Device getDevice() {
     return device;
   }
 
+  /**
+   * @param device
+   * @deprecated This variable will be final. Use any constructor.
+   */
+  @Deprecated
   public void setDevice(Device device) {
     this.device = device;
   }
@@ -200,6 +233,11 @@ public Backend getBackend() {
     return backend;
   }
 
+  /**
+   * @param backend
+   * @deprecated This variable will be final. Use any constructor.
+   */
+  @Deprecated
   public void setBackend(Backend backend) {
     this.backend = backend;
   }
@@ -314,11 +352,26 @@ protected List<byte[]> getModelStoreCommandArgs(String key) {
     }
 
     args.add(Keyword.BLOB.getRaw());
-    args.add(blob);
+    collectChunks(args, blob);
 
     return args;
   }
 
+  private static void collectChunks(List<byte[]> collector, byte[] array) {
+    final int chunkSize = BLOB_CHUNK_SIZE;
+    if (chunkSize <= 0 || array.length <= chunkSize) {
+      collector.add(array);
+      return;
+    }
+
+    int from = 0;
+    while (from < array.length) {
+      int copySize = Math.min(array.length - from, chunkSize);
+      collector.add(Arrays.copyOfRange(array, from, from + copySize));
+      from += copySize;
+    }
+  }
+
   protected static List<byte[]> modelRunFlatArgs(
       String key, String[] inputs, String[] outputs, boolean includeCommandName) {
     List<byte[]> args = new ArrayList<>();

src/test/java/com/redislabs/redisai/ChunkTest.java

@@ -0,0 +1,55 @@
+package com.redislabs.redisai;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+@Ignore
+public class ChunkTest {
+
+  private static final int SMALL_CHUNK_SIZE = 8 * 1024; // 8KB
+
+  @BeforeClass
+  public static void prepare() {
+    System.setProperty(Model.BLOB_CHUNK_SIZE_PROPERTY, Integer.toString(SMALL_CHUNK_SIZE));
+  }
+
+  @AfterClass
+  public static void cleanUp() {
+    System.clearProperty(Model.BLOB_CHUNK_SIZE_PROPERTY);
+  }
+
+  /**
+   * @throws java.net.URISyntaxException
+   * @throws java.io.IOException
+   * @see ModelTest#argumentsWithoutChunking()
+   */
+  @Test
+  public void argumentsWithChunking() throws URISyntaxException, IOException {
+    Model model =
+        new Model(
+            Backend.ONNX,
+            Device.GPU,
+            getClass().getClassLoader().getResource("test_data/mnist.onnx").toURI());
+
+    Assert.assertEquals(8, model.getModelStoreCommandArgs("key").size());
+  }
+
+  @Test
+  public void commandWithChunking() throws IOException, URISyntaxException {
+    Model model =
+        new Model(
+            Backend.ONNX,
+            Device.CPU,
+            getClass().getClassLoader().getResource("test_data/mnist.onnx").toURI());
+
+    try (RedisAI ai = new RedisAI()) {
+      Assert.assertTrue(ai.storeModel("model-chunk", model));
+      Assert.assertNotNull(ai.getModel("model-chunk"));
+    }
+  }
+}

src/test/java/com/redislabs/redisai/ModelTest.java

@@ -1,6 +1,8 @@
 package com.redislabs.redisai;
 
 import com.redislabs.redisai.exceptions.JRedisAIRunTimeException;
+import java.io.IOException;
+import java.net.URISyntaxException;
 import java.util.List;
 import org.junit.Assert;
 import org.junit.Before;
@@ -37,11 +39,11 @@ public void getSetBlob() {
     byte[] expected = new byte[0];
     Model model = new Model(Backend.ONNX, Device.GPU, new String[0], new String[0], expected);
     byte[] blob = model.getBlob();
-    Assert.assertEquals(blob, expected);
+    Assert.assertSame(blob, expected);
     byte[] expected2 = new byte[] {0x10};
     model.setBlob(expected2);
     blob = model.getBlob();
-    Assert.assertEquals(blob, expected2);
+    Assert.assertSame(blob, expected2);
   }
 
   @Test
@@ -104,6 +106,22 @@ public void getSetMinBatchSize() {
     Assert.assertEquals(10, minbatchsize);
   }
 
+  /**
+   * @throws java.net.URISyntaxException
+   * @throws java.io.IOException
+   * @see ChunkTest#argumentsWithChunking()
+   */
+  @Test
+  public void argumentsWithoutChunking() throws URISyntaxException, IOException {
+    Model model =
+        new Model(
+            Backend.ONNX,
+            Device.GPU,
+            getClass().getClassLoader().getResource("test_data/mnist.onnx").toURI());
+
+    Assert.assertEquals(5, model.getModelStoreCommandArgs("key").size());
+  }
+
   @Test
   public void createModelFromRespReply() {
     // negative testing

src/test/java/com/redislabs/redisai/RedisAITest.java

@@ -1,6 +1,8 @@
 package com.redislabs.redisai;
 
 import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.Map;
@@ -256,8 +258,12 @@ public void storeModel() throws IOException {
     String[] outputs = new String[] {"mul"};
     byte[] blob = IOUtils.resourceToByteArray("test_data/graph.pb", getClass().getClassLoader());
 
-    Model createdModel = new Model(Backend.TF, Device.CPU, inputs, outputs, blob);
+    Model createdModel = new Model(Backend.TF, Device.CPU, blob);
+    createdModel.setInputs(inputs);
+    createdModel.setOutputs(outputs);
+
     Assert.assertTrue(client.storeModel("model-1", createdModel));
+
     Model readModel1 = client.getModel("model-1");
     Assert.assertEquals(Backend.TF, readModel1.getBackend());
     Assert.assertEquals(Device.CPU, readModel1.getDevice());
@@ -272,7 +278,9 @@ public void storeModel() throws IOException {
     createdModel.setMinBatchSize(5);
     createdModel.setMinBatchTimeout(15);
     createdModel.setTag("test batching params");
+
     Assert.assertTrue(client.storeModel("model-2", createdModel));
+
     Model readModel2 = client.getModel("model-2");
     Assert.assertEquals(Backend.TF, readModel2.getBackend());
     Assert.assertEquals(Device.CPU, readModel2.getDevice());
@@ -284,6 +292,29 @@ public void storeModel() throws IOException {
     Assert.assertEquals("test batching params", readModel2.getTag());
   }
 
+  @Test
+  public void storeModelByPath() throws URISyntaxException, IOException {
+    String[] inputs = new String[] {"a", "b"};
+    String[] outputs = new String[] {"mul"};
+    URL modelUrl = getClass().getClassLoader().getResource("test_data/graph.pb");
+
+    Model createdModel = new Model(Backend.TF, Device.CPU, modelUrl.toURI());
+    createdModel.setInputs(inputs);
+    createdModel.setOutputs(outputs);
+
+    Assert.assertTrue(client.storeModel("model-uri", createdModel));
+
+    Model readModel = client.getModel("model-uri");
+    Assert.assertEquals(Backend.TF, readModel.getBackend());
+    Assert.assertEquals(Device.CPU, readModel.getDevice());
+    Assert.assertArrayEquals(inputs, readModel.getInputs());
+    Assert.assertArrayEquals(outputs, readModel.getOutputs());
+    Assert.assertEquals(0L, readModel.getBatchSize());
+    Assert.assertEquals(0L, readModel.getMinBatchSize());
+    Assert.assertEquals(0L, readModel.getMinBatchTimeout());
+    Assert.assertEquals("", readModel.getTag());
+  }
+
   @Test
   public void storeModelFail() throws IOException {
     try {