File size: 115,466 Bytes
5980447 |
1 2 |
{"repo": "simonlindholm/decomp-permuter", "pull_number": 97, "instance_id": "simonlindholm__decomp-permuter-97", "issue_numbers": "", "base_commit": "939c92b0b093ab0290a94d882b19c5f8a186b2a1", "patch": "diff --git a/pah.py b/pah.py\nnew file mode 100755\n--- /dev/null\n+++ b/pah.py\n@@ -0,0 +1,4 @@\n+#!/usr/bin/env python3\n+from src.net.cmd.main import main\n+\n+main()\ndiff --git a/src/candidate.py b/src/candidate.py\n--- a/src/candidate.py\n+++ b/src/candidate.py\n@@ -19,15 +19,13 @@\n \n @dataclass\n class CandidateResult:\n- \"\"\"\n- Represents the result of scoring a candidate, and is sent from child to\n- parent processes.\n- \"\"\"\n+ \"\"\"Represents the result of scoring a candidate, and is sent from child to\n+ parent processes, or server to client with p@h.\"\"\"\n \n score: int\n- hash: str\n+ hash: Optional[str]\n source: Optional[str]\n- profiler: Profiler = field(default_factory=Profiler)\n+ profiler: Optional[Profiler] = None\n \n \n @dataclass\ndiff --git a/src/error.py b/src/error.py\n--- a/src/error.py\n+++ b/src/error.py\n@@ -1,6 +1,11 @@\n from dataclasses import dataclass\n \n \n+@dataclass\n+class ServerError(Exception):\n+ message: str\n+\n+\n @dataclass\n class CandidateConstructionFailure(Exception):\n message: str\ndiff --git a/src/helpers.py b/src/helpers.py\n--- a/src/helpers.py\n+++ b/src/helpers.py\n@@ -1,4 +1,13 @@\n import os\n+from typing import NoReturn\n+\n+\n+def exception_to_string(e: object) -> str:\n+ return str(e) or e.__class__.__name__\n+\n+\n+def static_assert_unreachable(x: NoReturn) -> NoReturn:\n+ raise Exception(\"Unreachable! \" + repr(x))\n \n \n def try_remove(path: str) -> None:\ndiff --git a/src/main.py b/src/main.py\n--- a/src/main.py\n+++ b/src/main.py\n@@ -2,9 +2,13 @@\n from dataclasses import dataclass, field\n import itertools\n import multiprocessing\n+from multiprocessing import Queue\n import os\n+import queue\n+import random\n from random import Random\n import sys\n+import threading\n import time\n from typing import (\n Callable,\n@@ -16,14 +20,27 @@\n Tuple,\n )\n \n-from .error import CandidateConstructionFailure\n-from .preprocess import preprocess\n from .candidate import CandidateResult\n from .compiler import Compiler\n-from .scorer import Scorer\n-from .permuter import EvalError, EvalResult, Permuter\n+from .error import CandidateConstructionFailure\n+from .helpers import static_assert_unreachable\n+from .net.client import start_client\n+from .net.core import ServerError, connect, enable_debug_mode, MAX_PRIO, MIN_PRIO\n+from .permuter import (\n+ EvalError,\n+ EvalResult,\n+ Feedback,\n+ Finished,\n+ Message,\n+ NeedMoreWork,\n+ Permuter,\n+ Task,\n+ WorkDone,\n+)\n+from .preprocess import preprocess\n from .printer import Printer\n from .profiler import Profiler\n+from .scorer import Scorer\n \n # The probability that the randomizer continues transforming the output it\n # generated last time.\n@@ -44,6 +61,9 @@ class Options:\n keep_prob: float = DEFAULT_RAND_KEEP_PROB\n force_seed: Optional[str] = None\n threads: int = 1\n+ use_network: bool = False\n+ network_debug: bool = False\n+ network_priority: float = 1.0\n \n \n def restricted_float(lo: float, hi: float) -> Callable[[str], float]:\n@@ -62,6 +82,11 @@ def convert(x: str) -> float:\n return convert\n \n \n+def plural(n: int, noun: str) -> str:\n+ s = \"s\" if n != 1 else \"\"\n+ return f\"{n} {noun}{s}\"\n+\n+\n @dataclass\n class EvalContext:\n options: Options\n@@ -94,11 +119,13 @@ def write_candidate(perm: Permuter, result: CandidateResult) -> None:\n print(f\"wrote to {output_dir}\")\n \n \n-def post_score(context: EvalContext, permuter: Permuter, result: EvalResult) -> bool:\n+def post_score(\n+ context: EvalContext, permuter: Permuter, result: EvalResult, who: Optional[str]\n+) -> bool:\n if isinstance(result, EvalError):\n if result.exc_str is not None:\n context.printer.print(\n- \"internal permuter failure.\", permuter, keep_progress=True\n+ \"internal permuter failure.\", permuter, who, keep_progress=True\n )\n print(result.exc_str)\n if result.seed is not None:\n@@ -119,7 +146,10 @@ def post_score(context: EvalContext, permuter: Permuter, result: EvalResult) ->\n \n profiler = result.profiler\n score_value = result.score\n- score_hash = result.hash\n+\n+ if profiler is not None:\n+ for stattype in profiler.time_stats:\n+ context.overall_profiler.add_stat(stattype, profiler.time_stats[stattype])\n \n context.iteration += 1\n if score_value == permuter.scorer.PENALTY_INF:\n@@ -129,29 +159,16 @@ def post_score(context: EvalContext, permuter: Permuter, result: EvalResult) ->\n disp_score = str(score_value)\n timings = \"\"\n if context.options.show_timings:\n- for stattype in profiler.time_stats:\n- context.overall_profiler.add_stat(stattype, profiler.time_stats[stattype])\n timings = \" \\t\" + context.overall_profiler.get_str_stats()\n status_line = f\"iteration {context.iteration}, {context.errors} errors, score = {disp_score}{timings}\"\n \n- # Note: when updating this if condition, Permuter._need_to_send_source may\n- # also need to be updated, or else assertion failures will result.\n- if (\n- score_value is not None\n- and score_hash is not None\n- and not (score_value > permuter.best_score and context.options.best_only)\n- and (\n- score_value < permuter.base_score\n- or (score_value == permuter.base_score and not context.options.better_only)\n- )\n- and score_hash not in permuter.hashes\n- ):\n- if score_value != 0:\n- permuter.hashes.add(score_hash)\n- if score_value < permuter.best_score:\n+ if permuter.should_output(result):\n+ former_best = permuter.best_score\n+ permuter.record_result(result)\n+ if score_value < former_best:\n color = \"\\u001b[32;1m\"\n msg = f\"found new best score! ({score_value} vs {permuter.base_score})\"\n- elif score_value == permuter.best_score:\n+ elif score_value == former_best:\n color = \"\\u001b[32;1m\"\n msg = f\"tied best score! ({score_value} vs {permuter.base_score})\"\n elif score_value < permuter.base_score:\n@@ -160,8 +177,8 @@ def post_score(context: EvalContext, permuter: Permuter, result: EvalResult) ->\n else:\n color = \"\\u001b[33m\"\n msg = f\"found different asm with same score ({score_value})\"\n- permuter.best_score = min(permuter.best_score, score_value)\n- context.printer.print(msg, permuter, color=color)\n+ context.printer.print(msg, permuter, who, color=color)\n+\n write_candidate(permuter, result)\n context.printer.progress(status_line)\n return score_value == 0\n@@ -191,26 +208,39 @@ def cycle_seeds(permuters: List[Permuter]) -> Iterable[Tuple[int, int]]:\n \n def multiprocess_worker(\n permuters: List[Permuter],\n- input_queue: \"multiprocessing.Queue[Optional[Tuple[int, int]]]\",\n- output_queue: \"multiprocessing.Queue[Tuple[int, EvalResult]]\",\n+ input_queue: \"Queue[Task]\",\n+ output_queue: \"Queue[Feedback]\",\n ) -> None:\n- input_queue.cancel_join_thread()\n- output_queue.cancel_join_thread()\n-\n try:\n while True:\n- queue_item = input_queue.get()\n- if queue_item is None:\n+ # Read a work item from the queue. If none is immediately available,\n+ # tell the main thread to fill the queues more, and then block on\n+ # the queue.\n+ queue_item: Task\n+ try:\n+ queue_item = input_queue.get(block=False)\n+ except queue.Empty:\n+ output_queue.put((NeedMoreWork(), -1, None))\n+ queue_item = input_queue.get()\n+ if isinstance(queue_item, Finished):\n+ output_queue.put((queue_item, -1, None))\n+ output_queue.close()\n break\n permuter_index, seed = queue_item\n permuter = permuters[permuter_index]\n result = permuter.try_eval_candidate(seed)\n- output_queue.put((permuter_index, result))\n+ if isinstance(result, CandidateResult) and permuter.should_output(result):\n+ permuter.record_result(result)\n+ output_queue.put((WorkDone(permuter_index, result), -1, None))\n+ output_queue.put((NeedMoreWork(), -1, None))\n except KeyboardInterrupt:\n # Don't clutter the output with stack traces; Ctrl+C is the expected\n # way to quit and sends KeyboardInterrupt to all processes.\n # A heartbeat thing here would be good but is too complex.\n- pass\n+ # Don't join the queue background thread -- thread joins in relation\n+ # to KeyboardInterrupt usually result in deadlocks.\n+ input_queue.cancel_join_thread()\n+ output_queue.cancel_join_thread()\n \n \n def run(options: Options) -> List[int]:\n@@ -285,8 +315,11 @@ def run_inner(options: Options, heartbeat: Callable[[], None]) -> List[int]:\n force_seed=force_seed,\n force_rng_seed=force_rng_seed,\n keep_prob=options.keep_prob,\n+ need_profiler=options.show_timings,\n need_all_sources=options.print_diffs,\n show_errors=options.show_errors,\n+ best_only=options.best_only,\n+ better_only=options.better_only,\n )\n except CandidateConstructionFailure as e:\n print(e.message, file=sys.stderr)\n@@ -296,72 +329,180 @@ def run_inner(options: Options, heartbeat: Callable[[], None]) -> List[int]:\n name_counts[permuter.fn_name] = name_counts.get(permuter.fn_name, 0) + 1\n print()\n \n+ if not context.permuters:\n+ print(\"No permuters!\")\n+ return []\n+\n for permuter in context.permuters:\n if name_counts[permuter.fn_name] > 1:\n permuter.unique_name += f\" ({permuter.dir})\"\n print(f\"[{permuter.unique_name}] base score = {permuter.best_score}\")\n \n found_zero = False\n- perm_seed_iter = iter(cycle_seeds(context.permuters))\n- if options.threads == 1:\n- for permuter_index, seed in perm_seed_iter:\n+ if options.threads == 1 and not options.use_network:\n+ # Simple single-threaded mode. This is not technically needed, but\n+ # makes the permuter easier to debug.\n+ for permuter_index, seed in cycle_seeds(context.permuters):\n heartbeat()\n permuter = context.permuters[permuter_index]\n result = permuter.try_eval_candidate(seed)\n- if post_score(context, permuter, result):\n+ if post_score(context, permuter, result, None):\n found_zero = True\n if options.stop_on_zero:\n break\n else:\n- # Create queues\n- task_queue: \"multiprocessing.Queue[Optional[Tuple[int, int]]]\" = (\n- multiprocessing.Queue()\n- )\n- results_queue: \"multiprocessing.Queue[Tuple[int, EvalResult]]\" = (\n- multiprocessing.Queue()\n- )\n- task_queue.cancel_join_thread()\n- results_queue.cancel_join_thread()\n-\n- def wait_for_result() -> bool:\n- heartbeat()\n- permuter_index, result = results_queue.get()\n- permuter = context.permuters[permuter_index]\n- return post_score(context, permuter, result)\n-\n- # Begin workers\n+ seed_iterators: List[Optional[Iterator[int]]] = [\n+ itertools.repeat(perm_ind)\n+ for perm_ind, permuter in enumerate(context.permuters)\n+ ]\n+ seed_iterators_remaining = len(seed_iterators)\n+ next_iterator_index = 0\n+\n+ # Create queues.\n+ worker_task_queue: \"Queue[Task]\" = Queue()\n+ feedback_queue: \"Queue[Feedback]\" = Queue()\n+\n+ # Connect to network and create client threads and queues.\n+ net_conns: \"List[Tuple[threading.Thread, Queue[Task]]]\" = []\n+ if options.use_network:\n+ print(\"Connecting to permuter@home...\")\n+ if options.network_debug:\n+ enable_debug_mode()\n+ first_stats: Optional[Tuple[int, int, float]] = None\n+ for perm_index in range(len(context.permuters)):\n+ try:\n+ port = connect()\n+ except (EOFError, ServerError) as e:\n+ print(\"Error:\", e)\n+ sys.exit(1)\n+ thread, queue, stats = start_client(\n+ port,\n+ context.permuters[perm_index],\n+ perm_index,\n+ feedback_queue,\n+ options.network_priority,\n+ )\n+ net_conns.append((thread, queue))\n+ if first_stats is None:\n+ first_stats = stats\n+ assert first_stats is not None, \"has at least one permuter\"\n+ clients_str = plural(first_stats[0], \"other client\")\n+ servers_str = plural(first_stats[1], \"server\")\n+ cores_str = plural(int(first_stats[2]), \"core\")\n+ print(f\"Connected! {servers_str} online ({cores_str}, {clients_str})\")\n+\n+ # Start local worker threads\n processes: List[multiprocessing.Process] = []\n for i in range(options.threads):\n p = multiprocessing.Process(\n target=multiprocess_worker,\n- args=(context.permuters, task_queue, results_queue),\n+ args=(context.permuters, worker_task_queue, feedback_queue),\n )\n p.start()\n processes.append(p)\n \n- # Feed the task queue with work, but not too much work at a time\n- active_tasks = 0\n- for perm_seed in perm_seed_iter:\n- if active_tasks >= options.threads + 2:\n- active_tasks -= 1\n- if wait_for_result():\n+ active_workers = len(processes)\n+\n+ if not active_workers and not net_conns:\n+ print(\"No workers available! Exiting.\")\n+ sys.exit(1)\n+\n+ def process_finish(finish: Finished, source: int) -> None:\n+ nonlocal active_workers\n+\n+ if finish.reason:\n+ permuter: Optional[Permuter] = None\n+ if source != -1 and len(context.permuters) > 1:\n+ permuter = context.permuters[source]\n+ context.printer.print(finish.reason, permuter, None, keep_progress=True)\n+\n+ if source == -1:\n+ active_workers -= 1\n+\n+ def process_result(work: WorkDone, who: Optional[str]) -> bool:\n+ permuter = context.permuters[work.perm_index]\n+ return post_score(context, permuter, work.result, who)\n+\n+ def get_task(perm_index: int) -> Optional[Tuple[int, int]]:\n+ nonlocal next_iterator_index, seed_iterators_remaining\n+ if perm_index == -1:\n+ while seed_iterators_remaining > 0:\n+ task = get_task(next_iterator_index)\n+ next_iterator_index += 1\n+ next_iterator_index %= len(seed_iterators)\n+ if task is not None:\n+ return task\n+ else:\n+ it = seed_iterators[perm_index]\n+ if it is not None:\n+ seed = next(it, None)\n+ if seed is None:\n+ seed_iterators[perm_index] = None\n+ seed_iterators_remaining -= 1\n+ else:\n+ return (perm_index, seed)\n+ return None\n+\n+ # Feed the task queue with work and read from results queue.\n+ # We generally match these up one-by-one to avoid overfilling queues,\n+ # but workers can ask us to add more tasks into the system if they run\n+ # out of work. (This will happen e.g. at the very beginning, when the\n+ # queues are empty.)\n+ while seed_iterators_remaining > 0:\n+ heartbeat()\n+ feedback, source, who = feedback_queue.get()\n+ if isinstance(feedback, Finished):\n+ process_finish(feedback, source)\n+ elif isinstance(feedback, Message):\n+ context.printer.print(feedback.text, None, who, keep_progress=True)\n+ elif isinstance(feedback, WorkDone):\n+ if process_result(feedback, who):\n # Found score 0!\n found_zero = True\n if options.stop_on_zero:\n break\n- task_queue.put(perm_seed)\n- active_tasks += 1\n-\n- # Await final results\n- for i in range(active_tasks):\n- wait_for_result()\n-\n- # Stop workers\n- for i in range(options.threads):\n- task_queue.put(None)\n+ elif isinstance(feedback, NeedMoreWork):\n+ task = get_task(source)\n+ if task is not None:\n+ if source == -1:\n+ worker_task_queue.put(task)\n+ else:\n+ net_conns[source][1].put(task)\n+ else:\n+ static_assert_unreachable(feedback)\n+\n+ # Signal workers to stop.\n+ for i in range(active_workers):\n+ worker_task_queue.put(Finished())\n+\n+ for conn in net_conns:\n+ conn[1].put(Finished())\n+\n+ # Await final results.\n+ while active_workers > 0 or net_conns:\n+ heartbeat()\n+ feedback, source, who = feedback_queue.get()\n+ if isinstance(feedback, Finished):\n+ process_finish(feedback, source)\n+ elif isinstance(feedback, Message):\n+ context.printer.print(feedback.text, None, who, keep_progress=True)\n+ elif isinstance(feedback, WorkDone):\n+ if not (options.stop_on_zero and found_zero):\n+ if process_result(feedback, who):\n+ found_zero = True\n+ elif isinstance(feedback, NeedMoreWork):\n+ pass\n+ else:\n+ static_assert_unreachable(feedback)\n+\n+ # Wait for workers to finish.\n for p in processes:\n p.join()\n \n+ # Wait for network connections to close (currently does not happen).\n+ for conn in net_conns:\n+ conn[0].join()\n+\n if found_zero:\n print(\"\\nFound zero score! Exiting.\")\n return [permuter.best_score for permuter in context.permuters]\n@@ -372,7 +513,7 @@ def main() -> None:\n sys.setrecursionlimit(10000)\n \n # Ideally we would do:\n- # multiprocessing.set_start_method('spawn')\n+ # multiprocessing.set_start_method(\"spawn\")\n # here, to make multiprocessing behave the same across operating systems.\n # However, that means that arguments to Process are passed across using\n # pickling, which mysteriously breaks with pycparser...\n@@ -443,19 +584,49 @@ def main() -> None:\n metavar=\"PROB\",\n type=restricted_float(0.0, 1.0),\n default=DEFAULT_RAND_KEEP_PROB,\n- help=\"Continue randomizing the previous output with the given probability \"\n- f\"(float in 0..1, default %(default)s).\",\n+ help=\"\"\"Continue randomizing the previous output with the given probability\n+ (float in 0..1, default %(default)s).\"\"\",\n )\n parser.add_argument(\"--seed\", dest=\"force_seed\", type=str, help=argparse.SUPPRESS)\n parser.add_argument(\n \"-j\",\n dest=\"threads\",\n type=int,\n- default=1,\n- help=\"Number of threads (default: %(default)s).\",\n+ default=0,\n+ help=\"Number of own threads to use (default: 1 without -J, 0 with -J).\",\n )\n+ parser.add_argument(\n+ \"-J\",\n+ dest=\"use_network\",\n+ action=\"store_true\",\n+ help=\"Harness extra compute power through cyberspace (permuter@home).\",\n+ )\n+ parser.add_argument(\n+ \"--pah-debug\",\n+ dest=\"network_debug\",\n+ action=\"store_true\",\n+ help=\"Enable debug prints for permuter@home.\",\n+ )\n+ parser.add_argument(\n+ \"--priority\",\n+ dest=\"network_priority\",\n+ metavar=\"PRIORITY\",\n+ type=restricted_float(MIN_PRIO, MAX_PRIO),\n+ default=1.0,\n+ help=f\"\"\"Proportion of server resources to use when multiple people\n+ are using -J at the same time.\n+ Defaults to 1.0, meaning resources are split equally, but can be\n+ set to any value within [{MIN_PRIO}, {MAX_PRIO}].\n+ Each server runs with a priority threshold, which defaults to 0.1,\n+ below which they will not run permuter jobs at all.\"\"\",\n+ )\n+\n args = parser.parse_args()\n \n+ threads = args.threads\n+ if not threads and not args.use_network:\n+ threads = 1\n+\n options = Options(\n directories=args.directories,\n show_errors=args.show_errors,\n@@ -468,7 +639,10 @@ def main() -> None:\n stop_on_zero=args.stop_on_zero,\n keep_prob=args.keep_prob,\n force_seed=args.force_seed,\n- threads=args.threads,\n+ threads=threads,\n+ use_network=args.use_network,\n+ network_debug=args.network_debug,\n+ network_priority=args.network_priority,\n )\n \n run(options)\ndiff --git a/src/net/__init__.py b/src/net/__init__.py\nnew file mode 100644\ndiff --git a/src/net/client.py b/src/net/client.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/client.py\n@@ -0,0 +1,279 @@\n+from dataclasses import dataclass\n+import json\n+from multiprocessing import Queue\n+import re\n+import socket\n+import struct\n+import threading\n+from typing import List, Optional, Tuple, TypeVar\n+import zlib\n+\n+from ..candidate import CandidateResult\n+from ..helpers import exception_to_string\n+from ..permuter import (\n+ EvalError,\n+ EvalResult,\n+ Feedback,\n+ FeedbackItem,\n+ Finished,\n+ Message,\n+ NeedMoreWork,\n+ Permuter,\n+ Task,\n+ WorkDone,\n+)\n+from ..profiler import Profiler\n+from .core import (\n+ PermuterData,\n+ Port,\n+ SocketPort,\n+ json_array,\n+ json_prop,\n+ permuter_data_to_json,\n+)\n+\n+\n+def _profiler_from_json(obj: dict) -> Profiler:\n+ ret = Profiler()\n+ for key in obj:\n+ assert isinstance(key, str), \"json properties are strings\"\n+ stat = Profiler.StatType[key]\n+ time = json_prop(obj, key, float)\n+ ret.add_stat(stat, time)\n+ return ret\n+\n+\n+def _result_from_json(obj: dict, source: Optional[str]) -> EvalResult:\n+ if \"error\" in obj:\n+ return EvalError(exc_str=json_prop(obj, \"error\", str), seed=None)\n+\n+ profiler: Optional[Profiler] = None\n+ if \"profiler\" in obj:\n+ profiler = _profiler_from_json(json_prop(obj, \"profiler\", dict))\n+ return CandidateResult(\n+ score=json_prop(obj, \"score\", int),\n+ hash=json_prop(obj, \"hash\", str) if \"hash\" in obj else None,\n+ source=source,\n+ profiler=profiler,\n+ )\n+\n+\n+def _make_script_portable(source: str) -> str:\n+ \"\"\"Parse a shell script and get rid of the machine-specific parts that\n+ import.py introduces. The resulting script must be run in an environment\n+ that has the right binaries in its $PATH, and with a current working\n+ directory similar to where import.py found its target's make root.\"\"\"\n+ lines = []\n+ for line in source.split(\"\\n\"):\n+ if re.match(\"cd '?/\", line):\n+ # Skip cd's to absolute directory paths. Note that shlex quotes\n+ # its argument with ' if it contains spaces/single quotes.\n+ continue\n+ if re.match(\"'?/\", line):\n+ quote = \"'\" if line[0] == \"'\" else \"\"\n+ ind = line.find(quote + \" \")\n+ if ind == -1:\n+ ind = len(line)\n+ else:\n+ ind += len(quote)\n+ lastind = line.rfind(\"/\", 0, ind)\n+ assert lastind != -1\n+ # Emit a call to \"which\" as the first part, to ensure the called\n+ # binary still sees an absolute path. qemu-irix requires this,\n+ # for some reason.\n+ line = \"$(which \" + quote + line[lastind + 1 : ind] + \")\" + line[ind:]\n+ lines.append(line)\n+ return \"\\n\".join(lines)\n+\n+\n+def make_portable_permuter(permuter: Permuter) -> PermuterData:\n+ with open(permuter.scorer.target_o, \"rb\") as f:\n+ target_o_bin = f.read()\n+\n+ with open(permuter.compiler.compile_cmd, \"r\") as f2:\n+ compile_script = _make_script_portable(f2.read())\n+\n+ return PermuterData(\n+ base_score=permuter.base_score,\n+ base_hash=permuter.base_hash,\n+ fn_name=permuter.fn_name,\n+ filename=permuter.source_file,\n+ keep_prob=permuter.keep_prob,\n+ need_profiler=permuter.need_profiler,\n+ stack_differences=permuter.scorer.stack_differences,\n+ compile_script=compile_script,\n+ source=permuter.source,\n+ target_o_bin=target_o_bin,\n+ )\n+\n+\n+class Connection:\n+ _port: SocketPort\n+ _permuter_data: PermuterData\n+ _perm_index: int\n+ _task_queue: \"Queue[Task]\"\n+ _feedback_queue: \"Queue[Feedback]\"\n+\n+ def __init__(\n+ self,\n+ port: SocketPort,\n+ permuter_data: PermuterData,\n+ perm_index: int,\n+ task_queue: \"Queue[Task]\",\n+ feedback_queue: \"Queue[Feedback]\",\n+ ) -> None:\n+ self._port = port\n+ self._permuter_data = permuter_data\n+ self._perm_index = perm_index\n+ self._task_queue = task_queue\n+ self._feedback_queue = feedback_queue\n+\n+ def _send_permuter(self) -> None:\n+ data = self._permuter_data\n+ self._port.send_json(permuter_data_to_json(data))\n+ self._port.send(zlib.compress(data.source.encode(\"utf-8\")))\n+ self._port.send(zlib.compress(data.target_o_bin))\n+\n+ def _feedback(self, feedback: FeedbackItem, server_nick: Optional[str]) -> None:\n+ self._feedback_queue.put((feedback, self._perm_index, server_nick))\n+\n+ def _receive_one(self) -> bool:\n+ \"\"\"Receive a result/progress message and send it on. Returns true if\n+ more work should be requested.\"\"\"\n+ msg = self._port.receive_json()\n+ msg_type = json_prop(msg, \"type\", str)\n+ if msg_type == \"need_work\":\n+ return True\n+\n+ server_nick = json_prop(msg, \"server\", str)\n+ if msg_type == \"init_done\":\n+ base_hash = json_prop(msg, \"hash\", str)\n+ my_base_hash = self._permuter_data.base_hash\n+ text = \"connected\"\n+ if base_hash != my_base_hash:\n+ text += \" (note: mismatching hash)\"\n+ self._feedback(Message(text), server_nick)\n+ return True\n+\n+ if msg_type == \"init_failed\":\n+ text = \"failed to initialize: \" + json_prop(msg, \"reason\", str)\n+ self._feedback(Message(text), server_nick)\n+ return False\n+\n+ if msg_type == \"disconnect\":\n+ self._feedback(Message(\"disconnected\"), server_nick)\n+ return False\n+\n+ if msg_type == \"result\":\n+ source: Optional[str] = None\n+ if msg.get(\"has_source\") == True:\n+ # Source is sent separately, compressed, since it can be\n+ # large (hundreds of kilobytes is not uncommon).\n+ compressed_source = self._port.receive()\n+ try:\n+ source = zlib.decompress(compressed_source).decode(\"utf-8\")\n+ except Exception as e:\n+ text = \"failed to decompress: \" + exception_to_string(e)\n+ self._feedback(Message(text), server_nick)\n+ return True\n+ try:\n+ result = _result_from_json(msg, source)\n+ self._feedback(WorkDone(self._perm_index, result), server_nick)\n+ except Exception as e:\n+ text = \"failed to parse result message: \" + exception_to_string(e)\n+ self._feedback(Message(text), server_nick)\n+ return True\n+\n+ raise ValueError(f\"Invalid message type {msg_type}\")\n+\n+ def run(self) -> None:\n+ finish_reason: Optional[str] = None\n+ try:\n+ self._send_permuter()\n+ self._port.receive_json()\n+\n+ finished = False\n+\n+ # Main loop: send messages from the queue on to the server, and\n+ # vice versa. Currently we are being lazy and alternate between\n+ # sending and receiving; this is nicely simple and keeps us on a\n+ # single thread, however it could cause deadlocks if the server\n+ # receiver stops reading because we aren't reading fast enough.\n+ while True:\n+ if not self._receive_one():\n+ continue\n+ self._feedback(NeedMoreWork(), None)\n+\n+ # Read a task and send it on, unless there are no more tasks.\n+ if not finished:\n+ task = self._task_queue.get()\n+ if isinstance(task, Finished):\n+ # We don't have a way of indicating to the server that\n+ # all is done: the server currently doesn't track\n+ # outstanding work so it doesn't know when to close\n+ # the connection. (Even with this fixed we'll have the\n+ # problem that servers may disconnect, losing work, so\n+ # the task never truly finishes. But it might work well\n+ # enough in practice.)\n+ finished = True\n+ else:\n+ work = {\n+ \"type\": \"work\",\n+ \"work\": {\n+ \"seed\": task[1],\n+ },\n+ }\n+ self._port.send_json(work)\n+\n+ except EOFError:\n+ finish_reason = \"disconnected from permuter@home\"\n+\n+ except Exception as e:\n+ errmsg = exception_to_string(e)\n+ finish_reason = f\"permuter@home error: {errmsg}\"\n+\n+ finally:\n+ self._feedback(Finished(reason=finish_reason), None)\n+ self._port.shutdown()\n+ self._port.close()\n+\n+\n+def start_client(\n+ port: SocketPort,\n+ permuter: Permuter,\n+ perm_index: int,\n+ feedback_queue: \"Queue[Feedback]\",\n+ priority: float,\n+) -> \"Tuple[threading.Thread, Queue[Task], Tuple[int, int, float]]\":\n+ port.send_json(\n+ {\n+ \"method\": \"connect_client\",\n+ \"priority\": priority,\n+ }\n+ )\n+ obj = port.receive_json()\n+ if \"error\" in obj:\n+ err = json_prop(obj, \"error\", str)\n+ # TODO use another exception type\n+ raise Exception(f\"Failed to connect: {err}\")\n+ num_servers = json_prop(obj, \"servers\", int)\n+ num_clients = json_prop(obj, \"clients\", int)\n+ num_cores = json_prop(obj, \"cores\", float)\n+ permuter_data = make_portable_permuter(permuter)\n+ task_queue: \"Queue[Task]\" = Queue()\n+\n+ conn = Connection(\n+ port,\n+ permuter_data,\n+ perm_index,\n+ task_queue,\n+ feedback_queue,\n+ )\n+\n+ thread = threading.Thread(target=conn.run)\n+ thread.daemon = True\n+ thread.start()\n+\n+ stats = (num_clients, num_servers, num_cores)\n+\n+ return thread, task_queue, stats\ndiff --git a/src/net/cmd/__init__.py b/src/net/cmd/__init__.py\nnew file mode 100644\ndiff --git a/src/net/cmd/base.py b/src/net/cmd/base.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/cmd/base.py\n@@ -0,0 +1,17 @@\n+import abc\n+from argparse import ArgumentParser, Namespace\n+\n+\n+class Command(abc.ABC):\n+ command: str\n+ help: str\n+\n+ @staticmethod\n+ @abc.abstractmethod\n+ def add_arguments(parser: ArgumentParser) -> None:\n+ ...\n+\n+ @staticmethod\n+ @abc.abstractmethod\n+ def run(args: Namespace) -> None:\n+ ...\ndiff --git a/src/net/cmd/main.py b/src/net/cmd/main.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/cmd/main.py\n@@ -0,0 +1,61 @@\n+from argparse import ArgumentParser, RawDescriptionHelpFormatter\n+import sys\n+\n+from ..core import ServerError, enable_debug_mode\n+from .run_server import RunServerCommand\n+from .setup import SetupCommand\n+from .ping import PingCommand\n+from .vouch import VouchCommand\n+\n+\n+def main() -> None:\n+ parser = ArgumentParser(\n+ description=\"permuter@home - run the permuter across the Internet!\\n\\n\"\n+ \"To use p@h as a client, just pass -J when running the permuter. \"\n+ \"This script is\\nonly necessary for configuration or when running a server.\",\n+ formatter_class=RawDescriptionHelpFormatter,\n+ )\n+\n+ commands = [\n+ PingCommand,\n+ RunServerCommand,\n+ SetupCommand,\n+ VouchCommand,\n+ ]\n+\n+ parser.add_argument(\n+ \"--debug\",\n+ dest=\"debug\",\n+ action=\"store_true\",\n+ help=\"Enable debug logging.\",\n+ )\n+\n+ subparsers = parser.add_subparsers(metavar=\"<command>\")\n+ for command in commands:\n+ subparser = subparsers.add_parser(\n+ command.command,\n+ help=command.help,\n+ description=command.help,\n+ )\n+ command.add_arguments(subparser)\n+ subparser.set_defaults(subcommand_handler=command.run)\n+\n+ args = parser.parse_args()\n+ if args.debug:\n+ enable_debug_mode()\n+\n+ if \"subcommand_handler\" in args:\n+ try:\n+ args.subcommand_handler(args)\n+ except EOFError as e:\n+ print(\"Network error:\", e)\n+ sys.exit(1)\n+ except ServerError as e:\n+ print(\"Error:\", e.message)\n+ sys.exit(1)\n+ else:\n+ parser.print_help()\n+\n+\n+if __name__ == \"__main__\":\n+ main()\ndiff --git a/src/net/cmd/ping.py b/src/net/cmd/ping.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/cmd/ping.py\n@@ -0,0 +1,27 @@\n+from argparse import ArgumentParser, Namespace\n+import time\n+\n+from ..core import connect\n+from .base import Command\n+\n+\n+class PingCommand(Command):\n+ command = \"ping\"\n+ help = \"Check server connectivity.\"\n+\n+ @staticmethod\n+ def add_arguments(parser: ArgumentParser) -> None:\n+ pass\n+\n+ @staticmethod\n+ def run(args: Namespace) -> None:\n+ run_ping()\n+\n+\n+def run_ping() -> None:\n+ port = connect()\n+ t0 = time.time()\n+ port.send_json({\"method\": \"ping\"})\n+ port.receive_json()\n+ rtt = (time.time() - t0) * 1000\n+ print(f\"Connected successfully! Round-trip time: {rtt:.1f} ms\")\ndiff --git a/src/net/cmd/run_server.py b/src/net/cmd/run_server.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/cmd/run_server.py\n@@ -0,0 +1,382 @@\n+from argparse import ArgumentParser, Namespace\n+from dataclasses import dataclass\n+from functools import partial\n+import os\n+import queue\n+import random\n+import sys\n+import time\n+import threading\n+import traceback\n+from typing import Any, Callable, Dict, List, Optional, Tuple, TYPE_CHECKING\n+\n+if TYPE_CHECKING:\n+ import pystray\n+\n+from ...helpers import static_assert_unreachable\n+from ..core import CancelToken, ServerError\n+from ..server import (\n+ Client,\n+ IoActivity,\n+ IoConnect,\n+ IoDisconnect,\n+ IoGlobalMessage,\n+ IoImmediateDisconnect,\n+ IoReconnect,\n+ IoServerFailed,\n+ IoShutdown,\n+ IoUserRemovePermuter,\n+ IoWillSleep,\n+ IoWorkDone,\n+ PermuterHandle,\n+ Server,\n+ ServerOptions,\n+)\n+from .base import Command\n+\n+\n+SYSTRAY_UPDATE_INTERVAL = 20.0\n+\n+\n+class RunServerCommand(Command):\n+ command = \"run-server\"\n+ help = \"\"\"Run a permuter server, allowing anyone with access to the central\n+ server to run sandboxed permuter jobs on your machine. Requires docker.\"\"\"\n+\n+ @staticmethod\n+ def add_arguments(parser: ArgumentParser) -> None:\n+ parser.add_argument(\n+ \"--cores\",\n+ dest=\"num_cores\",\n+ metavar=\"CORES\",\n+ type=float,\n+ required=True,\n+ help=\"Number of cores to use (float).\",\n+ )\n+ parser.add_argument(\n+ \"--memory\",\n+ dest=\"max_memory_gb\",\n+ metavar=\"MEMORY_GB\",\n+ type=float,\n+ required=True,\n+ help=\"\"\"Restrict the sandboxed process to the given amount of memory in\n+ gigabytes (float). If this limit is hit, the permuter will crash\n+ horribly, but at least your system won't lock up.\"\"\",\n+ )\n+ parser.add_argument(\n+ \"--systray\",\n+ dest=\"systray\",\n+ action=\"store_true\",\n+ help=\"\"\"Make the server controllable through the system tray.\n+ Warning: buggy!\"\"\",\n+ )\n+ parser.add_argument(\n+ \"--min-priority\",\n+ dest=\"min_priority\",\n+ metavar=\"PRIORITY\",\n+ type=float,\n+ default=0.1,\n+ help=\"\"\"Only accept jobs from clients who pass --priority with a number\n+ higher or equal to this value. (default: %(default)s)\"\"\",\n+ )\n+\n+ @staticmethod\n+ def run(args: Namespace) -> None:\n+ options = ServerOptions(\n+ num_cores=args.num_cores,\n+ max_memory_gb=args.max_memory_gb,\n+ min_priority=args.min_priority,\n+ )\n+\n+ server_main(options, args.systray)\n+\n+\n+class SystrayState:\n+ def connect(self, handle: PermuterHandle, nickname: str, fn_name: str) -> None:\n+ pass\n+\n+ def disconnect(self, handle: PermuterHandle) -> None:\n+ pass\n+\n+ def work_done(self, handle: PermuterHandle, is_improvement: bool) -> None:\n+ pass\n+\n+ def will_sleep(self) -> None:\n+ pass\n+\n+ def server_failed(self) -> None:\n+ pass\n+\n+\n+@dataclass\n+class Permuter:\n+ nickname: str\n+ fn_name: str\n+ iterations: int = 0\n+ improvements: int = 0\n+ last_systray_update: float = 0.0\n+\n+\n+class RealSystrayState(SystrayState):\n+ _permuters: Dict[PermuterHandle, Permuter]\n+\n+ def __init__(\n+ self,\n+ io_queue: \"queue.Queue[IoActivity]\",\n+ update_menu: \"Callable[[List[pystray.MenuItem], bool], None]\",\n+ ) -> None:\n+ self._io_queue = io_queue\n+ self._update_menu = update_menu\n+ self._permuters = {}\n+\n+ def _remove_permuter(self, handle: PermuterHandle, *_: Any) -> None:\n+ self._io_queue.put((None, (handle, IoUserRemovePermuter())))\n+\n+ def _quit(self) -> None:\n+ self._io_queue.put((None, IoShutdown()))\n+\n+ def _update(self, flush: bool = True) -> None:\n+ import pystray\n+\n+ title = \"Currently permuting:\" if self._permuters else \"<not running>\"\n+ items: List[pystray.MenuItem] = [\n+ pystray.MenuItem(title, None, enabled=False),\n+ ]\n+\n+ for handle, perm in self._permuters.items():\n+ items.append(\n+ pystray.MenuItem(\n+ f\"{perm.fn_name} ({perm.nickname})\",\n+ pystray.Menu(\n+ pystray.MenuItem(\n+ f\"Iterations: {perm.iterations}\", None, enabled=False\n+ ),\n+ pystray.MenuItem(\n+ f\"Improvements found: {perm.improvements}\",\n+ None,\n+ enabled=False,\n+ ),\n+ pystray.MenuItem(\n+ \"Stop\", partial(self._remove_permuter, handle)\n+ ),\n+ ),\n+ ),\n+ )\n+\n+ items.append(pystray.MenuItem(\"Quit\", self._quit))\n+\n+ self._update_menu(items, flush)\n+\n+ def initial_update(self) -> None:\n+ self._update()\n+\n+ def connect(self, handle: PermuterHandle, nickname: str, fn_name: str) -> None:\n+ self._permuters[handle] = Permuter(nickname, fn_name)\n+ self._update()\n+\n+ def disconnect(self, handle: PermuterHandle) -> None:\n+ del self._permuters[handle]\n+ self._update()\n+\n+ def work_done(self, handle: PermuterHandle, is_improvement: bool) -> None:\n+ perm = self._permuters[handle]\n+ perm.iterations += 1\n+ if is_improvement:\n+ perm.improvements += 1\n+ flush = time.time() > perm.last_systray_update + SYSTRAY_UPDATE_INTERVAL\n+ if flush:\n+ perm.last_systray_update = time.time()\n+ self._update(flush)\n+\n+ def will_sleep(self) -> None:\n+ self._update()\n+\n+ def server_failed(self) -> None:\n+ self._permuters = {}\n+ self._update()\n+\n+\n+def run_with_systray(\n+ io_queue: \"queue.Queue[IoActivity]\",\n+ loop: Callable[[SystrayState], None],\n+) -> None:\n+ try:\n+ from PIL import Image\n+ import pystray\n+ except Exception:\n+ print(\n+ \"Systray requires the pystray and Pillow packages to be installed.\\n\"\n+ \"Run `python3 -m pip install --upgrade pystray Pillow`.\"\n+ )\n+ sys.exit(1)\n+\n+ menu_items: List[pystray.MenuItem] = []\n+\n+ icon = pystray.Icon(\n+ name=\"permuter@home\",\n+ title=\"permuter@home\",\n+ icon=Image.open(os.path.join(os.path.dirname(__file__), \"icon.png\")),\n+ menu=pystray.Menu(lambda: menu_items),\n+ )\n+\n+ def update_menu(items: List[pystray.MenuItem], flush: bool) -> None:\n+ nonlocal menu_items\n+ menu_items = items\n+ if flush:\n+ icon.update_menu()\n+\n+ systray = RealSystrayState(io_queue, update_menu)\n+ systray.initial_update()\n+\n+ def inner(icon: pystray.Icon) -> None:\n+ icon.visible = True\n+ loop(systray)\n+ icon.stop()\n+\n+ icon.run(inner)\n+\n+\n+class Reconnector:\n+ _RESET_BACKOFF_AFTER_UPTIME: float = 60.0\n+ _RANDOM_ADDEND_MAX: float = 60.0\n+ _BACKOFF_MULTIPLIER: float = 2.0\n+ _INITIAL_DELAY: float = 5.0\n+\n+ _io_queue: \"queue.Queue[IoActivity]\"\n+ _reconnect_token: CancelToken\n+ _reconnect_delay: float\n+ _reconnect_timer: Optional[threading.Timer]\n+ _start_time: float\n+ _stop_time: float\n+\n+ def __init__(self, io_queue: \"queue.Queue[IoActivity]\") -> None:\n+ self._io_queue = io_queue\n+ self._reconnect_token = CancelToken()\n+ self._reconnect_delay = self._INITIAL_DELAY\n+ self._reconnect_timer = None\n+ self._start_time = self._stop_time = time.time()\n+\n+ def mark_start(self) -> None:\n+ self._start_time = time.time()\n+\n+ def mark_stop(self) -> None:\n+ self._stop_time = time.time()\n+\n+ def stop(self) -> None:\n+ self._reconnect_token.cancelled = True\n+ if self._reconnect_timer is not None:\n+ self._reconnect_timer.cancel()\n+ self._reconnect_timer.join()\n+ self._reconnect_timer = None\n+\n+ def reconnect_eventually(self) -> int:\n+ if self._stop_time - self._start_time > self._RESET_BACKOFF_AFTER_UPTIME:\n+ delay = self._reconnect_delay = self._INITIAL_DELAY\n+ else:\n+ delay = self._reconnect_delay\n+ self._reconnect_delay = (\n+ self._reconnect_delay * self._BACKOFF_MULTIPLIER\n+ + random.uniform(1.0, self._RANDOM_ADDEND_MAX)\n+ )\n+ token = CancelToken()\n+ self._reconnect_token = token\n+ self._reconnect_timer = threading.Timer(\n+ delay, lambda: self._io_queue.put((token, IoReconnect()))\n+ )\n+ self._reconnect_timer.daemon = True\n+ self._reconnect_timer.start()\n+ return int(delay)\n+\n+\n+def main_loop(\n+ io_queue: \"queue.Queue[IoActivity]\",\n+ server: Server,\n+ systray: SystrayState,\n+) -> None:\n+ reconnector = Reconnector(io_queue)\n+ handle_clients: Dict[PermuterHandle, Client] = {}\n+ while True:\n+ token, activity = io_queue.get()\n+ if token and token.cancelled:\n+ continue\n+\n+ if not isinstance(activity, tuple):\n+ if isinstance(activity, IoWillSleep):\n+ systray.will_sleep()\n+\n+ elif isinstance(activity, IoShutdown):\n+ break\n+\n+ elif isinstance(activity, IoReconnect):\n+ print(\"reconnecting...\")\n+ try:\n+ reconnector.mark_start()\n+ server.start()\n+ except EOFError:\n+ delay = reconnector.reconnect_eventually()\n+ print(f\"failed again, reconnecting in {delay} seconds...\")\n+ except ServerError as e:\n+ print(\"failed!\", e.message)\n+ except Exception:\n+ print(\"failed!\")\n+ traceback.print_exc()\n+\n+ elif isinstance(activity, IoServerFailed):\n+ print(\"disconnected from permuter@home\")\n+ server.stop()\n+ reconnector.mark_stop()\n+ systray.server_failed()\n+\n+ if activity.graceful:\n+ delay = reconnector.reconnect_eventually()\n+ print(f\"will reconnect in {delay} seconds...\")\n+\n+ else:\n+ static_assert_unreachable(activity)\n+\n+ else:\n+ handle, msg = activity\n+\n+ if isinstance(msg, IoConnect):\n+ client = msg.client\n+ handle_clients[handle] = client\n+ systray.connect(handle, client.nickname, msg.fn_name)\n+ print(f\"{client.nickname} connected ({msg.fn_name})\")\n+\n+ elif isinstance(msg, IoDisconnect):\n+ systray.disconnect(handle)\n+ nickname = handle_clients[handle].nickname\n+ del handle_clients[handle]\n+ print(f\"[{nickname}] {msg.reason}\")\n+\n+ elif isinstance(msg, IoImmediateDisconnect):\n+ print(f\"[{msg.client.nickname}] {msg.reason}\")\n+\n+ elif isinstance(msg, IoWorkDone):\n+ # TODO: statistics\n+ systray.work_done(handle, msg.is_improvement)\n+\n+ elif isinstance(msg, IoUserRemovePermuter):\n+ server.remove_permuter(handle)\n+\n+ else:\n+ static_assert_unreachable(msg)\n+\n+\n+def server_main(options: ServerOptions, use_systray: bool) -> None:\n+ io_queue: \"queue.Queue[IoActivity]\" = queue.Queue()\n+\n+ server = Server(options, io_queue)\n+ server.start()\n+\n+ try:\n+\n+ def cmdline_ui(systray: SystrayState) -> None:\n+ main_loop(io_queue, server, systray)\n+\n+ if use_systray:\n+ run_with_systray(io_queue, cmdline_ui)\n+ else:\n+ cmdline_ui(SystrayState())\n+ finally:\n+ server.stop()\ndiff --git a/src/net/cmd/setup.py b/src/net/cmd/setup.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/cmd/setup.py\n@@ -0,0 +1,87 @@\n+from argparse import ArgumentParser, Namespace\n+import base64\n+import os\n+import random\n+import string\n+import sys\n+import time\n+from typing import Optional\n+\n+from nacl.public import SealedBox\n+from nacl.signing import SigningKey, VerifyKey\n+\n+from .base import Command\n+from ..core import connect, Config, read_config, sign_with_magic, write_config\n+from .util import ask\n+\n+\n+class SetupCommand(Command):\n+ command = \"setup\"\n+ help = \"\"\"Set up permuter@home. This will require someone else to grant you\n+ access to the central server.\"\"\"\n+\n+ @staticmethod\n+ def add_arguments(parser: ArgumentParser) -> None:\n+ pass\n+\n+ @staticmethod\n+ def run(args: Namespace) -> None:\n+ _run_initial_setup()\n+\n+\n+def _random_name() -> str:\n+ return \"\".join(random.choice(string.ascii_lowercase) for _ in range(5))\n+\n+\n+def _run_initial_setup() -> None:\n+ config = read_config()\n+ signing_key: Optional[SigningKey] = config.signing_key\n+ if not signing_key or not ask(\"Keep previous secret key\", default=True):\n+ signing_key = SigningKey.generate()\n+ config.signing_key = signing_key\n+ write_config(config)\n+ verify_key = signing_key.verify_key\n+\n+ nickname: Optional[str] = config.initial_setup_nickname\n+ if not nickname or not ask(f\"Keep previous nickname [{nickname}]\", default=True):\n+ default_nickname = os.environ.get(\"USER\") or _random_name()\n+ nickname = (\n+ input(f\"Nickname [default: {default_nickname}]: \") or default_nickname\n+ )\n+ config.initial_setup_nickname = nickname\n+ write_config(config)\n+\n+ signed_nickname = sign_with_magic(b\"NAME\", signing_key, nickname.encode(\"utf-8\"))\n+\n+ vouch_data = verify_key.encode() + signed_nickname\n+ vouch_text = base64.b64encode(vouch_data).decode(\"utf-8\")\n+ print(\"Ask someone to run the following command:\")\n+ print(f\"./pah.py vouch {vouch_text}\")\n+ print()\n+ print(\"They should give you a token back in return. Paste that here:\")\n+ inp = input().strip()\n+\n+ try:\n+ token = base64.b64decode(inp.encode(\"utf-8\"))\n+ data = SealedBox(signing_key.to_curve25519_private_key()).decrypt(token)\n+ config.server_address = data[32:].decode(\"utf-8\")\n+ config.server_verify_key = VerifyKey(data[:32])\n+ config.initial_setup_nickname = None\n+ except Exception:\n+ print(\"Invalid token!\")\n+ sys.exit(1)\n+\n+ print(f\"Server: {config.server_address}\")\n+ print(\"Testing connection...\")\n+\n+ port = connect(config)\n+ port.send_json({\"method\": \"ping\"})\n+ port.receive_json()\n+\n+ try:\n+ write_config(config)\n+ except Exception as e:\n+ print(\"Failed to write config:\", e)\n+ sys.exit(1)\n+\n+ print(\"permuter@home successfully set up!\")\ndiff --git a/src/net/cmd/util.py b/src/net/cmd/util.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/cmd/util.py\n@@ -0,0 +1,15 @@\n+import sys\n+\n+\n+def ask(msg: str, *, default: bool) -> bool:\n+ if default:\n+ msg += \" (Y/n)? \"\n+ else:\n+ msg += \" (y/N)? \"\n+ res = input(msg).strip().lower()\n+ if not res:\n+ return default\n+ if res in [\"y\", \"yes\", \"n\", \"no\"]:\n+ return res[0] == \"y\"\n+ print(\"Bad response!\")\n+ sys.exit(1)\ndiff --git a/src/net/cmd/vouch.py b/src/net/cmd/vouch.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/cmd/vouch.py\n@@ -0,0 +1,73 @@\n+from argparse import ArgumentParser, Namespace\n+import base64\n+import sys\n+\n+from nacl.encoding import HexEncoder\n+from nacl.public import SealedBox\n+from nacl.signing import VerifyKey\n+\n+from ..core import connect, read_config, verify_with_magic\n+from .base import Command\n+from .util import ask\n+\n+\n+class VouchCommand(Command):\n+ command = \"vouch\"\n+ help = \"Give someone access to the central server.\"\n+\n+ @staticmethod\n+ def add_arguments(parser: ArgumentParser) -> None:\n+ parser.add_argument(\n+ \"magic\",\n+ help=\"Opaque hex string generated by 'setup'.\",\n+ )\n+\n+ @staticmethod\n+ def run(args: Namespace) -> None:\n+ run_vouch(args.magic)\n+\n+\n+def run_vouch(magic: str) -> None:\n+ try:\n+ vouch_data = base64.b64decode(magic.encode(\"utf-8\"))\n+ verify_key = VerifyKey(vouch_data[:32])\n+ signed_nickname = vouch_data[32:]\n+ msg = verify_with_magic(b\"NAME\", verify_key, signed_nickname)\n+ nickname = msg.decode(\"utf-8\")\n+ except Exception:\n+ print(\"Could not parse data!\")\n+ sys.exit(1)\n+\n+ try:\n+ config = read_config()\n+ port = connect(config)\n+ port.send_json(\n+ {\n+ \"method\": \"vouch\",\n+ \"who\": verify_key.encode(HexEncoder).decode(\"utf-8\"),\n+ \"signed_name\": HexEncoder.encode(signed_nickname).decode(\"utf-8\"),\n+ }\n+ )\n+ port.receive_json()\n+ except Exception as e:\n+ print(f\"Error: {e}\")\n+ sys.exit(1)\n+\n+ if not ask(f\"Grant permuter server access to {nickname}\", default=True):\n+ return\n+\n+ try:\n+ port.send_json({})\n+ port.receive_json()\n+ except Exception as e:\n+ print(f\"Failed to grant access: {e}\")\n+ sys.exit(1)\n+\n+ assert config.server_address, \"checked by connect\"\n+ assert config.server_verify_key, \"checked by connect\"\n+ data = config.server_verify_key.encode() + config.server_address.encode(\"utf-8\")\n+ token = SealedBox(verify_key.to_curve25519_public_key()).encrypt(data)\n+ print(\"Granted!\")\n+ print()\n+ print(\"Send them the following token:\")\n+ print(base64.b64encode(token).decode(\"utf-8\"))\ndiff --git a/src/net/core.py b/src/net/core.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/core.py\n@@ -0,0 +1,391 @@\n+import abc\n+from dataclasses import dataclass\n+import datetime\n+import json\n+import socket\n+import struct\n+import sys\n+import toml\n+import traceback\n+import typing\n+from typing import BinaryIO, List, Optional, Tuple, Type, TypeVar, Union\n+\n+from nacl.encoding import HexEncoder\n+from nacl.public import Box, PrivateKey, PublicKey\n+from nacl.secret import SecretBox\n+from nacl.signing import SigningKey, VerifyKey\n+\n+from ..error import ServerError\n+from ..helpers import exception_to_string\n+\n+T = TypeVar(\"T\")\n+AnyBox = Union[Box, SecretBox]\n+\n+PERMUTER_VERSION = 1\n+\n+CONFIG_FILENAME = \"pah.conf\"\n+\n+MIN_PRIO = 0.01\n+MAX_PRIO = 2.0\n+\n+DEBUG_MODE = False\n+\n+\n+def enable_debug_mode() -> None:\n+ \"\"\"Enable debug logging.\"\"\"\n+ global DEBUG_MODE\n+ DEBUG_MODE = True\n+\n+\n+def debug_print(message: str) -> None:\n+ if DEBUG_MODE:\n+ time = datetime.datetime.now().strftime(\"%H:%M:%S:%f\")\n+ print(f\"\\n{time} debug: {message}\")\n+\n+\n+@dataclass(eq=False)\n+class CancelToken:\n+ cancelled: bool = False\n+\n+\n+@dataclass\n+class PermuterData:\n+ base_score: int\n+ base_hash: str\n+ fn_name: str\n+ filename: str\n+ keep_prob: float\n+ need_profiler: bool\n+ stack_differences: bool\n+ compile_script: str\n+ source: str\n+ target_o_bin: bytes\n+\n+\n+def permuter_data_from_json(\n+ obj: dict, source: str, target_o_bin: bytes\n+) -> PermuterData:\n+ return PermuterData(\n+ base_score=json_prop(obj, \"base_score\", int),\n+ base_hash=json_prop(obj, \"base_hash\", str),\n+ fn_name=json_prop(obj, \"fn_name\", str),\n+ filename=json_prop(obj, \"filename\", str),\n+ keep_prob=json_prop(obj, \"keep_prob\", float),\n+ need_profiler=json_prop(obj, \"need_profiler\", bool),\n+ stack_differences=json_prop(obj, \"stack_differences\", bool),\n+ compile_script=json_prop(obj, \"compile_script\", str),\n+ source=source,\n+ target_o_bin=target_o_bin,\n+ )\n+\n+\n+def permuter_data_to_json(perm: PermuterData) -> dict:\n+ return {\n+ \"base_score\": perm.base_score,\n+ \"base_hash\": perm.base_hash,\n+ \"fn_name\": perm.fn_name,\n+ \"filename\": perm.filename,\n+ \"keep_prob\": perm.keep_prob,\n+ \"need_profiler\": perm.need_profiler,\n+ \"stack_differences\": perm.stack_differences,\n+ \"compile_script\": perm.compile_script,\n+ }\n+\n+\n+@dataclass\n+class Config:\n+ server_address: Optional[str] = None\n+ server_verify_key: Optional[VerifyKey] = None\n+ signing_key: Optional[SigningKey] = None\n+ initial_setup_nickname: Optional[str] = None\n+\n+\n+def read_config() -> Config:\n+ config = Config()\n+ try:\n+ with open(CONFIG_FILENAME) as f:\n+ obj = toml.load(f)\n+\n+ def read(key: str, t: Type[T]) -> Optional[T]:\n+ ret = obj.get(key)\n+ return ret if isinstance(ret, t) else None\n+\n+ temp = read(\"server_public_key\", str)\n+ if temp:\n+ config.server_verify_key = VerifyKey(HexEncoder.decode(temp))\n+ temp = read(\"secret_key\", str)\n+ if temp:\n+ config.signing_key = SigningKey(HexEncoder.decode(temp))\n+ config.initial_setup_nickname = read(\"initial_setup_nickname\", str)\n+ config.server_address = read(\"server_address\", str)\n+ except FileNotFoundError:\n+ pass\n+ except Exception:\n+ print(f\"Malformed configuration file {CONFIG_FILENAME}.\\n\")\n+ raise\n+ return config\n+\n+\n+def write_config(config: Config) -> None:\n+ obj = {}\n+\n+ def write(key: str, val: Union[None, str, int]) -> None:\n+ if val is not None:\n+ obj[key] = val\n+\n+ write(\"initial_setup_nickname\", config.initial_setup_nickname)\n+ write(\"server_address\", config.server_address)\n+\n+ key_hex: bytes\n+ if config.server_verify_key:\n+ key_hex = config.server_verify_key.encode(HexEncoder)\n+ write(\"server_public_key\", key_hex.decode(\"utf-8\"))\n+ if config.signing_key:\n+ key_hex = config.signing_key.encode(HexEncoder)\n+ write(\"secret_key\", key_hex.decode(\"utf-8\"))\n+\n+ with open(CONFIG_FILENAME, \"w\") as f:\n+ toml.dump(obj, f)\n+\n+\n+def file_read_fixed(inf: BinaryIO, n: int) -> bytes:\n+ try:\n+ ret = []\n+ while n > 0:\n+ data = inf.read(n)\n+ if not data:\n+ raise EOFError\n+ ret.append(data)\n+ n -= len(data)\n+ return b\"\".join(ret)\n+ except EOFError:\n+ raise\n+ except Exception as e:\n+ raise EOFError from e\n+\n+\n+def socket_read_fixed(sock: socket.socket, n: int) -> bytes:\n+ try:\n+ ret = []\n+ while n > 0:\n+ data = sock.recv(min(n, 4096))\n+ if not data:\n+ raise EOFError\n+ ret.append(data)\n+ n -= len(data)\n+ return b\"\".join(ret)\n+ except EOFError:\n+ raise\n+ except Exception as e:\n+ raise EOFError from e\n+\n+\n+def socket_shutdown(sock: socket.socket, how: int) -> None:\n+ try:\n+ sock.shutdown(how)\n+ except Exception:\n+ pass\n+\n+\n+def json_prop(obj: dict, prop: str, t: Type[T]) -> T:\n+ ret = obj.get(prop)\n+ if not isinstance(ret, t):\n+ if t is float and isinstance(ret, int):\n+ return typing.cast(T, float(ret))\n+ found_type = type(ret).__name__\n+ if prop not in obj:\n+ raise ValueError(f\"Member {prop} does not exist\")\n+ raise ValueError(f\"Member {prop} must have type {t.__name__}; got {found_type}\")\n+ return ret\n+\n+\n+def json_array(obj: list, t: Type[T]) -> List[T]:\n+ for elem in obj:\n+ if not isinstance(elem, t):\n+ found_type = type(elem).__name__\n+ raise ValueError(\n+ f\"Array elements must have type {t.__name__}; got {found_type}\"\n+ )\n+ return obj\n+\n+\n+def sign_with_magic(magic: bytes, signing_key: SigningKey, data: bytes) -> bytes:\n+ signature: bytes = signing_key.sign(magic + b\":\" + data).signature\n+ return signature + data\n+\n+\n+def verify_with_magic(magic: bytes, verify_key: VerifyKey, data: bytes) -> bytes:\n+ if len(data) < 64:\n+ raise ValueError(\"String is too small to contain a signature\")\n+ signature = data[:64]\n+ data = data[64:]\n+ verify_key.verify(magic + b\":\" + data, signature)\n+ return data\n+\n+\n+class Port(abc.ABC):\n+ def __init__(self, box: AnyBox, who: str, *, is_client: bool) -> None:\n+ self._box = box\n+ self._who = who\n+ self._send_nonce = 0 if is_client else 1\n+ self._receive_nonce = 1 if is_client else 0\n+\n+ @abc.abstractmethod\n+ def _send(self, data: bytes) -> None:\n+ ...\n+\n+ @abc.abstractmethod\n+ def _receive(self, length: int) -> bytes:\n+ ...\n+\n+ def send(self, msg: bytes) -> None:\n+ \"\"\"Send a binary message, potentially blocking.\"\"\"\n+ if DEBUG_MODE:\n+ if len(msg) <= 300:\n+ debug_print(f\"Send to {self._who}: {msg!r}\")\n+ else:\n+ debug_print(f\"Send to {self._who}: {len(msg)} bytes\")\n+ nonce = struct.pack(\">16xQ\", self._send_nonce)\n+ self._send_nonce += 2\n+ data = self._box.encrypt(msg, nonce).ciphertext\n+ length_data = struct.pack(\">Q\", len(data))\n+ self._send(length_data + data)\n+\n+ def send_json(self, msg: dict) -> None:\n+ \"\"\"Send a message in the form of a JSON dict, potentially blocking.\"\"\"\n+ self.send(json.dumps(msg).encode(\"utf-8\"))\n+\n+ def receive(self) -> bytes:\n+ \"\"\"Read a binary message, blocking.\"\"\"\n+ length_data = self._receive(8)\n+ if length_data[0]:\n+ # Lengths above 2^56 are unreasonable, so if we get one someone is\n+ # sending us bad data. Raise an exception to help debugging.\n+ raise Exception(\"Got unexpected data: \" + repr(length_data))\n+ length = struct.unpack(\">Q\", length_data)[0]\n+ data = self._receive(length)\n+ nonce = struct.pack(\">16xQ\", self._receive_nonce)\n+ self._receive_nonce += 2\n+ msg: bytes = self._box.decrypt(data, nonce)\n+ if DEBUG_MODE:\n+ if len(msg) <= 300:\n+ debug_print(f\"Receive from {self._who}: {msg!r}\")\n+ else:\n+ debug_print(f\"Receive from {self._who}: {len(msg)} bytes\")\n+ return msg\n+\n+ def receive_json(self) -> dict:\n+ \"\"\"Read a message in the form of a JSON dict, blocking.\"\"\"\n+ ret = json.loads(self.receive())\n+ if isinstance(ret, str):\n+ # Raw strings indicate errors.\n+ raise ServerError(ret)\n+ if not isinstance(ret, dict):\n+ # We always pass dictionaries as messages and no other data types,\n+ # to ensure future extensibility. (Other types are rare in\n+ # practice, anyway.)\n+ raise ValueError(\"Top-level JSON value must be a dictionary\")\n+ return ret\n+\n+\n+class SocketPort(Port):\n+ def __init__(\n+ self, sock: socket.socket, box: AnyBox, who: str, *, is_client: bool\n+ ) -> None:\n+ self._sock = sock\n+ super().__init__(box, who, is_client=is_client)\n+\n+ def _send(self, data: bytes) -> None:\n+ self._sock.sendall(data)\n+\n+ def _receive(self, length: int) -> bytes:\n+ return socket_read_fixed(self._sock, length)\n+\n+ def shutdown(self, how: int = socket.SHUT_RDWR) -> None:\n+ socket_shutdown(self._sock, how)\n+\n+ def close(self) -> None:\n+ self._sock.close()\n+\n+\n+class FilePort(Port):\n+ def __init__(\n+ self, inf: BinaryIO, outf: BinaryIO, box: AnyBox, who: str, *, is_client: bool\n+ ) -> None:\n+ self._inf = inf\n+ self._outf = outf\n+ super().__init__(box, who, is_client=is_client)\n+\n+ def _send(self, data: bytes) -> None:\n+ self._outf.write(data)\n+ self._outf.flush()\n+\n+ def _receive(self, length: int) -> bytes:\n+ return file_read_fixed(self._inf, length)\n+\n+\n+def _do_connect(config: Config) -> SocketPort:\n+ if (\n+ not config.server_verify_key\n+ or not config.signing_key\n+ or not config.server_address\n+ ):\n+ print(\n+ \"Using permuter@home requires someone to give you access to a central -J server.\\n\"\n+ \"Run `./pah.py setup` to set this up.\"\n+ )\n+ print()\n+ sys.exit(1)\n+\n+ host, port_str = config.server_address.split(\":\")\n+ try:\n+ sock = socket.create_connection((host, int(port_str)))\n+ except ConnectionRefusedError:\n+ raise EOFError(\"connection refused\") from None\n+ except socket.gaierror as e:\n+ raise EOFError(f\"DNS lookup failed: {e}\") from None\n+ except Exception as e:\n+ raise EOFError(\"unable to connect: \" + exception_to_string(e)) from None\n+\n+ # Send over the protocol version and an ephemeral encryption key which we\n+ # are going to use for all communication.\n+ ephemeral_key = PrivateKey.generate()\n+ ephemeral_key_data = ephemeral_key.public_key.encode()\n+ sock.sendall(b\"p@h0\" + ephemeral_key_data)\n+\n+ # Receive the server's encryption key, plus a signature of it and our own\n+ # ephemeral key -- this guarantees that we are talking to the server and\n+ # aren't victim to a replay attack. Use it to set up a communication port.\n+ msg = socket_read_fixed(sock, 32 + 64)\n+ server_enc_key_data = msg[:32]\n+ config.server_verify_key.verify(\n+ b\"HELLO:\" + ephemeral_key_data + server_enc_key_data, msg[32:]\n+ )\n+ box = Box(ephemeral_key, PublicKey(server_enc_key_data))\n+ port = SocketPort(sock, box, \"controller\", is_client=True)\n+\n+ # Use the encrypted port to send over our public key, proof that we are\n+ # able to sign new things with it, as well as permuter version.\n+ signature: bytes = config.signing_key.sign(\n+ b\"WORLD:\" + server_enc_key_data\n+ ).signature\n+ port.send(\n+ config.signing_key.verify_key.encode()\n+ + signature\n+ + struct.pack(\">I\", PERMUTER_VERSION)\n+ )\n+\n+ # Get an acknowledgement that the server wants to talk to us.\n+ obj = port.receive_json()\n+\n+ if \"message\" in obj:\n+ print(obj[\"message\"])\n+\n+ return port\n+\n+\n+def connect(config: Optional[Config] = None) -> SocketPort:\n+ \"\"\"Authenticate and connect to the permuter@home controller server.\"\"\"\n+ if not config:\n+ config = read_config()\n+ return _do_connect(config)\ndiff --git a/src/net/evaluator.py b/src/net/evaluator.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/evaluator.py\n@@ -0,0 +1,396 @@\n+\"\"\"This file runs as a free-standing program within a sandbox, and processes\n+permutation requests. It communicates with the outside world on stdin/stdout.\"\"\"\n+import base64\n+from dataclasses import dataclass\n+import math\n+from multiprocessing import Process, Queue\n+import os\n+import queue\n+import struct\n+import sys\n+from tempfile import mkstemp\n+import threading\n+import time\n+import traceback\n+from typing import BinaryIO, Counter, Dict, List, Optional, Set, Tuple, Union\n+import zlib\n+\n+from nacl.secret import SecretBox\n+\n+from ..candidate import CandidateResult\n+from ..compiler import Compiler\n+from ..error import CandidateConstructionFailure\n+from ..helpers import exception_to_string, static_assert_unreachable\n+from ..permuter import EvalError, EvalResult, Permuter\n+from ..profiler import Profiler\n+from ..scorer import Scorer\n+from .core import (\n+ FilePort,\n+ PermuterData,\n+ Port,\n+ json_prop,\n+ permuter_data_from_json,\n+)\n+\n+\n+def _fix_stdout() -> None:\n+ \"\"\"Redirect stdout to stderr to make print() debugging work. This function\n+ *must* be called at startup for each (sub)process, since we use stdout for\n+ our own communication purposes.\"\"\"\n+ sys.stdout = sys.stderr\n+\n+ # In addition, we set stderr to flush on newlines, which not happen by\n+ # default when it is piped. (Requires Python 3.7, but we can assume that's\n+ # available inside the sandbox.)\n+ sys.stdout.reconfigure(line_buffering=True) # type: ignore\n+\n+\n+def _setup_port(secret: bytes) -> Port:\n+ \"\"\"Set up communication with the outside world.\"\"\"\n+ port = FilePort(\n+ sys.stdin.buffer,\n+ sys.stdout.buffer,\n+ SecretBox(secret),\n+ \"server\",\n+ is_client=False,\n+ )\n+\n+ # Follow the controlling process's sanity check protocol.\n+ magic = port.receive()\n+ port.send(magic)\n+\n+ return port\n+\n+\n+def _create_permuter(data: PermuterData) -> Permuter:\n+ fd, path = mkstemp(suffix=\".o\", prefix=\"permuter\", text=False)\n+ try:\n+ with os.fdopen(fd, \"wb\") as f:\n+ f.write(data.target_o_bin)\n+ scorer = Scorer(target_o=path, stack_differences=data.stack_differences)\n+ finally:\n+ os.unlink(path)\n+\n+ fd, path = mkstemp(suffix=\".sh\", prefix=\"permuter\", text=True)\n+ try:\n+ os.chmod(fd, 0o755)\n+ with os.fdopen(fd, \"w\") as f2:\n+ f2.write(data.compile_script)\n+ compiler = Compiler(compile_cmd=path, show_errors=False)\n+\n+ return Permuter(\n+ dir=\"unused\",\n+ fn_name=data.fn_name,\n+ compiler=compiler,\n+ scorer=scorer,\n+ source_file=data.filename,\n+ source=data.source,\n+ force_seed=None,\n+ force_rng_seed=None,\n+ keep_prob=data.keep_prob,\n+ need_profiler=data.need_profiler,\n+ need_all_sources=False,\n+ show_errors=False,\n+ better_only=False,\n+ best_only=False,\n+ )\n+ except:\n+ os.unlink(path)\n+ raise\n+\n+\n+def _remove_permuter(perm: Permuter) -> None:\n+ os.unlink(perm.compiler.compile_cmd)\n+\n+\n+def _send_result(perm_id: str, time_us: float, res: EvalResult, port: Port) -> None:\n+ if isinstance(res, EvalError):\n+ port.send_json(\n+ {\n+ \"type\": \"result\",\n+ \"id\": perm_id,\n+ \"time_us\": time_us,\n+ \"error\": res.exc_str,\n+ }\n+ )\n+ return\n+\n+ compressed_source = getattr(res, \"compressed_source\")\n+\n+ obj = {\n+ \"type\": \"result\",\n+ \"id\": perm_id,\n+ \"time_us\": time_us,\n+ \"score\": res.score,\n+ \"has_source\": compressed_source is not None,\n+ }\n+ if res.hash is not None:\n+ obj[\"hash\"] = res.hash\n+ if res.profiler is not None:\n+ obj[\"profiler\"] = {\n+ st.name: res.profiler.time_stats[st] for st in Profiler.StatType\n+ }\n+\n+ port.send_json(obj)\n+\n+ if compressed_source is not None:\n+ port.send(compressed_source)\n+\n+\n+@dataclass\n+class AddPermuter:\n+ perm_id: str\n+ data: PermuterData\n+\n+\n+@dataclass\n+class AddPermuterLocal:\n+ perm_id: str\n+ permuter: Permuter\n+\n+\n+@dataclass\n+class RemovePermuter:\n+ perm_id: str\n+\n+\n+@dataclass\n+class WorkDone:\n+ perm_id: str\n+ time_us: float\n+ result: EvalResult\n+\n+\n+@dataclass\n+class Work:\n+ perm_id: str\n+ seed: int\n+\n+\n+class NeedMoreWork:\n+ pass\n+\n+\n+LocalWork = Tuple[Union[AddPermuterLocal, RemovePermuter], int]\n+GlobalWork = Tuple[Work, int]\n+Task = Union[AddPermuter, RemovePermuter, Work, WorkDone, NeedMoreWork]\n+\n+\n+def multiprocess_worker(\n+ worker_queue: \"Queue[GlobalWork]\",\n+ local_queue: \"Queue[LocalWork]\",\n+ task_queue: \"Queue[Task]\",\n+) -> None:\n+ _fix_stdout()\n+\n+ permuters: Dict[str, Permuter] = {}\n+ timestamp = 0\n+\n+ while True:\n+ try:\n+ work, required_timestamp = worker_queue.get(block=False)\n+ except queue.Empty:\n+ task_queue.put(NeedMoreWork())\n+ work, required_timestamp = worker_queue.get()\n+ while True:\n+ try:\n+ block = timestamp < required_timestamp\n+ task, timestamp = local_queue.get(block=block)\n+ except queue.Empty:\n+ break\n+ if isinstance(task, AddPermuterLocal):\n+ permuters[task.perm_id] = task.permuter\n+ elif isinstance(task, RemovePermuter):\n+ del permuters[task.perm_id]\n+ else:\n+ static_assert_unreachable(task)\n+\n+ time_before = time.time()\n+\n+ permuter = permuters[work.perm_id]\n+ result = permuter.try_eval_candidate(work.seed)\n+ if isinstance(result, CandidateResult) and permuter.should_output(result):\n+ permuter.record_result(result)\n+\n+ # Compress the source within the worker. (Why waste a free\n+ # multi-threading opportunity?)\n+ if isinstance(result, CandidateResult):\n+ compressed_source: Optional[bytes] = None\n+ if result.source is not None:\n+ compressed_source = zlib.compress(result.source.encode(\"utf-8\"))\n+ setattr(result, \"compressed_source\", compressed_source)\n+ result.source = None\n+\n+ time_us = int((time.time() - time_before) * 10 ** 6)\n+ task_queue.put(WorkDone(perm_id=work.perm_id, time_us=time_us, result=result))\n+\n+\n+def read_loop(task_queue: \"Queue[Task]\", port: Port) -> None:\n+ try:\n+ while True:\n+ item = port.receive_json()\n+ msg_type = json_prop(item, \"type\", str)\n+ if msg_type == \"add\":\n+ perm_id = json_prop(item, \"id\", str)\n+ source = port.receive().decode(\"utf-8\")\n+ target_o_bin = port.receive()\n+ data = permuter_data_from_json(item, source, target_o_bin)\n+ task_queue.put(AddPermuter(perm_id=perm_id, data=data))\n+\n+ elif msg_type == \"remove\":\n+ perm_id = json_prop(item, \"id\", str)\n+ task_queue.put(RemovePermuter(perm_id=perm_id))\n+\n+ elif msg_type == \"work\":\n+ perm_id = json_prop(item, \"id\", str)\n+ seed = json_prop(item, \"seed\", int)\n+ task_queue.put(Work(perm_id=perm_id, seed=seed))\n+\n+ else:\n+ raise Exception(f\"Invalid message type {msg_type}\")\n+\n+ except EOFError:\n+ # Port closed from the other side. Silently exit, to avoid ugly error\n+ # messages and to ensure that the Docker container really stops and\n+ # gets removed. (The parent server has a \"finally:\" that does that, but\n+ # it's evidently not 100% trustworthy. I'm speculating that pystray\n+ # might be to blame, by reverting the signal handler for SIGINT to\n+ # the default, making Ctrl+C kill the program directly without firing\n+ # \"finally\"s. Either way, defense in depth here doesn't hurt, since\n+ # leaking Docker containers is pretty bad.)\n+ os._exit(1)\n+\n+ except Exception:\n+ traceback.print_exc()\n+ os._exit(1)\n+\n+\n+def main() -> None:\n+ secret = base64.b64decode(os.environ[\"SECRET\"])\n+ del os.environ[\"SECRET\"]\n+ os.environ[\"PERMUTER_IS_REMOTE\"] = \"1\"\n+\n+ port = _setup_port(secret)\n+ _fix_stdout()\n+\n+ obj = port.receive_json()\n+ num_cores = json_prop(obj, \"num_cores\", float)\n+ num_threads = math.ceil(num_cores)\n+\n+ worker_queue: \"Queue[GlobalWork]\" = Queue()\n+ task_queue: \"Queue[Task]\" = Queue()\n+ local_queues: \"List[Queue[LocalWork]]\" = []\n+\n+ for i in range(num_threads):\n+ local_queue: \"Queue[LocalWork]\" = Queue()\n+ p = Process(\n+ target=multiprocess_worker,\n+ args=(worker_queue, local_queue, task_queue),\n+ )\n+ p.start()\n+ local_queues.append(local_queue)\n+\n+ reader_thread = threading.Thread(target=read_loop, args=(task_queue, port))\n+ reader_thread.start()\n+\n+ remaining_work: Counter[str] = Counter()\n+ should_remove: Set[str] = set()\n+ permuters: Dict[str, Permuter] = {}\n+ timestamp = 0\n+\n+ def try_remove(perm_id: str) -> None:\n+ nonlocal timestamp\n+ assert perm_id in permuters\n+ if perm_id not in should_remove or remaining_work[perm_id] != 0:\n+ return\n+ del remaining_work[perm_id]\n+ should_remove.remove(perm_id)\n+ timestamp += 1\n+ for queue in local_queues:\n+ queue.put((RemovePermuter(perm_id=perm_id), timestamp))\n+ _remove_permuter(permuters[perm_id])\n+ del permuters[perm_id]\n+\n+ while True:\n+ item = task_queue.get()\n+\n+ if isinstance(item, AddPermuter):\n+ assert item.perm_id not in permuters\n+\n+ msg: Dict[str, object] = {\n+ \"type\": \"init\",\n+ \"id\": item.perm_id,\n+ }\n+\n+ time_before = time.time()\n+ try:\n+ # Construct a permuter. This involves a compilation on the main\n+ # thread, which isn't great but we can live with it for now.\n+ permuter = _create_permuter(item.data)\n+\n+ if permuter.base_score != item.data.base_score:\n+ _remove_permuter(permuter)\n+ score_str = f\"{permuter.base_score} vs {item.data.base_score}\"\n+ if permuter.base_hash == item.data.base_hash:\n+ hash_str = \"same hash; different Python or permuter versions?\"\n+ else:\n+ hash_str = \"different hash; different objdump versions?\"\n+ raise CandidateConstructionFailure(\n+ f\"mismatching score: {score_str} ({hash_str})\"\n+ )\n+\n+ permuters[item.perm_id] = permuter\n+\n+ msg[\"success\"] = True\n+ msg[\"base_score\"] = permuter.base_score\n+ msg[\"base_hash\"] = permuter.base_hash\n+\n+ # Tell all the workers about the new permuter.\n+ # TODO: ideally we would also seed their Candidate lru_cache's\n+ # to avoid all workers having to parse the source...\n+ timestamp += 1\n+ for queue in local_queues:\n+ queue.put(\n+ (\n+ AddPermuterLocal(perm_id=item.perm_id, permuter=permuter),\n+ timestamp,\n+ )\n+ )\n+ except Exception as e:\n+ # This shouldn't practically happen, since the client compiled\n+ # the code successfully. Print a message if it does.\n+ msg[\"success\"] = False\n+ msg[\"error\"] = exception_to_string(e)\n+ if isinstance(e, CandidateConstructionFailure):\n+ print(e.message)\n+ else:\n+ traceback.print_exc()\n+\n+ msg[\"time_us\"] = int((time.time() - time_before) * 10 ** 6)\n+ port.send_json(msg)\n+\n+ elif isinstance(item, RemovePermuter):\n+ # Silently ignore requests to remove permuters that have already\n+ # been removed, which can occur when AddPermuter fails.\n+ if item.perm_id in permuters:\n+ should_remove.add(item.perm_id)\n+ try_remove(item.perm_id)\n+\n+ elif isinstance(item, WorkDone):\n+ remaining_work[item.perm_id] -= 1\n+ try_remove(item.perm_id)\n+ _send_result(item.perm_id, item.time_us, item.result, port)\n+\n+ elif isinstance(item, Work):\n+ remaining_work[item.perm_id] += 1\n+ worker_queue.put((item, timestamp))\n+\n+ elif isinstance(item, NeedMoreWork):\n+ port.send_json({\"type\": \"need_work\"})\n+\n+ else:\n+ static_assert_unreachable(item)\n+\n+\n+if __name__ == \"__main__\":\n+ main()\ndiff --git a/src/net/server.py b/src/net/server.py\nnew file mode 100644\n--- /dev/null\n+++ b/src/net/server.py\n@@ -0,0 +1,917 @@\n+import abc\n+import base64\n+from dataclasses import dataclass, field\n+from enum import Enum\n+import json\n+import os\n+import pathlib\n+import queue\n+import socket\n+import socketserver\n+import struct\n+import subprocess\n+import sys\n+import threading\n+import time\n+import traceback\n+from typing import BinaryIO, Dict, List, Optional, Set, Tuple, Union\n+import uuid\n+import zlib\n+\n+import docker\n+from nacl.public import Box, PrivateKey, PublicKey\n+from nacl.secret import SecretBox\n+from nacl.signing import SigningKey, VerifyKey\n+import nacl.utils\n+\n+from ..helpers import exception_to_string, static_assert_unreachable\n+from .core import (\n+ CancelToken,\n+ PermuterData,\n+ Port,\n+ SocketPort,\n+ connect,\n+ file_read_fixed,\n+ json_prop,\n+ permuter_data_from_json,\n+ permuter_data_to_json,\n+)\n+\n+\n+_HEARTBEAT_INTERVAL_SLACK: float = 50.0\n+\n+\n+@dataclass\n+class Client:\n+ id: str\n+ nickname: str\n+\n+\n+class InitState(Enum):\n+ UNINIT = 0\n+ WAITING = 1\n+ READY = 2\n+\n+\n+@dataclass\n+class ClientState:\n+ handle: int\n+ client: Client\n+ init_state: InitState = InitState.UNINIT\n+\n+\n+@dataclass\n+class AddPermuter:\n+ handle: int\n+ client: Client\n+ permuter_data: PermuterData\n+\n+\n+@dataclass\n+class RemovePermuter:\n+ handle: int\n+\n+\n+@dataclass\n+class Work:\n+ handle: int\n+ seed: int\n+\n+\n+@dataclass\n+class ImmediateDisconnect:\n+ handle: int\n+ client: Client\n+ reason: str\n+\n+\n+@dataclass\n+class Disconnect:\n+ handle: int\n+\n+\n+@dataclass\n+class PermInitFail:\n+ perm_id: str\n+ error: str\n+\n+\n+@dataclass\n+class PermInitSuccess:\n+ perm_id: str\n+ base_score: int\n+ base_hash: str\n+ time_us: float\n+\n+\n+@dataclass\n+class WorkDone:\n+ perm_id: str\n+ obj: dict\n+ time_us: float\n+ compressed_source: Optional[bytes]\n+\n+\n+class NeedMoreWork:\n+ pass\n+\n+\n+@dataclass\n+class NetThreadDisconnected:\n+ graceful: bool\n+\n+\n+class Heartbeat:\n+ pass\n+\n+\n+class Shutdown:\n+ pass\n+\n+\n+Activity = Union[\n+ AddPermuter,\n+ RemovePermuter,\n+ Work,\n+ ImmediateDisconnect,\n+ Disconnect,\n+ PermInitFail,\n+ PermInitSuccess,\n+ WorkDone,\n+ NeedMoreWork,\n+ NetThreadDisconnected,\n+ Heartbeat,\n+ Shutdown,\n+]\n+\n+\n+@dataclass\n+class OutputInitFail:\n+ handle: int\n+ error: str\n+\n+\n+@dataclass\n+class OutputInitSuccess:\n+ handle: int\n+ base_score: int\n+ base_hash: str\n+ time_us: float\n+\n+\n+@dataclass\n+class OutputDisconnect:\n+ handle: int\n+\n+\n+@dataclass\n+class OutputNeedMoreWork:\n+ pass\n+\n+\n+@dataclass\n+class OutputWork:\n+ handle: int\n+ time_us: float\n+ obj: dict\n+ compressed_source: Optional[bytes]\n+\n+\n+Output = Union[\n+ OutputDisconnect,\n+ OutputInitFail,\n+ OutputInitSuccess,\n+ OutputNeedMoreWork,\n+ OutputWork,\n+ Shutdown,\n+]\n+\n+\n+@dataclass\n+class IoConnect:\n+ fn_name: str\n+ client: Client\n+\n+\n+@dataclass\n+class IoDisconnect:\n+ reason: str\n+\n+\n+@dataclass\n+class IoImmediateDisconnect:\n+ reason: str\n+ client: Client\n+\n+\n+class IoUserRemovePermuter:\n+ pass\n+\n+\n+@dataclass\n+class IoServerFailed:\n+ graceful: bool\n+\n+\n+class IoReconnect:\n+ pass\n+\n+\n+class IoShutdown:\n+ pass\n+\n+\n+class IoWillSleep:\n+ pass\n+\n+\n+@dataclass\n+class IoWorkDone:\n+ score: Optional[int]\n+ is_improvement: bool\n+\n+\n+PermuterHandle = Tuple[int, CancelToken]\n+IoMessage = Union[\n+ IoConnect, IoDisconnect, IoImmediateDisconnect, IoUserRemovePermuter, IoWorkDone\n+]\n+IoGlobalMessage = Union[IoReconnect, IoShutdown, IoServerFailed, IoWillSleep]\n+IoActivity = Tuple[\n+ Optional[CancelToken], Union[Tuple[PermuterHandle, IoMessage], IoGlobalMessage]\n+]\n+\n+\n+@dataclass\n+class ServerOptions:\n+ num_cores: float\n+ max_memory_gb: float\n+ min_priority: float\n+\n+\n+class NetThread:\n+ _port: Optional[SocketPort]\n+ _main_queue: \"queue.Queue[Activity]\"\n+ _controller_queue: \"queue.Queue[Output]\"\n+ _read_thread: \"threading.Thread\"\n+ _write_thread: \"threading.Thread\"\n+\n+ def __init__(\n+ self,\n+ port: SocketPort,\n+ main_queue: \"queue.Queue[Activity]\",\n+ ) -> None:\n+ self._port = port\n+ self._main_queue = main_queue\n+ self._controller_queue = queue.Queue()\n+\n+ self._read_thread = threading.Thread(target=self.read_loop)\n+ self._read_thread.daemon = True\n+ self._read_thread.start()\n+\n+ self._write_thread = threading.Thread(target=self.write_loop)\n+ self._write_thread.daemon = True\n+ self._write_thread.start()\n+\n+ def stop(self) -> None:\n+ if self._port is None:\n+ return\n+ try:\n+ self._controller_queue.put(Shutdown())\n+ self._port.shutdown()\n+ self._read_thread.join()\n+ self._write_thread.join()\n+ self._port.close()\n+ self._port = None\n+ except Exception:\n+ print(\"Failed to stop net thread.\")\n+ traceback.print_exc()\n+\n+ def send_controller(self, msg: Output) -> None:\n+ self._controller_queue.put(msg)\n+\n+ def _read_one(self) -> Activity:\n+ assert self._port is not None\n+\n+ msg = self._port.receive_json()\n+\n+ msg_type = json_prop(msg, \"type\", str)\n+\n+ if msg_type == \"heartbeat\":\n+ return Heartbeat()\n+\n+ handle = json_prop(msg, \"permuter\", int)\n+\n+ if msg_type == \"work\":\n+ seed = json_prop(msg, \"seed\", int)\n+ return Work(handle=handle, seed=seed)\n+\n+ elif msg_type == \"add\":\n+ client_id = json_prop(msg, \"client_id\", str)\n+ client_name = json_prop(msg, \"client_name\", str)\n+ client = Client(client_id, client_name)\n+ data = json_prop(msg, \"data\", dict)\n+ compressed_source = self._port.receive()\n+ compressed_target_o_bin = self._port.receive()\n+\n+ try:\n+ source = zlib.decompress(compressed_source).decode(\"utf-8\")\n+ target_o_bin = zlib.decompress(compressed_target_o_bin)\n+ permuter = permuter_data_from_json(data, source, target_o_bin)\n+ except Exception as e:\n+ # Client sent something illegible. This can legitimately happen if the\n+ # client runs another version, but it's interesting to log.\n+ traceback.print_exc()\n+ return ImmediateDisconnect(\n+ handle=handle,\n+ client=client,\n+ reason=f\"Failed to parse permuter: {exception_to_string(e)}\",\n+ )\n+\n+ return AddPermuter(\n+ handle=handle,\n+ client=client,\n+ permuter_data=permuter,\n+ )\n+\n+ elif msg_type == \"remove\":\n+ return RemovePermuter(handle=handle)\n+\n+ else:\n+ raise Exception(f\"Bad message type: {msg_type}\")\n+\n+ def read_loop(self) -> None:\n+ try:\n+ while True:\n+ msg = self._read_one()\n+ self._main_queue.put(msg)\n+ except EOFError:\n+ self._main_queue.put(NetThreadDisconnected(graceful=True))\n+ except Exception:\n+ traceback.print_exc()\n+ self._main_queue.put(NetThreadDisconnected(graceful=False))\n+\n+ def _write_one(self, item: Output) -> None:\n+ assert self._port is not None\n+\n+ if isinstance(item, Shutdown):\n+ # Handled by caller\n+ pass\n+\n+ elif isinstance(item, OutputInitFail):\n+ self._port.send_json(\n+ {\n+ \"type\": \"update\",\n+ \"permuter\": item.handle,\n+ \"time_us\": 0,\n+ \"update\": {\"type\": \"init_failed\", \"reason\": item.error},\n+ }\n+ )\n+\n+ elif isinstance(item, OutputInitSuccess):\n+ self._port.send_json(\n+ {\n+ \"type\": \"update\",\n+ \"permuter\": item.handle,\n+ \"time_us\": item.time_us,\n+ \"update\": {\"type\": \"init_done\", \"hash\": item.base_hash},\n+ }\n+ )\n+\n+ elif isinstance(item, OutputDisconnect):\n+ self._port.send_json(\n+ {\n+ \"type\": \"update\",\n+ \"permuter\": item.handle,\n+ \"time_us\": 0,\n+ \"update\": {\"type\": \"disconnect\"},\n+ }\n+ )\n+\n+ elif isinstance(item, OutputNeedMoreWork):\n+ self._port.send_json({\"type\": \"need_work\"})\n+\n+ elif isinstance(item, OutputWork):\n+ self._port.send_json(\n+ {\n+ \"type\": \"update\",\n+ \"permuter\": item.handle,\n+ \"time_us\": item.time_us,\n+ \"update\": {\n+ \"type\": \"work\",\n+ **item.obj,\n+ },\n+ }\n+ )\n+ if item.compressed_source is not None:\n+ self._port.send(item.compressed_source)\n+\n+ else:\n+ static_assert_unreachable(item)\n+\n+ def write_loop(self) -> None:\n+ try:\n+ while True:\n+ item = self._controller_queue.get()\n+ if isinstance(item, Shutdown):\n+ break\n+ self._write_one(item)\n+ except EOFError:\n+ self._main_queue.put(NetThreadDisconnected(graceful=True))\n+ except Exception:\n+ traceback.print_exc()\n+ self._main_queue.put(NetThreadDisconnected(graceful=False))\n+\n+\n+class ServerInner:\n+ \"\"\"This class represents an up-and-running server, connected to the controller and\n+ to the evaluator.\"\"\"\n+\n+ _evaluator_port: \"DockerPort\"\n+ _main_queue: \"queue.Queue[Activity]\"\n+ _io_queue: \"queue.Queue[IoActivity]\"\n+ _net_thread: NetThread\n+ _read_eval_thread: threading.Thread\n+ _main_thread: threading.Thread\n+ _heartbeat_interval: float\n+ _last_heartbeat: float\n+ _last_heartbeat_lock: threading.Lock\n+ _active: Set[int]\n+ _token: CancelToken\n+\n+ def __init__(\n+ self,\n+ net_port: SocketPort,\n+ evaluator_port: \"DockerPort\",\n+ io_queue: \"queue.Queue[IoActivity]\",\n+ heartbeat_interval: float,\n+ ) -> None:\n+ self._evaluator_port = evaluator_port\n+ self._main_queue = queue.Queue()\n+ self._io_queue = io_queue\n+ self._active = set()\n+ self._token = CancelToken()\n+\n+ self._net_thread = NetThread(net_port, self._main_queue)\n+\n+ # Start a thread for checking heartbeats.\n+ self._heartbeat_interval = heartbeat_interval\n+ self._last_heartbeat = time.time()\n+ self._last_heartbeat_lock = threading.Lock()\n+ self._heartbeat_stop = threading.Event()\n+ self._heartbeat_thread = threading.Thread(target=self._heartbeat_loop)\n+ self._heartbeat_thread.daemon = True\n+ self._heartbeat_thread.start()\n+\n+ # Start a thread for reading evaluator results and sending them on to\n+ # the main loop queue.\n+ self._read_eval_thread = threading.Thread(target=self._read_eval_loop)\n+ self._read_eval_thread.daemon = True\n+ self._read_eval_thread.start()\n+\n+ # Start a thread for the main loop.\n+ self._main_thread = threading.Thread(target=self._main_loop)\n+ self._main_thread.daemon = True\n+ self._main_thread.start()\n+\n+ def _send_controller(self, msg: Output) -> None:\n+ self._net_thread.send_controller(msg)\n+\n+ def _send_io(self, handle: int, io_msg: IoMessage) -> None:\n+ self._io_queue.put((self._token, ((handle, self._token), io_msg)))\n+\n+ def _send_io_global(self, io_msg: IoGlobalMessage) -> None:\n+ self._io_queue.put((self._token, io_msg))\n+\n+ def _handle_message(self, msg: Activity) -> None:\n+ if isinstance(msg, Shutdown):\n+ # Handled by caller\n+ pass\n+\n+ elif isinstance(msg, Heartbeat):\n+ with self._last_heartbeat_lock:\n+ self._last_heartbeat = time.time()\n+\n+ elif isinstance(msg, Work):\n+ if msg.handle not in self._active:\n+ self._need_work()\n+ return\n+\n+ self._evaluator_port.send_json(\n+ {\n+ \"type\": \"work\",\n+ \"id\": str(msg.handle),\n+ \"seed\": msg.seed,\n+ }\n+ )\n+\n+ elif isinstance(msg, AddPermuter):\n+ if msg.handle in self._active:\n+ raise Exception(\"Repeated AddPermuter!\")\n+\n+ self._active.add(msg.handle)\n+ self._send_permuter(str(msg.handle), msg.permuter_data)\n+ fn_name = msg.permuter_data.fn_name\n+ self._send_io(msg.handle, IoConnect(fn_name, msg.client))\n+\n+ elif isinstance(msg, RemovePermuter):\n+ if msg.handle not in self._active:\n+ return\n+\n+ self._remove(msg.handle)\n+ self._send_io(msg.handle, IoDisconnect(\"disconnected\"))\n+\n+ elif isinstance(msg, Disconnect):\n+ if msg.handle not in self._active:\n+ return\n+\n+ self._remove(msg.handle)\n+ self._send_io(msg.handle, IoDisconnect(\"kicked\"))\n+ self._send_controller(OutputDisconnect(handle=msg.handle))\n+\n+ elif isinstance(msg, ImmediateDisconnect):\n+ if msg.handle in self._active:\n+ raise Exception(\"ImmediateDisconnect is not immediate\")\n+\n+ self._send_io(\n+ msg.handle, IoImmediateDisconnect(\"sent garbage message\", msg.client)\n+ )\n+ self._send_controller(OutputDisconnect(handle=msg.handle))\n+\n+ elif isinstance(msg, PermInitFail):\n+ handle = int(msg.perm_id)\n+ if handle not in self._active:\n+ self._need_work()\n+ return\n+\n+ self._active.remove(handle)\n+ self._send_io(handle, IoDisconnect(\"failed to compile\"))\n+ self._send_controller(\n+ OutputInitFail(\n+ handle=handle,\n+ error=msg.error,\n+ )\n+ )\n+\n+ elif isinstance(msg, PermInitSuccess):\n+ handle = int(msg.perm_id)\n+ if handle not in self._active:\n+ self._need_work()\n+ return\n+\n+ self._send_controller(\n+ OutputInitSuccess(\n+ handle=handle,\n+ time_us=msg.time_us,\n+ base_score=msg.base_score,\n+ base_hash=msg.base_hash,\n+ )\n+ )\n+\n+ elif isinstance(msg, WorkDone):\n+ handle = int(msg.perm_id)\n+ if handle not in self._active:\n+ self._need_work()\n+ return\n+\n+ obj = msg.obj\n+ obj[\"permuter\"] = handle\n+ score = json_prop(obj, \"score\", int) if \"score\" in obj else None\n+ is_improvement = msg.compressed_source is not None\n+ self._send_io(\n+ handle,\n+ IoWorkDone(score=score, is_improvement=is_improvement),\n+ )\n+ self._send_controller(\n+ OutputWork(\n+ handle=handle,\n+ time_us=msg.time_us,\n+ obj=obj,\n+ compressed_source=msg.compressed_source,\n+ )\n+ )\n+\n+ elif isinstance(msg, NeedMoreWork):\n+ self._need_work()\n+\n+ elif isinstance(msg, NetThreadDisconnected):\n+ self._send_io_global(IoServerFailed(msg.graceful))\n+\n+ else:\n+ static_assert_unreachable(msg)\n+\n+ def _need_work(self) -> None:\n+ self._send_controller(OutputNeedMoreWork())\n+\n+ def _remove(self, handle: int) -> None:\n+ self._evaluator_port.send_json({\"type\": \"remove\", \"id\": str(handle)})\n+ self._active.remove(handle)\n+\n+ def _send_permuter(self, id: str, perm: PermuterData) -> None:\n+ self._evaluator_port.send_json(\n+ {\"type\": \"add\", \"id\": id, **permuter_data_to_json(perm)}\n+ )\n+ self._evaluator_port.send(perm.source.encode(\"utf-8\"))\n+ self._evaluator_port.send(perm.target_o_bin)\n+\n+ def _do_read_eval_loop(self) -> None:\n+ while True:\n+ msg = self._evaluator_port.receive_json()\n+ msg_type = json_prop(msg, \"type\", str)\n+\n+ if msg_type == \"init\":\n+ perm_id = json_prop(msg, \"id\", str)\n+ time_us = json_prop(msg, \"time_us\", float)\n+ resp: Activity\n+ if json_prop(msg, \"success\", bool):\n+ resp = PermInitSuccess(\n+ perm_id=perm_id,\n+ base_score=json_prop(msg, \"base_score\", int),\n+ base_hash=json_prop(msg, \"base_hash\", str),\n+ time_us=time_us,\n+ )\n+ else:\n+ resp = PermInitFail(\n+ perm_id=perm_id,\n+ error=json_prop(msg, \"error\", str),\n+ )\n+ self._main_queue.put(resp)\n+\n+ elif msg_type == \"result\":\n+ compressed_source: Optional[bytes] = None\n+ if msg.get(\"has_source\") == True:\n+ compressed_source = self._evaluator_port.receive()\n+ perm_id = json_prop(msg, \"id\", str)\n+ time_us = json_prop(msg, \"time_us\", float)\n+ del msg[\"id\"]\n+ del msg[\"time_us\"]\n+ self._main_queue.put(\n+ WorkDone(\n+ perm_id=perm_id,\n+ obj=msg,\n+ time_us=time_us,\n+ compressed_source=compressed_source,\n+ )\n+ )\n+\n+ elif msg_type == \"need_work\":\n+ self._main_queue.put(NeedMoreWork())\n+\n+ else:\n+ raise Exception(f\"Unknown message type from evaluator: {msg_type}\")\n+\n+ def _read_eval_loop(self) -> None:\n+ try:\n+ self._do_read_eval_loop()\n+ except EOFError:\n+ # Silence errors from shutdown.\n+ pass\n+\n+ def _main_loop(self) -> None:\n+ while True:\n+ msg = self._main_queue.get()\n+ if isinstance(msg, Shutdown):\n+ break\n+\n+ self._handle_message(msg)\n+\n+ if not self._active and self._main_queue.empty():\n+ self._send_io_global(IoWillSleep())\n+\n+ def _heartbeat_loop(self) -> None:\n+ second_attempt = False\n+ while True:\n+ with self._last_heartbeat_lock:\n+ delay = (\n+ self._last_heartbeat\n+ + self._heartbeat_interval\n+ + _HEARTBEAT_INTERVAL_SLACK / 2\n+ - time.time()\n+ )\n+ if delay <= 0:\n+ if second_attempt:\n+ self._main_queue.put(NetThreadDisconnected(graceful=True))\n+ return\n+ # Handle clock skew or computer going to sleep by waiting a bit\n+ # longer before giving up.\n+ second_attempt = True\n+ if self._heartbeat_stop.wait(_HEARTBEAT_INTERVAL_SLACK / 2):\n+ return\n+ else:\n+ second_attempt = False\n+ if self._heartbeat_stop.wait(delay):\n+ return\n+\n+ def remove_permuter(self, handle: int) -> None:\n+ assert not self._token.cancelled\n+ self._main_queue.put(Disconnect(handle=handle))\n+\n+ def stop(self) -> None:\n+ assert not self._token.cancelled\n+ self._token.cancelled = True\n+ self._main_queue.put(Shutdown())\n+ self._heartbeat_stop.set()\n+ self._net_thread.stop()\n+ self._evaluator_port.shutdown()\n+ self._main_thread.join()\n+ self._heartbeat_thread.join()\n+\n+\n+class DockerPort(Port):\n+ \"\"\"Port for communicating with Docker. Communication is encrypted for a few\n+ not-very-good reasons:\n+ - it allows code reuse\n+ - it adds error-checking\n+ - it was fun to implement\"\"\"\n+\n+ _sock: BinaryIO\n+ _container: docker.models.containers.Container\n+ _stdout_buffer: bytes\n+ _closed: bool\n+\n+ def __init__(\n+ self, container: docker.models.containers.Container, secret: bytes\n+ ) -> None:\n+ self._container = container\n+ self._stdout_buffer = b\"\"\n+ self._closed = False\n+\n+ # Set up a socket for reading from stdout/stderr and writing to\n+ # stdin for the container. The docker package does not seem to\n+ # expose an API for writing the stdin, but we can do so directly\n+ # by attaching a socket and poking at internal state. (See\n+ # https://github.com/docker/docker-py/issues/983.) For stdout/\n+ # stderr, we use the format described at\n+ # https://docs.docker.com/engine/api/v1.24/#attach-to-a-container.\n+ #\n+ # Hopefully this will keep working for at least a while...\n+ try:\n+ self._sock = container.attach_socket(\n+ params={\"stdout\": True, \"stdin\": True, \"stderr\": True, \"stream\": True}\n+ )\n+ self._sock._writing = True # type: ignore\n+ except:\n+ try:\n+ container.remove(force=True)\n+ except Exception:\n+ pass\n+ raise\n+\n+ super().__init__(SecretBox(secret), \"docker\", is_client=True)\n+\n+ def shutdown(self) -> None:\n+ if self._closed:\n+ return\n+ self._closed = True\n+ try:\n+ self._sock.close()\n+ self._container.remove(force=True)\n+ except Exception as e:\n+ print(\"Failed to shut down Docker\")\n+ traceback.print_exc()\n+\n+ def _read_one(self) -> None:\n+ header = file_read_fixed(self._sock, 8)\n+ stream, length = struct.unpack(\">BxxxI\", header)\n+ if stream not in [1, 2]:\n+ raise Exception(\"Unexpected output from Docker: \" + repr(header))\n+ data = file_read_fixed(self._sock, length)\n+ if stream == 1:\n+ self._stdout_buffer += data\n+ else:\n+ sys.stderr.buffer.write(b\"Docker stderr: \" + data)\n+ sys.stderr.buffer.flush()\n+\n+ def _receive(self, length: int) -> bytes:\n+ while len(self._stdout_buffer) < length:\n+ self._read_one()\n+ ret = self._stdout_buffer[:length]\n+ self._stdout_buffer = self._stdout_buffer[length:]\n+ return ret\n+\n+ def _send(self, data: bytes) -> None:\n+ while data:\n+ written = self._sock.write(data)\n+ data = data[written:]\n+ self._sock.flush()\n+\n+\n+def _start_evaluator(docker_image: str, options: ServerOptions) -> DockerPort:\n+ \"\"\"Spawn a docker container and set it up to evaluate permutations in,\n+ returning a handle that we can use to communicate with it.\n+\n+ We do this for a few reasons:\n+ - enforcing a known Linux environment, all while the outside server can run\n+ on e.g. Windows and display a systray\n+ - enforcing resource limits\n+ - sandboxing\n+\n+ Docker does have the downside of requiring root access, so ideally we would\n+ also have a Docker-less mode, where we leave the sandboxing to some other\n+ tool, e.g. https://github.com/ioi/isolate/.\"\"\"\n+ print(\"Starting docker...\")\n+ command = [\"python3\", \"-m\", \"src.net.evaluator\"]\n+ secret = nacl.utils.random(32)\n+ box = SecretBox(secret)\n+ enc_secret = base64.b64encode(secret).decode(\"utf-8\")\n+ src_path = pathlib.Path(__file__).parent.parent.absolute()\n+\n+ try:\n+ client = docker.from_env()\n+ client.info()\n+ except Exception:\n+ print(\n+ \"Failed to start docker. Make sure you have docker installed, \"\n+ \"and either run the permuter with sudo or add yourself to the \"\n+ '\"docker\" UNIX group.'\n+ )\n+ sys.exit(1)\n+\n+ try:\n+ container = client.containers.run(\n+ docker_image,\n+ command,\n+ detach=True,\n+ remove=True,\n+ stdin_open=True,\n+ stdout=True,\n+ environment={\"SECRET\": enc_secret},\n+ volumes={src_path: {\"bind\": \"/src\", \"mode\": \"ro\"}},\n+ tmpfs={\"/tmp\": \"size=1G,exec\"},\n+ nano_cpus=int(options.num_cores * 1e9),\n+ mem_limit=int(options.max_memory_gb * 2 ** 30),\n+ read_only=True,\n+ network_disabled=True,\n+ )\n+ except Exception as e:\n+ print(f\"Failed to start docker container: {e}\")\n+ sys.exit(1)\n+\n+ port = DockerPort(container, secret)\n+\n+ try:\n+ # Sanity-check that the Docker container started successfully and can\n+ # be communicated with.\n+ magic = b\"\\0\" * 1000\n+ port.send(magic)\n+ r = port.receive()\n+ if r != magic:\n+ raise Exception(\"Failed initial sanity check.\")\n+\n+ port.send_json({\"num_cores\": options.num_cores})\n+ except:\n+ port.shutdown()\n+ raise\n+\n+ print(\"Started.\")\n+ return port\n+\n+\n+class Server:\n+ \"\"\"This class represents a server that may or may not be connected to the\n+ controller and the evaluator.\"\"\"\n+\n+ _server: Optional[ServerInner]\n+ _options: ServerOptions\n+ _io_queue: \"queue.Queue[IoActivity]\"\n+\n+ def __init__(\n+ self, options: ServerOptions, io_queue: \"queue.Queue[IoActivity]\"\n+ ) -> None:\n+ self._server = None\n+ self._options = options\n+ self._io_queue = io_queue\n+\n+ def start(self) -> None:\n+ assert self._server is None\n+\n+ net_port = connect()\n+ net_port.send_json(\n+ {\n+ \"method\": \"connect_server\",\n+ \"min_priority\": self._options.min_priority,\n+ \"num_cores\": self._options.num_cores,\n+ }\n+ )\n+ obj = net_port.receive_json()\n+ docker_image = json_prop(obj, \"docker_image\", str)\n+ heartbeat_interval = json_prop(obj, \"heartbeat_interval\", float)\n+\n+ evaluator_port = _start_evaluator(docker_image, self._options)\n+\n+ try:\n+ self._server = ServerInner(\n+ net_port, evaluator_port, self._io_queue, heartbeat_interval\n+ )\n+ except:\n+ evaluator_port.shutdown()\n+ raise\n+\n+ def stop(self) -> None:\n+ if self._server is None:\n+ return\n+ self._server.stop()\n+ self._server = None\n+\n+ def remove_permuter(self, handle: PermuterHandle) -> None:\n+ if self._server is not None and not handle[1].cancelled:\n+ self._server.remove_permuter(handle[0])\ndiff --git a/src/permuter.py b/src/permuter.py\n--- a/src/permuter.py\n+++ b/src/permuter.py\n@@ -33,10 +33,35 @@ class EvalError:\n EvalResult = Union[CandidateResult, EvalError]\n \n \n+@dataclass\n+class Finished:\n+ reason: Optional[str] = None\n+\n+\n+@dataclass\n+class Message:\n+ text: str\n+\n+\n+class NeedMoreWork:\n+ pass\n+\n+\n class _CompileFailure(Exception):\n pass\n \n \n+@dataclass\n+class WorkDone:\n+ perm_index: int\n+ result: EvalResult\n+\n+\n+Task = Union[Finished, Tuple[int, int]]\n+FeedbackItem = Union[Finished, Message, NeedMoreWork, WorkDone]\n+Feedback = Tuple[FeedbackItem, int, Optional[str]]\n+\n+\n class Permuter:\n \"\"\"\n Represents a single source from which permutation candidates can be generated,\n@@ -55,13 +80,17 @@ def __init__(\n force_seed: Optional[int],\n force_rng_seed: Optional[int],\n keep_prob: float,\n+ need_profiler: bool,\n need_all_sources: bool,\n show_errors: bool,\n+ best_only: bool,\n+ better_only: bool,\n ) -> None:\n self.dir = dir\n self.compiler = compiler\n self.scorer = scorer\n self.source_file = source_file\n+ self.source = source\n \n if fn_name is None:\n # Semi-legacy codepath; all functions imported through import.py have a\n@@ -88,8 +117,11 @@ def __init__(\n self._cur_seed: Optional[Tuple[int, int]] = None\n \n self.keep_prob = keep_prob\n+ self.need_profiler = need_profiler\n self._need_all_sources = need_all_sources\n self._show_errors = show_errors\n+ self._best_only = best_only\n+ self._better_only = better_only\n \n (\n self.base_score,\n@@ -110,16 +142,11 @@ def _create_and_score_base(self) -> Tuple[int, str, str]:\n if not o_file:\n raise CandidateConstructionFailure(f\"Unable to compile {self.source_file}\")\n base_result = base_cand.score(self.scorer, o_file)\n+ assert base_result.hash is not None\n return base_result.score, base_result.hash, base_cand.get_source()\n \n def _need_to_send_source(self, result: CandidateResult) -> bool:\n- if self._need_all_sources:\n- return True\n- if result.score < self.base_score:\n- return True\n- if result.score == self.base_score:\n- return result.hash != self.base_hash\n- return False\n+ return self._need_all_sources or self.should_output(result)\n \n def _eval_candidate(self, seed: int) -> CandidateResult:\n t0 = time.time()\n@@ -168,19 +195,45 @@ def _eval_candidate(self, seed: int) -> CandidateResult:\n \n t4 = time.time()\n \n- profiler: Profiler = result.profiler\n- profiler.add_stat(Profiler.StatType.perm, t1 - t0)\n- profiler.add_stat(Profiler.StatType.stringify, t2 - t1)\n- profiler.add_stat(Profiler.StatType.compile, t3 - t2)\n- profiler.add_stat(Profiler.StatType.score, t4 - t3)\n+ if self.need_profiler:\n+ profiler = Profiler()\n+ profiler.add_stat(Profiler.StatType.perm, t1 - t0)\n+ profiler.add_stat(Profiler.StatType.stringify, t2 - t1)\n+ profiler.add_stat(Profiler.StatType.compile, t3 - t2)\n+ profiler.add_stat(Profiler.StatType.score, t4 - t3)\n+ result.profiler = profiler\n \n self._last_score = result.score\n \n if not self._need_to_send_source(result):\n result.source = None\n+ result.hash = None\n \n return result\n \n+ def should_output(self, result: CandidateResult) -> bool:\n+ \"\"\"Check whether a result should be outputted. This must be more liberal\n+ in child processes than in parent ones, or else sources will be missing.\"\"\"\n+ return (\n+ result.score <= self.base_score\n+ and result.hash is not None\n+ and result.source is not None\n+ and not (result.score > self.best_score and self._best_only)\n+ and (\n+ result.score < self.base_score\n+ or (result.score == self.base_score and not self._better_only)\n+ )\n+ and result.hash not in self.hashes\n+ )\n+\n+ def record_result(self, result: CandidateResult) -> None:\n+ \"\"\"Record a new result, updating the best score and adding the hash to\n+ the set of hashes we have already seen. No hash is recorded for score\n+ 0, since we are interested in all score 0's, not just the first.\"\"\"\n+ self.best_score = min(self.best_score, result.score)\n+ if result.score != 0 and result.hash is not None:\n+ self.hashes.add(result.hash)\n+\n def seed_iterator(self) -> Iterator[int]:\n \"\"\"Create an iterator over all seeds for this permuter. The iterator\n will be infinite if we are randomizing.\"\"\"\ndiff --git a/src/printer.py b/src/printer.py\n--- a/src/printer.py\n+++ b/src/printer.py\n@@ -25,6 +25,7 @@ def print(\n self,\n message: str,\n permuter: Optional[Permuter],\n+ who: Optional[str],\n *,\n color: str = \"\",\n keep_progress: bool = False,\n@@ -37,6 +38,8 @@ def print(\n print(\"\\r\" + \" \" * pad + \"\\r\", end=\"\")\n if permuter is not None:\n message = f\"[{permuter.unique_name}] {message}\"\n+ if who is not None:\n+ message = f\"[{who}] {message}\"\n if color:\n message = f\"{color}{message}\\u001b[0m\"\n print(message)\n", "test_patch": "", "problem_statement": "", "hints_text": "", "created_at": "2021-04-12T21:43:23Z"}
|