Add option to generate a schedule greedily

schedgen/opt/schedule.py

@@ -57,7 +57,31 @@ class OptimizeSchedule:
         self.epsilon = epsilon
         self.time_slices.sort()
 
-    def find_optimal_schedule(self, frame, overlord=None, threads=2, logics="None"):
+    def find_greedy_schedule(self, frame, logics=None):
+        remaining_time = self.timeout
+        best_score = 0
+        schedule = []
+        while remaining_time > self.time_slices[0]:
+            for strategy, solving_times in frame.iteritems():
+                for slice in self.time_slices:
+                    if slice > remaining_time:
+                        continue
+                    solved = solving_times.loc[solving_times < (slice - self.epsilon)]
+                    if len(solved) > best_score:
+                        best_solved = solved
+                        best_score = len(solved)
+                        best = (slice, strategy)
+            if best is not None:
+                remaining_time = remaining_time - best[0]
+                frame = frame[~frame.index.isin(best_solved.index)]
+                schedule.append(best)
+                best_score = 0
+                best = None
+            else:
+                return schedule
+        return schedule
+
+    def find_optimal_schedule(self, frame, overlord=None, threads=2, logics=None):
         """
         Create LP problem
         """

schedgen/schedgen-optimize.py

@@ -62,6 +62,12 @@ args_parser.add_argument(
     action="store_true",
     help="Use the CSV parser instead of the GridTPT parser to read experimental data.",
 )
+args_parser.add_argument(
+    "--greedy",
+    dest="greedy",
+    help="Generate a greedy schedule instead of an optimal one.",
+    action="store_true",
+)
 args_parser.add_argument(
     "-f",
     "--full",
@@ -267,72 +273,75 @@ if __name__ == "__main__":
 
     schedule_optimizer = OptimizeSchedule(time_slices, timeout, epsilon)
     # Format: (time, strategy)
-    schedule = schedule_optimizer.find_optimal_schedule(
-        exps, overlord=args.overlord, threads=args.threads, logics=logics
-    )
-
-    if len(schedule) == 0:
-        message("  Error: got empty schedule.", logics)
-        exit(1)
-    if len(schedule) == 1:
-        message("Have singular best step:", logics)
-        t, best_opt = schedule[0]
-        longest = time_slices[-1]
-        message(f"  For {t:.2f}s\t'{best_opt}'", logics)
-        order_optimizer = OptimizeOrder(exps)
-        _, best_time, best_solves = order_optimizer.runtime([(longest, best_opt)])
-        best_count = best_solves.sum()
-        message(f"This solves {best_count} in {best_time}s.", logics)
-        for e in exps:
-            _, time, solves = order_optimizer.runtime([(longest, e)])
-            new_count = solves.sum()
-            if new_count > best_count:
-                message(
-                    "Something went wrong: optimizer returned a better schedule.",
-                    logics,
-                )
-                exit(1)
-            if new_count == best_count and time < best_time:
-                best_time = time
-                best_opt = e
-        message("The best schedule is:", logics)
-        message(f"  Run\t'{best_opt}'", logics)
-        message(f"This solves {best_count} in {best_time}s.", logics)
-        after_solved = best_solves
-        after_count = best_count
-        after_total_time = best_time
-        best_schedule = [(t, best_opt)]
+    if args.greedy:
+        best_schedule = schedule_optimizer.find_greedy_schedule(exps, logics=logics)
     else:
-        message("Solution:", logics)
-        for (t, e) in schedule:
-            message(f"  For {t:.2f}s\t'{e}'", logics)
+        schedule = schedule_optimizer.find_optimal_schedule(
+            exps, overlord=args.overlord, threads=args.threads, logics=logics
+        )
 
-        order_optimizer = OptimizeOrder(exps)
+        if len(schedule) == 0:
+            message("  Error: got empty schedule.", logics)
+            exit(1)
+        if len(schedule) == 1:
+            message("Have singular best step:", logics)
+            t, best_opt = schedule[0]
+            longest = time_slices[-1]
+            message(f"  For {t:.2f}s\t'{best_opt}'", logics)
+            order_optimizer = OptimizeOrder(exps)
+            _, best_time, best_solves = order_optimizer.runtime([(longest, best_opt)])
+            best_count = best_solves.sum()
+            message(f"This solves {best_count} in {best_time}s.", logics)
+            for e in exps:
+                _, time, solves = order_optimizer.runtime([(longest, e)])
+                new_count = solves.sum()
+                if new_count > best_count:
+                    message(
+                        "Something went wrong: optimizer returned a better schedule.",
+                        logics,
+                    )
+                    exit(1)
+                if new_count == best_count and time < best_time:
+                    best_time = time
+                    best_opt = e
+            message("The best schedule is:", logics)
+            message(f"  Run\t'{best_opt}'", logics)
+            message(f"This solves {best_count} in {best_time}s.", logics)
+            after_solved = best_solves
+            after_count = best_count
+            after_total_time = best_time
+            best_schedule = [(t, best_opt)]
+        else:
+            message("Solution:", logics)
+            for (t, e) in schedule:
+                message(f"  For {t:.2f}s\t'{e}'", logics)
 
-        (
-            before_wait,
-            before_total_time,
-            before_solved,
-        ) = order_optimizer.runtime(schedule)
-        before_count = before_solved.value_counts().loc[True]
-        message(
-            f"Current schedule solves {before_count}/{before_solved.count()} in {before_total_time:.2f}s.",
-            logics,
-        )
+            order_optimizer = OptimizeOrder(exps)
 
-        message("Calculating best order.", logics)
-        best_schedule = order_optimizer.find_optimal_order(schedule)
-        message("\nOptimal schedule:", logics)
-        for (t, e) in best_schedule:
-            message(f"  For {t:.2f}s\t'{e}'", logics)
-        after_wait, after_total_time, after_solved = order_optimizer.runtime(
-            best_schedule
-        )
-        after_count = after_solved.value_counts().loc[True]
-        message(
-            f"This schedule solves {after_count}/{after_solved.count()} in {after_total_time:.2f}s.",
-            logics,
-        )
+            (
+                before_wait,
+                before_total_time,
+                before_solved,
+            ) = order_optimizer.runtime(schedule)
+            before_count = before_solved.value_counts().loc[True]
+            message(
+                f"Current schedule solves {before_count}/{before_solved.count()} in {before_total_time:.2f}s.",
+                logics,
+            )
+
+            message("Calculating best order.", logics)
+            best_schedule = order_optimizer.find_optimal_order(schedule)
+            message("\nOptimal schedule:", logics)
+            for (t, e) in best_schedule:
+                message(f"  For {t:.2f}s\t'{e}'", logics)
+            after_wait, after_total_time, after_solved = order_optimizer.runtime(
+                best_schedule
+            )
+            after_count = after_solved.value_counts().loc[True]
+            message(
+                f"This schedule solves {after_count}/{after_solved.count()} in {after_total_time:.2f}s.",
+                logics,
+            )
 
     if pre_schedule:
         message("Merging with pre-schedule.", logics)