Support multi-step schedules

schedgen/schedgen-optimize.py

@@ -53,7 +53,7 @@ args_parser.add_argument(
     "-c",
     "--cvc",
     dest="csv",
-    action='store_true',
+    action="store_true",
     help="Use the CSV parser instead of the GridTPT parser to read experimental data.",
 )
 args_parser.add_argument(
@@ -70,7 +70,7 @@ args_parser.add_argument(
     "--full",
     dest="full",
     help="Write full script instead of CSV file.",
-    action="store_true"
+    action="store_true",
 )
 args_parser.add_argument(
     "-p",
@@ -112,11 +112,11 @@ args_parser.add_argument(
     dest="pre_schedule_time",
     help="Intented time limit for the pre schedule.",
     type=float,
-    default=0.0
+    default=0.0,
 )
 
 
-def writeScript(outFile, logics):
+def writeScript(outFile, logics, schedule):
     message(f"Writing schedule to {outFile}.", logics)
     with open(outFile, "w") as af:
         if len(logics) == 1:
@@ -126,26 +126,26 @@ def writeScript(outFile, logics):
         af.write(
             f"        # Prediction: {after_count}/{after_solved.count()} in {after_total_time:.2f}s\n"
         )
-        for i in range(len(best_schedule) - 1):
-            (t, e) = best_schedule[i]
+        for i in range(len(schedule) - 1):
+            (t, e) = schedule[i]
             af.write(f"        trywith {1000*t:.0f}\t{e}\n")
-        (t, e) = best_schedule[-1]
+        (t, e) = schedule[-1]
         af.write(f"        # Calculated runtime: {t}s\n")
         af.write(f"        finishwith\t{e}\n")
         af.write("        ;;\n")
 
 
-def writeCSV(outFile, logics):
+def writeCSV(outFile, logics, schedule):
     message(f"Writing CSV schedule to {outFile}.", logics)
     with open(outFile, "w") as af:
-        for i in range(len(best_schedule)):
-            (t, e) = best_schedule[i]
-            af.write(f"{t:.0f};{e}\n")
+        for i in range(len(schedule)):
+            (t, e) = schedule[i]
+            af.write(f"{t:.3f};{e}\n")
 
 
 def readPreSchedule(preScheduleFile):
     with open(preScheduleFile, "r") as inFile:
-        splits = [line.split(';') for line in inFile]
+        splits = [line.split(";") for line in inFile]
         return [(float(s[0].strip()), s[1].strip()) for s in splits]
 
 
@@ -162,7 +162,7 @@ def solving_slices(frame, benchmark, strategy, slices, epsilon=0.0):
 
 def removeSolvedByPreSchedule(preSchedule, frame):
     for (t, e) in preSchedule:
-        frame = frame[frame.loc[:,e] > t]
+        frame = frame[frame.loc[:, e] > t]
     return frame
 
 
@@ -186,6 +186,7 @@ if __name__ == "__main__":
         r = GridTPT(args.data, logics)
     exps = r.frame
 
+    pre_schedule = None
     if args.pre_schedule:
         pre_schedule = readPreSchedule(args.pre_schedule)
         pre_schedule_timeout = args.pre_schedule_time
@@ -194,10 +195,16 @@ if __name__ == "__main__":
             exit(1)
         time_sum = sum([t[0] for t in pre_schedule])
         if time_sum > pre_schedule_timeout:
-            message("Error: pre-schedule has a longer runtime than the pre-schedule timeout given.", logics)
+            message(
+                "Error: pre-schedule has a longer runtime than the pre-schedule timeout given.",
+                logics,
+            )
             exit(1)
         if pre_schedule_timeout >= timeout:
-            message("Error: pre-schedule has a longer runtime than the given overall timeout.", logics)
+            message(
+                "Error: pre-schedule has a longer runtime than the given overall timeout.",
+                logics,
+            )
             exit(1)
         timeout = timeout - pre_schedule_timeout
         message(f"Time left after pre-schedule: {timeout}.", logics)
@@ -206,10 +213,10 @@ if __name__ == "__main__":
     exps = prune_unsolved(exps, timeout, epsilon)
     exps = prune_trivial(exps, time_slices, epsilon)
 
-    schedule_optimizer = OptimizeSchedule(exps, logics, time_slices, timeout, epsilon)
+    schedule_optimizer = OptimizeSchedule(time_slices, timeout, epsilon)
     # Format: (time, strategy)
     schedule = schedule_optimizer.find_optimal_schedule(
-        overlord=args.overlord, threads=args.threads
+        exps, overlord=args.overlord, threads=args.threads, logics=logics
     )
 
     if len(schedule) == 0:
@@ -219,14 +226,14 @@ if __name__ == "__main__":
         message("Have singular best step:", logics)
         t, best_opt = schedule[0]
         longest = time_slices[-1]
-        message(f"  For {t:.0f}s\t'{best_opt}'", logics)
+        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.value_counts().loc[True]
+        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.options)])
-            new_count = solves.value_counts().loc[True]
+            _, 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.",
@@ -250,13 +257,14 @@ if __name__ == "__main__":
 
         order_optimizer = OptimizeOrder(exps)
 
-        (before_wait, before_total_time, before_solved,) = order_optimizer.runtime(
-            schedule
-        )
+        (
+            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.",
+            f"Current schedule solves {before_count}/{before_solved.count()} in {before_total_time:.2f}s.",
             logics,
         )
 
@@ -274,9 +282,14 @@ if __name__ == "__main__":
             logics,
         )
 
+    if pre_schedule:
+        message("Merging with pre-schedule.", logics)
+        full_schedule = pre_schedule + best_schedule
+    else:
+        full_schedule = best_schedule
     if args.result and args.full:
-        writeScript(args.result, logics)
+        writeScript(args.result, logics, full_schedule)
     elif args.result:
-        writeCSV(args.result, logics)
+        writeCSV(args.result, logics, full_schedule)
 
     message("All done.", logics)