reapi: added match options to c bindings

zekemorton · zekemorton · commit 07df1f8f6662 · 2024-02-13T12:11:39.000-08:00
Problem: reapi C bindings only use 2 of the 4 match options for
match allocate.

Create new functions match and match_satisfy where match is a
general purpose match allocate function that can use all 4 match
options. match_satisfy and match_allocate both call match  with
their corresponding match options.
diff --git a/resource/reapi/bindings/c/reapi_cli.cpp b/resource/reapi/bindings/c/reapi_cli.cpp
@@ -90,26 +90,39 @@ extern "C" int reapi_cli_initialize (reapi_cli_ctx_t *ctx, const char *rgraph,
     return rc;    
 }
 
-extern "C" int reapi_cli_match_allocate (reapi_cli_ctx_t *ctx,
-                   bool orelse_reserve, const char *jobspec,
-                   uint64_t *jobid, bool *reserved,
-                   char **R, int64_t *at, double *ov)
+extern "C" int reapi_cli_match (reapi_cli_ctx_t *ctx,
+                                const char *match_op, const char *jobspec,
+                                uint64_t *jobid, bool *reserved,
+                                char **R, int64_t *at, double *ov)
 {
     int rc = -1;
     std::string R_buf = "";
     char *R_buf_c = nullptr;
+    match_op_t op;
 
     if (!ctx || !ctx->rqt) {
         errno = EINVAL;
         goto out;
     }
 
+    if (!strcmp (match_op,"allocate"))
+        op = match_op_t::MATCH_ALLOCATE;
+    else if (!strcmp (match_op, "allocate_with_satisfiability"))
+        op = match_op_t::MATCH_ALLOCATE_W_SATISFIABILITY;
+    else if (!strcmp (match_op, "allocate_orelse_reserve"))
+        op = match_op_t::MATCH_ALLOCATE_ORELSE_RESERVE;
+    else if (!strcmp (match_op, "satisfiability"))
+        op = match_op_t::MATCH_SATISFIABILITY;
+    else
+        goto out;
+
     *jobid = ctx->rqt->get_job_counter ();
-    if ((rc = reapi_cli_t::match_allocate (ctx->rqt, orelse_reserve,
+    if ((rc = reapi_cli_t::match_allocate (ctx->rqt, op,
                                            jobspec, *jobid, *reserved,
                                            R_buf, *at, *ov)) < 0) {
         goto out;
     }
+
     if ( !(R_buf_c = strdup (R_buf.c_str ()))) {
         ctx->err_msg = __FUNCTION__;
         ctx->err_msg += ": ERROR: can't allocate memory\n";
@@ -123,9 +136,44 @@ extern "C" int reapi_cli_match_allocate (reapi_cli_ctx_t *ctx,
     return rc;
 }
 
+extern "C" int reapi_cli_match_allocate (reapi_cli_ctx_t *ctx,
+                                         bool orelse_reserve, const char *jobspec,
+                                         uint64_t *jobid, bool *reserved,
+                                         char **R, int64_t *at, double *ov)
+{
+    const char  *match_op = orelse_reserve ? "allocate_orelse_reserve" : 
+                                             "allocate";
+
+    return reapi_cli_match (ctx, match_op, jobspec, jobid, reserved, 
+                                     R, at, ov);
+}
+
+extern "C" int reapi_cli_match_satisfy (reapi_cli_ctx_t *ctx,
+                                        const char *jobspec, 
+                                        bool *sat, double *ov)
+{
+    const char  *match_op = "satisfiability";
+    uint64_t jobid;
+    bool reserved;
+    char *R; 
+    int64_t at; 
+    int ret;
+    *sat = true;
+
+    ret = reapi_cli_match (ctx, match_op, jobspec, &jobid,
+                           &reserved, &R, &at, ov);
+
+    // check for satisfiability
+    if (errno == ENODEV)
+        *sat = false;
+
+    return ret;                        
+}
+
 extern "C" int reapi_cli_update_allocate (reapi_cli_ctx_t *ctx,
-                   const uint64_t jobid, const char *R, int64_t *at,
-                   double *ov, const char **R_out)
+                                          const uint64_t jobid, 
+                                          const char *R, int64_t *at,
+                                          double *ov, const char **R_out)
 {
     int rc = -1;
     std::string R_buf = "";
diff --git a/resource/reapi/bindings/c/reapi_cli.h b/resource/reapi/bindings/c/reapi_cli.h
@@ -41,6 +41,39 @@ void reapi_cli_destroy (reapi_cli_ctx_t *ctx);
 int reapi_cli_initialize (reapi_cli_ctx_t *ctx, const char *rgraph,
                           const char *options);
 
+/*! Match a jobspec to the "best" resources and either allocate
+ *  orelse reserve them. The best resources are determined by
+ *  the selected match policy.
+ *
+ *  \param ctx       reapi_cli_ctx_t context object
+ *  \param match_op  const char *: set to specify the specific match option
+ *                   from 1 of 4 choices:
+ *                   allocate: try to allocate now and fail if resources 
+ *                   aren't available. 
+ *                   allocate_orelse_reserve : Try to allocate and reserve if 
+ *                   resources aren't available now.
+ *                   satisfiability: Do a satisfiablity check and do not 
+ *                   allocate.
+ *                   allocate_with_satisfiability: try to allocate and run 
+ *                   satisfiability check if resources are not available.
+ *  \param jobspec   jobspec string.
+ *  \param jobid     jobid of the uint64_t type.
+ *  \param reserved  Boolean into which to return true if this job has been
+ *                   reserved instead of allocated.
+ *  \param R         String into which to return the resource set either
+ *                   allocated or reserved.
+ *  \param at        If allocated, 0 is returned; if reserved, actual time
+ *                   at which the job is reserved.
+ *  \param ov        Double into which to return performance overhead
+ *                   in terms of elapse time needed to complete
+ *                   the match operation.
+ *  \return          0 on success; -1 on error.
+ */
+int reapi_cli_match (reapi_cli_ctx_t *ctx, const char *match_op,
+                     const char *jobspec, uint64_t *jobid,
+                     bool *reserved,
+                     char **R, int64_t *at, double *ov);
+
 /*! Match a jobspec to the "best" resources and either allocate
  *  orelse reserve them. The best resources are determined by
  *  the selected match policy.
@@ -67,6 +100,20 @@ int reapi_cli_match_allocate (reapi_cli_ctx_t *ctx, bool orelse_reserve,
                               bool *reserved,
                               char **R, int64_t *at, double *ov);
 
+/*! Run Satisfiability check for jobspec.
+ *
+ *  \param ctx       reapi_cli_ctx_t context object
+ *  \param jobspec   jobspec string.
+ *  \param sat       bool sat into which to return if jobspec is 
+ *                   satisfiable. 
+ *  \param ov        Double into which to return performance overhead
+ *                   in terms of elapse time needed to complete
+ *                   the match operation.
+ *  \return          0 on success; -1 on error.
+ */
+int reapi_cli_match_satisfy (reapi_cli_ctx_t *ctx,
+                             const char *jobspec, bool *sat, double *ov);
+
 /*! Update the resource state with R.
  *
  *  \param ctx       reapi_cli_ctx_t context object
diff --git a/resource/reapi/bindings/c/reapi_module.cpp b/resource/reapi/bindings/c/reapi_module.cpp
@@ -47,10 +47,10 @@ extern "C" void reapi_module_destroy (reapi_module_ctx_t *ctx)
     free (ctx);
 }
 
-extern "C" int reapi_module_match_allocate (reapi_module_ctx_t *ctx,
-                   bool orelse_reserve, const char *jobspec,
-                   const uint64_t jobid, bool *reserved,
-                   char **R, int64_t *at, double *ov)
+extern "C" int reapi_module_match (reapi_module_ctx_t *ctx,
+                                   const char *match_op, const char *jobspec,
+                                   const uint64_t jobid, bool *reserved,
+                                   char **R, int64_t *at, double *ov)
 {
     int rc = -1;
     std::string R_buf = "";
@@ -60,7 +60,7 @@ extern "C" int reapi_module_match_allocate (reapi_module_ctx_t *ctx,
         errno = EINVAL;
         goto out;
     }
-    if ((rc = reapi_module_t::match_allocate (ctx->h, orelse_reserve, jobspec,
+    if ((rc = reapi_module_t::match_allocate (ctx->h, match_op, jobspec,
                                               jobid, *reserved,
                                               R_buf, *at, *ov)) < 0) {
         goto out;
@@ -75,6 +75,31 @@ extern "C" int reapi_module_match_allocate (reapi_module_ctx_t *ctx,
     return rc;
 }
 
+extern "C" int reapi_module_match_allocate (reapi_module_ctx_t *ctx,
+                                            bool orelse_reserve, const char *jobspec,
+                                            const uint64_t jobid, bool *reserved,
+                                            char **R, int64_t *at, double *ov)
+{
+    const char  *match_op = orelse_reserve ? "allocate_orelse_reserve" : 
+                                             "allocate";
+
+    return reapi_module_match (ctx, match_op, jobspec, jobid, reserved, 
+                                     R, at, ov);
+}
+
+extern "C" int reapi_module_match_satisfy (reapi_module_ctx_t *ctx,
+                                           const char *jobspec, double *ov)
+{
+    const char  *match_op = "satisfiability";
+    const uint64_t jobid =0;
+    bool *reserved;
+    char **R; 
+    int64_t *at; 
+
+    return reapi_module_match (ctx, match_op, jobspec, jobid,
+                               reserved, R, at, ov);
+}
+
 extern "C" int reapi_module_update_allocate (reapi_module_ctx_t *ctx,
                                              const uint64_t jobid, const char *R,
                                              int64_t *at, double *ov,
diff --git a/resource/reapi/bindings/c/reapi_module.h b/resource/reapi/bindings/c/reapi_module.h
@@ -32,6 +32,38 @@ reapi_module_ctx_t *reapi_module_new ();
  */
 void reapi_module_destroy (reapi_module_ctx_t *ctx);
 
+/*! Match a jobspec to the "best" resources and either allocate
+ *  orelse reserve them. The best resources are determined by
+ *  the selected match policy.
+ *
+ *  \param ctx       reapi_module_ctx_t context object
+ *  \param match_op  const char *: set to specify the specific match option
+ *                   from 1 of 4 choices:
+ *                   allocate: try to allocate now and fail if resources 
+ *                   aren't available. 
+ *                   allocate_orelse_reserve: Try to allocate and resever if 
+ *                   resources aren't available now.
+ *                   satisfiability: Do a satisfiablity check and do not 
+ *                   allocate.
+ *                   allocate_with_satisfiability: try to allocate and run 
+ *                   satisfiability check if resources are not available.
+ *  \param jobspec   jobspec string.
+ *  \param jobid     jobid of the uint64_t type.
+ *  \param reserved  Boolean into which to return true if this job has been
+ *                   reserved instead of allocated.
+ *  \param R         String into which to return the resource set either
+ *                   allocated or reserved.
+ *  \param at        If allocated, 0 is returned; if reserved, actual time
+ *                   at which the job is reserved.
+ *  \param ov        Double into which to return performance overhead
+ *                   in terms of elapse time needed to complete
+ *                   the match operation.
+ *  \return          0 on success; -1 on error.
+ */
+int reapi_module_match (reapi_module_ctx_t *ctx, const char *match_op,
+                        const char *jobspec, const uint64_t jobid,
+                        bool *reserved, char **R, int64_t *at, double *ov);
+
 /*! Match a jobspec to the "best" resources and either allocate
  *  orelse reserve them. The best resources are determined by
  *  the selected match policy.
@@ -58,6 +90,18 @@ int reapi_module_match_allocate (reapi_module_ctx_t *ctx, bool orelse_reserve,
                                  bool *reserved,
                                  char **R, int64_t *at, double *ov);
 
+/*! Run Satisfiability check for jobspec. 
+ *
+ *  \param ctx       reapi_module_ctx_t context object
+ *  \param jobspec   jobspec string.
+ *  \param ov        Double into which to return performance overhead
+ *                   in terms of elapse time needed to complete
+ *                   the match operation.
+ *  \return          0 on success; -1 on error.
+ */
+int reapi_module_match_satisfy (reapi_module_ctx_t *ctx, 
+                                const char *jobspec, double *ov);
+
 /*! Update the resource state with R.
  *
  *  \param ctx       reapi_module_ctx_t context object
