Refactor tests: use the new commands instead of the deprecated ones. Use "tests_commands" to test the new commands syntax (not for a specific backend), and test the deprecated commands only in "test_deprecated".

Update AI.MODELSTORE documentation.

Author: alonre24

README.md

@@ -46,7 +46,7 @@ Note that Redis config is located at `/usr/local/etc/redis/redis.conf` which can
 
 On the client, set the model
 ```sh
-redis-cli -x AI.MODELSET foo TF CPU INPUTS a b OUTPUTS c BLOB < tests/test_data/graph.pb
+redis-cli -x AI.MODELSTORE foo TF CPU INPUTS 2 a b OUTPUTS 1 c BLOB < tests/test_data/graph.pb
 ```
 
 Then create the input tensors, run the computation graph and get the output tensor (see `load_model.sh`). Note the signatures:

docs/commands.md

@@ -152,15 +152,15 @@ redis> AI.TENSORGET mytensor META BLOB
 !!! important "Using `BLOB` is preferable to `VALUES`"
     While it is possible to get the tensor as binary data or numerical values, it is recommended that you use the `BLOB` option. It requires fewer resources and performs better compared to returning the values discretely.
 
-## AI.MODELSET
-The **`AI.MODELSET`** commands stores a model as the value of a key.
+## AI.MODELSTORE
+The **`AI.MODELSTORE`** command stores a model as the value of a key.
 
 **Redis API**
 
 ```
-AI.MODELSET <key> <backend> <device>
-    [TAG tag] [BATCHSIZE n [MINBATCHSIZE m]]
-    [INPUTS <name> ...] [OUTPUTS name ...] BLOB <model>
+AI.MODELSTORE <key> <backend> <device>
+    [TAG tag] [BATCHSIZE n [MINBATCHSIZE m [MINBATCHTIMEOUT t]]]
+    [INPUTS <input_count> <name> ...] [OUTPUTS <output_count> <name> ...] BLOB <model>
 ```
 
 _Arguments_
@@ -176,11 +176,13 @@ _Arguments_
     * **GPU**: a GPU device
     * **GPU:0**, ..., **GPU:n**: a specific GPU device on a multi-GPU system
 * **TAG**: an optional string for tagging the model such as a version number or any arbitrary identifier
-* **BATCHSIZE**: when provided with an `n` that is greater than 0, the engine will batch incoming requests from multiple clients that use the model with input tensors of the same shape. When `AI.MODELRUN` is called the requests queue is visited and input tensors from compatible requests are concatenated along the 0th (batch) dimension until `n` is exceeded. The model is then run for the entire batch and the results are unpacked back to the individual requests unblocking their respective clients. If the batch size of the inputs to of first request in the queue exceeds `BATCHSIZE`, the request is served immediately (default value: 0).
-* **MINBATCHSIZE**: when provided with an `m` that is greater than 0, the engine will postpone calls to `AI.MODELRUN` until the batch's size had reached `m`. In this case, note that requests for which `m` is not reached will hang indefinitely (default value: 0), unless `MINBATCHTIMEOUT` is provided.
-* **MINBATCHTIMEOUT**: when provided with a `t` (expressed in milliseconds) that is greater than 0, the engine will trigger a run even though `MINBATCHSIZE` has not been reached after `t` milliseconds from the time a `MODELRUN` (or the enclosing `DAGRUN`) is enqueued. This only applies to cases where both `BATCHSIZE` and `MINBATCHSIZE` are greater than 0.
-* **INPUTS**: one or more names of the model's input nodes (applicable only for TensorFlow models)
-* **OUTPUTS**: one or more names of the model's output nodes (applicable only for TensorFlow models)
+* **BATCHSIZE**: when provided with an `n` that is greater than 0, the engine will batch incoming requests from multiple clients that use the model with input tensors of the same shape. When `AI.MODELEXECUTE` (or `AI.MODELRUN`) is called the requests queue is visited and input tensors from compatible requests are concatenated along the 0th (batch) dimension until `n` is exceeded. The model is then run for the entire batch and the results are unpacked back to the individual requests unblocking their respective clients. If the batch size of the inputs to of first request in the queue exceeds `BATCHSIZE`, the request is served immediately (default value: 0).
+* **MINBATCHSIZE**: when provided with an `m` that is greater than 0, the engine will postpone calls to `AI.MODELEXECUTE` until the batch's size had reached `m`. In this case, note that requests for which `m` is not reached will hang indefinitely (default value: 0), unless `MINBATCHTIMEOUT` is provided.
+* **MINBATCHTIMEOUT**: when provided with a `t` (expressed in milliseconds) that is greater than 0, the engine will trigger a run even though `MINBATCHSIZE` has not been reached after `t` milliseconds from the time a `MODELEXECUTE` (or the enclosing `DAGRUN`) is enqueued. This only applies to cases where both `BATCHSIZE` and `MINBATCHSIZE` are greater than 0.
+* **INPUTS**: denotes that one or more names of the model's input nodes are following (applicable only for TensorFlow models)
+* **input_count**: a positive number that indicates the number of following input nodes. 
+* **OUTPUTS**: denotes that one or more names of the model's output nodes are following (applicable only for TensorFlow models)
+* **output_count**: a positive number that indicates the number of following input nodes. 
 * **model**: the Protobuf-serialized model. Since Redis supports strings up to 512MB, blobs for very large models need to be chunked, e.g. `BLOB chunk1 chunk2 ...`.
 
 _Return_
@@ -192,10 +194,22 @@ A simple 'OK' string or an error.
 This example shows to set a model 'mymodel' key using the contents of a local file with [`redis-cli`](https://redis.io/topics/cli). Refer to the [Clients Page](clients.md) for additional client choices that are native to your programming language:
 
 ```
-$ cat resnet50.pb | redis-cli -x AI.MODELSET mymodel TF CPU TAG imagenet:5.0 INPUTS images OUTPUTS output BLOB
+$ cat resnet50.pb | redis-cli -x AI.MODELSTORE mymodel TF CPU TAG imagenet:5.0 INPUTS 1 images OUTPUTS 1 output BLOB
 OK
 ```
 
+## AI.MODELSET
+_This command is deprecated and will not be available in future versions. consider using AI.MODELSTORE command instead._
+The **`AI.MODELSET`** command stores a model as the value of a key. The command's arguments and effect are both exactly the same as `AI.MODELEXECUTE` command, except that <input_count> and <output_count> arguments should not be specified for TF backend. 
+
+**Redis API**
+
+```
+AI.MODELSET <key> <backend> <device>
+    [TAG tag] [BATCHSIZE n [MINBATCHSIZE m [MNBATCHTIMEOUT t]]]
+    [INPUTS <name> ...] [OUTPUTS name ...] BLOB <model>
+```
+
 ## AI.MODELGET
 The **`AI.MODELGET`** command returns a model's metadata and blob stored as a key's value.
 
@@ -303,9 +317,9 @@ _Arguments_
 
 * **key**: the model's key name
 * **INPUTS**: denotes the beginning of the input tensors keys' list, followed by the number of inputs and one or more key names
-* **input_count**: A positive number that indicates the number of following input keys. 
+* **input_count**: a positive number that indicates the number of following input keys. 
 * **OUTPUTS**: denotes the beginning of the output tensors keys' list, followed by the number of outputs one or more key names
-* **output_count**: A positive number that indicates the number of output keys to follow.
+* **output_count**: a positive number that indicates the number of output keys to follow.
 * **TIMEOUT**: the time (in ms) after which the client is unblocked and a `TIMEDOUT` string is returned
 
 _Return_

docs/intro.md

@@ -193,7 +193,7 @@ RedisAI Tensors are used as inputs and outputs in the execution of models and sc
 ## Loading Models
 A **Model** is a Deep Learning or Machine Learning frozen graph that was generated by some framework. The RedisAI Model data structure represents a DL/ML model that is stored in the database and can be run.
 
-Models, like any other Redis and RedisAI data structures, are identified by keys. A Model's key is created using the [`AI.MODELSET` command](commands.md#aimodelset) and requires the graph payload serialized as protobuf for input.
+Models, like any other Redis and RedisAI data structures, are identified by keys. A Model's key is created using the [`AI.MODELSTORE` command](commands.md#aimodelstore) and requires the graph payload serialized as protobuf for input.
 
 In our examples, we'll use one of the graphs that RedisAI uses in its tests, namely 'graph.pb', which can be downloaded from [here](https://github.com/RedisAI/RedisAI/raw/master/tests/test_data/graph.pb). This graph was created using TensorFlow with [this script](https://github.com/RedisAI/RedisAI/blob/master/tests/test_data/tf-minimal.py).
 
@@ -214,13 +214,13 @@ redis-cli doesn't provide a way to read files' contents, so to load the model wi
 
 ```
 cat graph.pb | docker exec -i redisai redis-cli -x \
-               AI.MODELSET mymodel TF CPU INPUTS a b OUTPUTS c BLOB
+               AI.MODELSTORE mymodel TF CPU INPUTS 2 a b OUTPUTS 1 c BLOB
 ```
 
 ??? example "Example: loading a model from command line"
     ```
     $ cat graph.pb | docker exec -i redisai redis-cli -x \
-               AI.MODELSET mymodel TF CPU INPUTS a b OUTPUTS c BLOB
+               AI.MODELSTORE mymodel TF CPU INPUTS 2 a b OUTPUTS 1 c BLOB
     OK
     ```
 
@@ -230,23 +230,23 @@ cat graph.pb | docker exec -i redisai redis-cli -x \
     * [Redis clients page](https://redis.io/clients)
     * [RedisAI clients page](clients.md)
 
-Like most commands, `AI.MODELSET`'s first argument is a key's name, which is 'mymodel' in the example. The next two arguments are the model's DL/ML backend and the device it will be executed on. 'graph.pb' in the example is a TensorFlow graph and is denoted by `TF` argument. The model will be executed on the CPU as instructed by the `CPU` argument.
+Like most commands, `AI.MODELSTORE`'s first argument is a key's name, which is 'mymodel' in the example. The next two arguments are the model's DL/ML backend and the device it will be executed on. 'graph.pb' in the example is a TensorFlow graph and is denoted by `TF` argument. The model will be executed on the CPU as instructed by the `CPU` argument.
 
-TensorFlow models also require declaring the names of their inputs and outputs. The inputs for 'graph.pb' are called 'a' and 'b', whereas its single output is called 'c'. These names are provided as additional arguments after the 'INPUTS' and 'OUTPUTS' arguments, respectively.
+TensorFlow models also require declaring the names of their inputs and outputs. The inputs for 'graph.pb' are called 'a' and 'b', whereas its single output is called 'c'. These names are provided as additional arguments after indicating 'INPUTS' along with the number of inputs to follow, and 'OUTPUTS' along with the number of outputs to follow, respectively.
 
 ## Running Models
-Once a RedisAI Model key has been set with `AI.MODELSET` it can be run with any Tensor keys from the database as its input. The model's output, after it was executed, is stored in RedisAI Tensors as well.
+Once a RedisAI Model key has been set with `AI.MODELSTORE` it can be run with any Tensor keys from the database as its input. The model's output, after it was executed, is stored in RedisAI Tensors as well.
 
 The model stored at 'mymodel' expects two input tensors so we'll use the previously-create 'tA' and create another input tensor, $\begin{equation*} tB = \begin{bmatrix} 3 \\ 5 \end{bmatrix} \end{equation*}$, with the following command:
 
 ```
 AI.TENSORSET tB FLOAT 2 VALUES 3 5
 ```
 
-The model can now be run with the [`AI.MODELRUN` command](commands.md#aimodelrun) as follows:
+The model can now be run with the [`AI.MODELEXECUTE` command](commands.md#aimodelexecute) as follows:
 
 ```
-AI.MODELRUN mymodel INPUTS tA tB OUTPUTS tResult
+AI.MODELEXECUTE mymodel INPUTS tA tB OUTPUTS tResult
 ```
 
 !!! example "Example: running a model"
@@ -256,11 +256,11 @@ AI.MODELRUN mymodel INPUTS tA tB OUTPUTS tResult
     OK
     127.0.0.1:6379> AI.TENSORSET tB FLOAT 2 VALUES 3 5
     OK
-    127.0.0.1:6379> AI.MODELRUN mymodel INPUTS tA tB OUTPUTS tModel
+    127.0.0.1:6379> AI.MODELEXECUTE mymodel INPUTS 2 tA tB OUTPUTS 1 tModel
     OK
     ```
 
-The first argument to `AI.MODELRUN` is the name of the key at which the RedisAI Model is stored. The names of RedisAI Tensor keys that follow the `INPUTS` argument are used as input for the model. Similarly, following the `OUTPUT` argument are the key names of RedisAI Tensors that the model outputs.
+The first argument to `AI.MODELEXECUTE` is the name of the key at which the RedisAI Model is stored. The names of RedisAI Tensor keys that follow the `INPUTS` and `input_count>` arguments are used as input for the model. Similarly, following the `OUTPUTS` and `output_count>`arguments are the key names of RedisAI Tensors that the model outputs.
 
 The inputs for the example are the tensors stored under the 'tA' and 'tB' keys. Once the model's run had finished, a new RedisAI Tensor key called 'tResult' is created and stores the model's output.
 

src/execution/command_parser.c

@@ -68,7 +68,7 @@ static int _ModelExecuteCommand_ParseArgs(RedisModuleCtx *ctx, int argc, RedisMo
         RAI_SetError(error, RAI_EMODELRUN, "ERR Invalid argument for output_count");
     }
     if (noutputs <= 0) {
-        RAI_SetError(error, RAI_EMODELRUN, "ERR Input count must be a positive integer");
+        RAI_SetError(error, RAI_EMODELRUN, "ERR Output count must be a positive integer");
         return REDISMODULE_ERR;
     }
     if ((*model)->noutputs != noutputs) {

src/execution/deprecated.c

@@ -208,13 +208,10 @@ int ModelSetCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
         const char *matches[] = {"OUTPUTS"};
         AC_GetSliceUntilMatches(&optionsac, &inac, 1, matches);
 
-        if (!AC_IsAtEnd(&optionsac)) {
-            if (!AC_AdvanceIfMatch(&optionsac, "OUTPUTS")) {
-                return RedisModule_ReplyWithError(ctx, "ERR OUTPUTS not specified");
-            }
-
-            AC_GetSliceToEnd(&optionsac, &outac);
+        if (AC_IsAtEnd(&optionsac) || !AC_AdvanceIfMatch(&optionsac, "OUTPUTS")) {
+            return RedisModule_ReplyWithError(ctx, "ERR OUTPUTS not specified");
         }
+        AC_GetSliceToEnd(&optionsac, &outac);
     }
 
     size_t ninputs = inac.argc;
@@ -241,12 +238,10 @@ int ModelSetCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
 
     AC_AdvanceUntilMatches(&ac, 1, blob_matches);
 
-    if (AC_IsAtEnd(&ac)) {
+    if (AC_Advance(&ac) != AC_OK || AC_IsAtEnd(&ac)) {
         return RedisModule_ReplyWithError(ctx, "ERR Insufficient arguments, missing model BLOB");
     }
 
-    AC_Advance(&ac);
-
     ArgsCursor blobsac;
     AC_GetSliceToEnd(&ac, &blobsac);
 

src/redisai.c

@@ -146,7 +146,7 @@ int RedisAI_ModelSet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
  * [INPUTS input_count name1 name2 ... OUTPUTS output_count name1 name2 ...] BLOB model_blob
  */
 int RedisAI_ModelStore_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
-    if (argc < 4)
+    if (argc < 6)
         return RedisModule_WrongArity(ctx);
 
     ArgsCursor ac;
@@ -170,13 +170,25 @@ int RedisAI_ModelStore_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **arg
         return RedisModule_ReplyWithError(ctx, "ERR unsupported backend");
     }
 
+    // Parse <backend> argument: check that the device string is "CPU", "GPU",
+    // "CPU:<n>" or "GPU:<n>, where <n> is a number (contains digits only).
     const char *devicestr;
     AC_GetString(&ac, &devicestr, NULL, 0);
-
-    if (strlen(devicestr) > 10 || strcasecmp(devicestr, "INPUTS") == 0 ||
-        strcasecmp(devicestr, "OUTPUTS") == 0 || strcasecmp(devicestr, "TAG") == 0 ||
-        strcasecmp(devicestr, "BATCHSIZE") == 0 || strcasecmp(devicestr, "MINBATCHSIZE") == 0 ||
-        strcasecmp(devicestr, "MINBATCHTIMEOUT") == 0 || strcasecmp(devicestr, "BLOB") == 0) {
+    bool valid_device = false;
+    if (strcasecmp(devicestr, "CPU") == 0 || strcasecmp(devicestr, "GPU") == 0) {
+        valid_device = true;
+    } else if ((strncasecmp(devicestr, "GPU:", 4) == 0 || strncasecmp(devicestr, "CPU:", 4) == 0) &&
+               strlen(devicestr) <= 10) {
+        bool digits_only = true;
+        for (size_t i = 5; i < strlen(devicestr); i++) {
+            if (devicestr[i] < '0' || devicestr[i] > '9') {
+                digits_only = false;
+                break;
+            }
+        }
+        valid_device = digits_only;
+    }
+    if (!valid_device) {
         return RedisModule_ReplyWithError(ctx, "ERR Invalid DEVICE");
     }
 
@@ -208,10 +220,6 @@ int RedisAI_ModelStore_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **arg
 
     unsigned long long minbatchtimeout = 0;
     if (AC_AdvanceIfMatch(&ac, "MINBATCHTIMEOUT")) {
-        if (batchsize == 0) {
-            return RedisModule_ReplyWithError(ctx,
-                                              "ERR MINBATCHTIMEOUT specified without BATCHSIZE");
-        }
         if (minbatchsize == 0) {
             return RedisModule_ReplyWithError(ctx,
                                               "ERR MINBATCHTIMEOUT specified without MINBATCHSIZE");
@@ -234,7 +242,6 @@ int RedisAI_ModelStore_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **arg
     const char *arg_string;
     AC_GetString(&ac, &arg_string, NULL, 0);
     unsigned long long ninputs = 0, noutputs = 0;
-    const char *inputs[ninputs], *outputs[noutputs];
 
     if (backend == RAI_BACKEND_TENSORFLOW) {
         if (strcasecmp(arg_string, "INPUTS") != 0) {
@@ -248,10 +255,16 @@ int RedisAI_ModelStore_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **arg
                 ctx, "ERR number of model inputs does not match the number of "
                      "given arguments");
         }
-        for (size_t i = 0; i < ninputs; i++) {
-            AC_GetString(&ac, inputs + i, NULL, 0);
-        }
+    } else if (strcasecmp(arg_string, "INPUTS") == 0) {
+        return RedisModule_ReplyWithError(
+            ctx, "ERR INPUTS argument should not be specified for this backend");
+    }
+    const char *inputs[ninputs];
+    for (size_t i = 0; i < ninputs; i++) {
+        AC_GetString(&ac, inputs + i, NULL, 0);
+    }
 
+    if (backend == RAI_BACKEND_TENSORFLOW) {
         if (AC_GetString(&ac, &arg_string, NULL, 0) != AC_OK ||
             strcasecmp(arg_string, "OUTPUTS") != 0) {
             return RedisModule_ReplyWithError(ctx, "ERR OUTPUTS not specified for TF");
@@ -264,16 +277,15 @@ int RedisAI_ModelStore_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **arg
                 ctx, "ERR number of model outputs does not match the number of "
                      "given arguments");
         }
-        for (size_t i = 0; i < noutputs; i++) {
-            AC_GetString(&ac, outputs + i, NULL, 0);
-        }
+    }
+    const char *outputs[noutputs];
+    for (size_t i = 0; i < noutputs; i++) {
+        AC_GetString(&ac, outputs + i, NULL, 0);
+    }
+    if (backend == RAI_BACKEND_TENSORFLOW) {
         AC_GetString(&ac, &arg_string, NULL, 0);
     }
 
-    if (strcasecmp(arg_string, "INPUTS") == 0 && backend != RAI_BACKEND_TENSORFLOW) {
-        return RedisModule_ReplyWithError(
-            ctx, "ERR INPUTS argument should not be specified for this backend");
-    }
     if (strcasecmp(arg_string, "BLOB") != 0) {
         return RedisModule_ReplyWithError(ctx, "ERR Invalid argument, expected BLOB");
     }