Avoid using arr in ModelRun API, align redisai.h ModelRun signature (#361)

Author: lantiga

src/dag.c

@@ -69,12 +69,11 @@ void *RedisAI_DagRunSession(RedisAI_RunInfo *rinfo) {
             &(rinfo->dagTensorsContext), 0, NULL, currentOp->err);
 
         if (parse_result > 0) {
-          RAI_ModelRunCtx **mctxs = NULL;
-          mctxs = array_new(RAI_ModelRunCtx *, 1);
-          mctxs = array_append(mctxs, currentOp->mctx);
+          RAI_ModelRunCtx *mctxs[1];
+          mctxs[0] = currentOp->mctx;
           currentOp->result = REDISMODULE_OK;
           const long long start = ustime();
-          currentOp->result = RAI_ModelRun(mctxs, currentOp->err);
+          currentOp->result = RAI_ModelRun(mctxs, 1, currentOp->err);
           currentOp->duration_us = ustime() - start;
           const size_t noutputs = RAI_ModelRunCtxNumOutputs(currentOp->mctx);
           for (size_t outputNumber = 0; outputNumber < noutputs;
@@ -92,7 +91,6 @@ void *RedisAI_DagRunSession(RedisAI_RunInfo *rinfo) {
               currentOp->result = REDISMODULE_ERR;
             }
           }
-          array_free(mctxs);
         } else {
           currentOp->result = REDISMODULE_ERR;
         }

src/model.c

@@ -413,48 +413,55 @@ void RAI_ModelRunCtxFree(RAI_ModelRunCtx* mctx) {
   RedisModule_Free(mctx);
 }
 
-int RAI_ModelRun(RAI_ModelRunCtx** mctxs, RAI_Error* err) {
+int RAI_ModelRun(RAI_ModelRunCtx** mctxs, long long n, RAI_Error* err) {
   int ret;
 
-  if (array_len(mctxs) == 0) {
+  if (n == 0) {
     RAI_SetError(err, RAI_EBACKENDNOTLOADED, "ERR Nothing to run");
     return REDISMODULE_ERR;
   }
 
-  switch (mctxs[0]->model->backend) {
+  RAI_ModelRunCtx** mctxs_arr = array_newlen(RAI_ModelRunCtx*, n);
+  for (int i=0; i<n; i++) {
+    mctxs_arr[i] = mctxs[i];
+  }
+
+  switch (mctxs_arr[0]->model->backend) {
     case RAI_BACKEND_TENSORFLOW:
       if (!RAI_backends.tf.model_run) {
         RAI_SetError(err, RAI_EBACKENDNOTLOADED, "ERR Backend not loaded: TF");
         return REDISMODULE_ERR;
       }
-      ret = RAI_backends.tf.model_run(mctxs, err);
+      ret = RAI_backends.tf.model_run(mctxs_arr, err);
       break;
     case RAI_BACKEND_TFLITE:
       if (!RAI_backends.tflite.model_run) {
         RAI_SetError(err, RAI_EBACKENDNOTLOADED, "ERR Backend not loaded: TFLITE");
         return REDISMODULE_ERR;
       }
-      ret = RAI_backends.tflite.model_run(mctxs, err);
+      ret = RAI_backends.tflite.model_run(mctxs_arr, err);
       break;
     case RAI_BACKEND_TORCH:
       if (!RAI_backends.torch.model_run) {
         RAI_SetError(err, RAI_EBACKENDNOTLOADED, "ERR Backend not loaded: TORCH");
         return REDISMODULE_ERR;
       }
-      ret = RAI_backends.torch.model_run(mctxs, err);
+      ret = RAI_backends.torch.model_run(mctxs_arr, err);
       break;
     case RAI_BACKEND_ONNXRUNTIME:
       if (!RAI_backends.onnx.model_run) {
         RAI_SetError(err, RAI_EBACKENDNOTLOADED, "ERR Backend not loaded: ONNX");
         return REDISMODULE_ERR;
       }
-      ret = RAI_backends.onnx.model_run(mctxs, err);
+      ret = RAI_backends.onnx.model_run(mctxs_arr, err);
       break;
     default:
       RAI_SetError(err, RAI_EUNSUPPORTEDBACKEND, "ERR Unsupported backend");
       return REDISMODULE_ERR;
   }
 
+  array_free(mctxs_arr);
+
   return ret;
 }
 
@@ -641,4 +648,4 @@ int RedisAI_Parse_ModelRun_RedisCommand(RedisModuleCtx *ctx,
     return -1;
   }
   return argpos;
-}
+}

src/model.h

@@ -150,12 +150,13 @@ RAI_Tensor* RAI_ModelRunCtxOutputTensor(RAI_ModelRunCtx* mctx, size_t index);
  * definition.
  *
  * @param mctxs array on input model contexts
+ * @param n length of input model contexts array
  * @param error error data structure to store error message in the case of
  * failures
  * @return REDISMODULE_OK if the underlying backend `model_run` runned
  * successfully, or REDISMODULE_ERR if failed.
  */
-int RAI_ModelRun(RAI_ModelRunCtx** mctxs, RAI_Error* err);
+int RAI_ModelRun(RAI_ModelRunCtx** mctxs, long long n, RAI_Error* err);
 
 /**
  * Every call to this function, will make the RAI_Model 'model' requiring an

src/model_script_run_session.c

@@ -34,28 +34,26 @@ void *RAI_ModelRunScriptRunSession(RedisAI_RunInfo **batch_rinfo) {
     return NULL;
   }
 
-  RAI_ModelRunCtx **mctxs = NULL;
   RAI_ScriptRunCtx *sctx = NULL;
 
   RAI_Error *err = RedisModule_Calloc(1, sizeof(RAI_Error));
   long long rtime;
   int status;
+  bool is_model;
   if (batch_rinfo[0]->mctx) {
-    mctxs = array_new(RAI_ModelRunCtx *, batch_size);
+    RAI_ModelRunCtx *mctxs[batch_size];
     for (long long i = 0; i < batch_size; i++) {
-      mctxs = array_append(mctxs, batch_rinfo[i]->mctx);
+      mctxs[i] = batch_rinfo[i]->mctx;
     }
+    const long long start = ustime();
+    status = RAI_ModelRun(mctxs, batch_size, err);
+    rtime = ustime() - start;
   } else if (batch_rinfo[0]->sctx) {
     sctx = batch_rinfo[0]->sctx;
-  }
-
-  const long long start = ustime();
-  if (mctxs) {
-    status = RAI_ModelRun(mctxs, err);
-  } else if (sctx) {
+    const long long start = ustime();
     status = RAI_ScriptRun(sctx, err);
+    rtime = ustime() - start;
   }
-  rtime = ustime() - start;
 
   for (long long i = 0; i < batch_size; i++) {
     struct RedisAI_RunInfo *rinfo = batch_rinfo[i];
@@ -76,12 +74,6 @@ void *RAI_ModelRunScriptRunSession(RedisAI_RunInfo **batch_rinfo) {
     }
   }
 
-  if (mctxs) {
-    array_free(mctxs);
-  } else if (sctx) {
-    // No batching for scripts for now
-  }
-
   return NULL;
 }
 
@@ -159,4 +151,4 @@ void RedisAI_FreeData(RedisModuleCtx *ctx, void *rinfo) {}
 void RedisAI_Disconnected(RedisModuleCtx *ctx, RedisModuleBlockedClient *bc) {
   RedisModule_Log(ctx, "warning", "Blocked client %p disconnected!",
                   (void *)bc);
-}
+}

src/redisai.h

@@ -65,7 +65,7 @@ int MODULE_API_FUNC(RedisAI_ModelRunCtxAddOutput)(RAI_ModelRunCtx* mctx, const c
 size_t MODULE_API_FUNC(RedisAI_ModelRunCtxNumOutputs)(RAI_ModelRunCtx* mctx);
 RAI_Tensor* MODULE_API_FUNC(RedisAI_ModelRunCtxOutputTensor)(RAI_ModelRunCtx* mctx, size_t index);
 void MODULE_API_FUNC(RedisAI_ModelRunCtxFree)(RAI_ModelRunCtx* mctx);
-int MODULE_API_FUNC(RedisAI_ModelRun)(RAI_ModelRunCtx* mctx, RAI_Error* err);
+int MODULE_API_FUNC(RedisAI_ModelRun)(RAI_ModelRunCtx** mctx, long long n, RAI_Error* err);
 RAI_Model* MODULE_API_FUNC(RedisAI_ModelGetShallowCopy)(RAI_Model* model);
 int MODULE_API_FUNC(RedisAI_ModelSerialize)(RAI_Model *model, char **buffer, size_t *len, RAI_Error *err);