resource: support resource.reserve configuration key

Problem: There is no way to reserve a set of cores so they cannot
be used by the scheduler of a Flux instance.

Add support for a new config key `resource.reserve`, which takes a
string of the form `cores[@Ranks]` where `cores` and the optional
`ranks` are idsets specifying the cores to reserve and the ranks
on which to reserve them. If ranks is not specified, then the spec
applies to all ranks.

The reserved set of cores are subtracted from the resource set before
it is handed off to the scheduler. The reserved resource set is also
removed from the status response used by `flux resource list`.

Author: grondo

src/modules/resource/acquire.c

@@ -65,6 +65,7 @@
 #include "reslog.h"
 #include "inventory.h"
 #include "exclude.h"
+#include "reserve.h"
 #include "drain.h"
 #include "acquire.h"
 #include "monitor.h"
@@ -108,6 +109,7 @@ static int acquire_request_init (struct acquire_request *ar,
 {
     struct resource_ctx *ctx = acquire->ctx;
     const struct idset *exclude = exclude_get (ctx->exclude);
+    const struct rlist *reserved = reserve_get (ctx->reserve);
     json_error_t e;
     struct rlist *rl;
     struct idset *drain = NULL;
@@ -116,8 +118,11 @@ static int acquire_request_init (struct acquire_request *ar,
         errno = EINVAL;
         return -1;
     }
-    if (exclude && idset_count (exclude) > 0) {
-        (void)rlist_remove_ranks (rl, (struct idset *)exclude);
+    if (reserved || (exclude && idset_count (exclude) > 0)) {
+        if (exclude)
+            (void)rlist_remove_ranks (rl, (struct idset *)exclude);
+        if (reserved)
+            (void)rlist_subtract (rl, reserved);
         if (!(ar->resources = rlist_to_R (rl))) {
             errno = ENOMEM;
             goto error;

src/modules/resource/resource.c

@@ -36,12 +36,18 @@
 #include "rutil.h"
 #include "status.h"
 #include "upgrade.h"
+#include "reserve.h"
 
 /* Parse [resource] table.
  *
  * exclude = "targets"
  *   Exclude specified broker rank(s) or hosts from scheduling
  *
+ * reserve = "corespec"
+ *   Exclude specified coes from scheduling, corespec has the form:
+ *   "cores[@ranks]", where each of cores and ranks are non-empty
+ *   idsets.
+ *
  * [[resource.confg]]
  *   Resource configuration array
  *
@@ -71,6 +77,7 @@ static int parse_config (struct resource_ctx *ctx,
     const char *exclude  = NULL;
     const char *path = NULL;
     const char *scheduling_path = NULL;
+    const char *reserve = NULL;
     int noverify = 0;
     int norestrict = 0;
     int no_update_watch = 0;
@@ -80,12 +87,13 @@ static int parse_config (struct resource_ctx *ctx,
 
     if (flux_conf_unpack (conf,
                           &error,
-                          "{s?{s?s s?s s?o s?s s?b s?b s?b s?b !}}",
+                          "{s?{s?s s?s s?o s?s s?s s?b s?b s?b s?b !}}",
                           "resource",
                             "path", &path,
                             "scheduling", &scheduling_path,
                             "config", &config,
                             "exclude", &exclude,
+                            "reserve", &reserve,
                             "norestrict", &norestrict,
                             "noverify", &noverify,
                             "no-update-watch", &no_update_watch,
@@ -147,6 +155,7 @@ static int parse_config (struct resource_ctx *ctx,
     }
     if (rconfig) {
         rconfig->exclude_idset = exclude;
+        rconfig->reserve = reserve;
         rconfig->noverify = noverify ? true : false;
         rconfig->norestrict = norestrict ? true : false;
         rconfig->no_update_watch = no_update_watch ? true : false;
@@ -238,6 +247,7 @@ static void resource_ctx_destroy (struct resource_ctx *ctx)
         topo_destroy (ctx->topology);
         monitor_destroy (ctx->monitor);
         exclude_destroy (ctx->exclude);
+        reserve_destroy (ctx->reserve);
         reslog_destroy (ctx->reslog);
         inventory_destroy (ctx->inventory);
         flux_msg_handler_delvec (ctx->handlers);
@@ -383,6 +393,8 @@ int mod_main (flux_t *h, int argc, char **argv)
             goto error;
         if (!(ctx->drain = drain_create (ctx, eventlog)))
             goto error;
+        if (!(ctx->reserve = reserve_create (ctx, config.reserve)))
+            goto error;
     }
     /*  topology is initialized after exclude/drain etc since this
      *  rank may attempt to drain itself due to a topology mismatch.

src/modules/resource/resource.h

@@ -14,6 +14,7 @@
 struct resource_config {
     json_t *R;
     const char *exclude_idset;
+    const char *reserve;
     bool rediscover;
     bool noverify;
     bool norestrict;
@@ -29,6 +30,7 @@ struct resource_ctx {
     struct topo *topology;
     struct drain *drain;
     struct exclude *exclude;
+    struct reserve *reserve;
     struct acquire *acquire;
     struct reslog *reslog;
     struct status *status;

src/modules/resource/status.c

@@ -21,6 +21,7 @@
 #include "rutil.h"
 #include "monitor.h"
 #include "exclude.h"
+#include "reserve.h"
 #include "status.h"
 #include "reslog.h"
 
@@ -282,9 +283,11 @@ static json_t *update_properties_json (json_t *R, const struct rlist *all)
 
 /* Create an rlist object from R.  Omit the scheduling key.  Then:
  * - exclude the ranks in 'exclude' (if non-NULL)
+ * - exclude resources in 'reserved' (if non-NULL)
  */
 static struct rlist *create_rlist (const json_t *R,
-                                   const struct idset *exclude)
+                                   const struct idset *exclude,
+                                   const struct rlist *reserved)
 {
     json_t *cpy;
     struct rlist *rl;
@@ -302,6 +305,10 @@ static struct rlist *create_rlist (const json_t *R,
         if (rlist_remove_ranks (rl, (struct idset *)exclude) < 0)
             goto error;
     }
+    if (reserved) {
+        if (rlist_subtract (rl, reserved) < 0)
+            goto error;
+    }
     json_decref (cpy);
     return rl;
 error:
@@ -316,9 +323,10 @@ static struct rlist *get_resource_list (struct status *status)
     if (!status->cache.rl) {
         const json_t *R;
         const struct idset *exclude = exclude_get (status->ctx->exclude);
+        const struct rlist *reserved = reserve_get (status->ctx->reserve);
 
         if ((R = inventory_get (status->ctx->inventory)))
-            status->cache.rl = create_rlist (R, exclude);
+            status->cache.rl = create_rlist (R, exclude, reserved);
     }
     return status->cache.rl;
 }