feat: support for heuristic for containment resources

Signed-off-by: vsoch <[email protected]>

Author: vsoch

examples/fractale/README.md

@@ -72,4 +72,10 @@ And right now the search is just over attributes to find matching clusters. E.g.
 }
 ```
 
+Here is a jobspec that can't be satisfied because we ask for too many resources given the cluster [containment-subsystem.json]([containment-subsystem.json).
+
+```bash
+fractale satisfy ./examples/fractale/jobspec-containment-unsatisfied.yaml 
+```
+
 We likely want to have a more structured query syntax that can handle AND, OR, and other specifics. The actual search should remain general to support any generic key/value pair of attributes. My database structure and queries are also bad. 

examples/fractale/jobspec-containment-unsatisfied.yaml

@@ -0,0 +1,21 @@
+version: 1
+resources:
+- type: slot
+  count: 1
+  with:
+  - type: core
+    count: 100
+  label: task
+tasks:
+- command:
+  - gmx
+  slot: task
+  count:
+    per_slot: 1
+attributes:
+  system:
+    duration: 0
+    requires:
+      software:
+        - name: curl
+          type: binary

fractale/jobspec.py

@@ -0,0 +1,22 @@
+import copy
+
+
+def flatten_jobspec_resources(jobspec):
+    """
+    Given a jobspec, turn the required resources into a flattened version.
+    """
+    resources = {}
+    resource_list = copy.deepcopy(jobspec["resources"])
+    multiplier = 1
+    while resource_list:
+        requires = resource_list.pop(0)
+        resource_type = requires["type"]
+        resource_count = requires.get("count")
+        if resource_type == "slot":
+            multiplier = resource_count or 1
+        else:
+            if resource_type not in resources:
+                resources[resource_type] = 0
+            resources[resource_type] += resource_count * multiplier
+        resource_list += requires.get("with") or []
+    return resources

fractale/subsystem/solver/database.py

@@ -1,6 +1,8 @@
+import copy
 import os
 import sqlite3
 
+import fractale.jobspec as jspec
 import fractale.subsystem.queries as queries
 import fractale.utils as utils
 from fractale.logger import LogColors, logger
@@ -9,12 +11,10 @@
 class DatabaseSolver:
     """
     A database solver solves for a cluster based on a simple database.
-
-    TODO: we need to have counters or another strategy for containment.
     """
 
     def __init__(self, path):
-        self.systems = {}
+        self.subsystems = {}
         self.conn = sqlite3.connect(":memory:")
         self.create_tables()
         self.load(path)
@@ -104,9 +104,18 @@ def load_subsystem(self, subsystem):
         # self.conn.commit()
         attr_fields = '("cluster", "subsystem", "node", "name", "value")'
 
+        # Keep track of counts of all types
+        counts = {}
+
         # Now all attributes, and also include type because I'm lazy
         for nid, node in subsystem.iter_nodes():
             typ = node["metadata"]["type"]
+
+            # Assume a node is a count of 1
+            if typ not in counts:
+                counts[typ] = 0
+            counts[typ] += 1
+
             attr_values = f"('{subsystem.cluster}', '{subsystem.name}', '{nid}', 'type', '{typ}')"
             statement = f"INSERT INTO attributes {attr_fields} VALUES {attr_values}"
             cursor.execute(statement)
@@ -119,6 +128,7 @@ def load_subsystem(self, subsystem):
 
         # Note that we aren't doing anything with edges currently.
         self.conn.commit()
+        self.subsystems[subsystem.name] = counts
 
     def get_subsystem_nodes(self, cluster, subsystem):
         """
@@ -196,6 +206,10 @@ def satisfied(self, jobspec):
         if not requires:
             logger.exit("Jobspec has no system requirements.")
 
+        # Special case: containment - try matching resources if we have one
+        if "containment" in self.subsystems:
+            requires["containment"] = jspec.flatten_jobspec_resources(js)
+
         # These clusters will satisfy the request
         matches = set()
 
@@ -214,6 +228,12 @@ def satisfied(self, jobspec):
             for subsystem in subsystems:
                 name, cluster, subsystem_type = subsystem
 
+                # If subsystem is containment and we don't have enough totals, fail
+                if "containment" in self.subsystems:
+                    if not self.assess_containment(requires["containment"]):
+                        print(f"{LogColors.RED}=> No Matches due to containment{LogColors.ENDC}")
+                        return False
+
                 # "Get nodes in subsystem X" if we have a query syntax we could limit to a type, etc.
                 # In this case, the subsystem is the name (e.g., spack) since we might have multiple for
                 # a type (e.g., software). This returns labels we can associate with attributes.
@@ -234,6 +254,19 @@ def satisfied(self, jobspec):
                 print(f"{LogColors.RED}=> No Matches{LogColors.ENDC}")
             return False
 
+    def assess_containment(self, requires):
+        """
+        A rough heuirstic to see if the cluster has enough resources
+        of specific types.
+        """
+        for typ, count in requires.items():
+            if typ not in self.subsystems.get("containment", {}):
+                return False
+            have_count = self.subsystems["containment"][typ]
+            if have_count < count:
+                return False
+        return True
+
     def get_subsystem_by_type(self, subsystem_type, ignore_missing=True):
         """
         Get subsystems based on a type. This will return one or more clusters