nix eval-hydra-jobs: Support parallel evaluation

Example usage:

  $ nix eval-hydra-jobs -f '<nixpkgs/pkgs/top-level/release.nix>' '' \
      --max-memory-size 2048 --workers 8

src/nix/eval-hydra-jobs.cc

@@ -5,6 +5,10 @@
 #include "common-args.hh"
 #include "json.hh"
 #include "get-drvs.hh"
+#include "attr-path.hh"
+
+#include <nlohmann/json.hpp>
+#include <sys/resource.h>
 
 using namespace nix;
 
@@ -36,6 +40,8 @@ static std::string queryMetaStrings(EvalState & state, DrvInfo & drv, const stri
 struct CmdEvalHydraJobs : MixJSON, MixDryRun, InstallableCommand
 {
     std::optional<Path> gcRootsDir;
+    size_t nrWorkers = 1;
+    size_t maxMemorySize = 4ULL * 1024;
 
     CmdEvalHydraJobs()
     {
@@ -44,6 +50,10 @@ struct CmdEvalHydraJobs : MixJSON, MixDryRun, InstallableCommand
             .description("garbage collector roots directory")
             .labels({"path"})
             .dest(&gcRootsDir);
+
+        mkIntFlag(0, "workers", "number of concurrent worker processes", &nrWorkers);
+
+        mkIntFlag(0, "max-memory-size", "maximum memory usage per worker process (in MiB)", &maxMemorySize);
     }
 
     std::string description() override
@@ -61,11 +71,11 @@ struct CmdEvalHydraJobs : MixJSON, MixDryRun, InstallableCommand
         };
     }
 
-    void run(ref<Store> store) override
+    void worker(AutoCloseFD & to, AutoCloseFD & from)
     {
         auto state = getEvalState();
 
-        if (!gcRootsDir) warn("'--gc-roots-dir' not specified");
+        // FIXME: should re-open state->store.
 
         if (dryRun) settings.readOnlyMode = true;
 
@@ -73,28 +83,33 @@ struct CmdEvalHydraJobs : MixJSON, MixDryRun, InstallableCommand
            to the environment. */
         evalSettings.restrictEval = true;
 
-        auto v = installable->toValue(*state).first;
-
-        auto jsonObj = json ? std::make_unique<JSONObject>(std::cout, true) : nullptr;
-
-        std::function<void(Value & vIn, const string & attrPath)> findJobs;
-
         auto autoArgs = getAutoArgs(*state);
 
-        findJobs = [&](Value & vIn, const string & attrPath)
+        auto vTop = installable->toValue(*state).first;
-        {
+
+        auto vRoot = state->allocValue();
+        state->autoCallFunction(*autoArgs, *vTop, *vRoot);
+
+        while (true) {
+            /* Wait for the master to send us a job name. */
+            writeLine(to.get(), "next");
+
+            auto s = readLine(from.get());
+            if (s == "exit") break;
+            if (!hasPrefix(s, "do ")) abort();
+            std::string attrPath(s, 3);
+
+            debug("worker process %d at '%s'", getpid(), attrPath);
+
+            /* Evaluate it and send info back to the master. */
+            nlohmann::json reply;
+
             try {
-                Activity act(*logger, lvlInfo, actUnknown, fmt("evaluating '%s'", attrPath));
+                auto v = findAlongAttrPath(*state, attrPath, *autoArgs, *vRoot).first;
 
-                checkInterrupt();
+                state->forceValue(*v);
 
-                auto v = state->allocValue();
+                if (auto drv = getDerivation(*state, *v, false)) {
-                state->autoCallFunction(*autoArgs, vIn, *v);
-
-                if (v->type == tAttrs) {
-                    auto drv = getDerivation(*state, *v, false);
-
-                    if (drv) {
 
                     DrvInfo::Outputs outputs = drv->queryOutputs();
 
@@ -103,19 +118,19 @@ struct CmdEvalHydraJobs : MixJSON, MixDryRun, InstallableCommand
 
                     auto drvPath = drv->queryDrvPath();
 
-                        if (jsonObj) {
+                    nlohmann::json job;
-                            auto res = jsonObj->object(attrPath);
+
-                            res.attr("nixName", drv->queryName());
+                    job["nixName"] = drv->queryName();
-                            res.attr("system", drv->querySystem());
+                    job["system"] =drv->querySystem();
-                            res.attr("drvPath", drvPath);
+                    job["drvPath"] = drvPath;
-                            res.attr("description", drv->queryMetaString("description"));
+                    job["description"] = drv->queryMetaString("description");
-                            res.attr("license", queryMetaStrings(*state, *drv, "license", "shortName"));
+                    job["license"] = queryMetaStrings(*state, *drv, "license", "shortName");
-                            res.attr("homepage", drv->queryMetaString("homepage"));
+                    job["homepage"] = drv->queryMetaString("homepage");
-                            res.attr("maintainers", queryMetaStrings(*state, *drv, "maintainers", "email"));
+                    job["maintainers"] = queryMetaStrings(*state, *drv, "maintainers", "email");
-                            res.attr("schedulingPriority", drv->queryMetaInt("schedulingPriority", 100));
+                    job["schedulingPriority"] = drv->queryMetaInt("schedulingPriority", 100);
-                            res.attr("timeout", drv->queryMetaInt("timeout", 36000));
+                    job["timeout"] = drv->queryMetaInt("timeout", 36000);
-                            res.attr("maxSilent", drv->queryMetaInt("maxSilent", 7200));
+                    job["maxSilent"] = drv->queryMetaInt("maxSilent", 7200);
-                            res.attr("isChannel", drv->queryMetaBool("isHydraChannel", false));
+                    job["isChannel"] = drv->queryMetaBool("isHydraChannel", false);
 
                     /* If this is an aggregate, then get its constituents. */
                     auto a = v->attrs->get(state->symbols.create("_hydraAggregate"));
@@ -131,7 +146,7 @@ struct CmdEvalHydraJobs : MixJSON, MixDryRun, InstallableCommand
                                 size_t index = i.find("!", 1);
                                 drvs.insert(string(i, index + 1));
                             }
-                                res.attr("constituents", concatStringsSep(" ", drvs));
+                        job["constituents"] = concatStringsSep(" ", drvs);
                     }
 
                     /* Register the derivation as a GC root.  !!! This
@@ -144,47 +159,175 @@ struct CmdEvalHydraJobs : MixJSON, MixDryRun, InstallableCommand
                             localStore->addPermRoot(localStore->parseStorePath(drvPath), root, false);
                     }
 
-                            auto res2 = res.object("outputs");
+                    nlohmann::json out;
                     for (auto & j : outputs)
-                                res2.attr(j.first, j.second);
+                        out[j.first] = j.second;
-                        } else
+                    job["outputs"] = std::move(out);
-                            std::cout << fmt("%d: %d\n", attrPath, drvPath);
 
+                    reply["job"] = std::move(job);
                 }
 
-                    else {
+                else if (v->type == tAttrs) {
-                        if (!state->isDerivation(*v)) {
+                    auto attrs = nlohmann::json::array();
+                    StringSet ss;
                     for (auto & i : v->attrs->lexicographicOrder()) {
                         std::string name(i->name);
-
+                        if (name.find('.') != std::string::npos || name.find(' ') != std::string::npos) {
-                                /* Skip jobs with dots in the name. */
-                                if (name.find('.') != std::string::npos) {
                             printError("skipping job with illegal name '%s'", name);
                             continue;
                         }
-
+                        attrs.push_back(name);
-                                findJobs(*i->value, (attrPath.empty() ? "" : attrPath + ".") + name);
                     }
+                    reply["attrs"] = std::move(attrs);
                 }
-                    }
-                }
-
-                else if (v->type == tNull) {
-                    // allow null values, meaning 'do nothing'
-                }
-
-                else
-                    throw TypeError("unsupported value: %s", *v);
 
             } catch (EvalError & e) {
-                if (jsonObj)
+                reply["error"] = filterANSIEscapes(e.msg(), true);
-                    jsonObj->object(attrPath).attr("error", filterANSIEscapes(e.msg(), true));
+            }
+
+            writeLine(to.get(), reply.dump());
+
+            /* If our RSS exceeds the maximum, exit. The master will
+               start a new process. */
+            struct rusage r;
+            getrusage(RUSAGE_SELF, &r);
+            if ((size_t) r.ru_maxrss > maxMemorySize * 1024) break;
+        }
+
+        writeLine(to.get(), "restart");
+    }
+
+    void run(ref<Store> store) override
+    {
+        if (!gcRootsDir) warn("'--gc-roots-dir' not specified");
+
+        struct State
+        {
+            std::set<std::string> todo{""};
+            std::set<std::string> active;
+            nlohmann::json result;
+        };
+
+        std::condition_variable wakeup;
+
+        Sync<State> state_;
+
+        /* Start a handler thread per worker process. */
+        auto handler = [this, &state_, &wakeup]()
+        {
+            try {
+                pid_t pid = -1;
+                AutoCloseFD from, to;
+
+                while (true) {
+
+                    /* Start a new worker process if necessary. */
+                    if (pid == -1) {
+                        Pipe toPipe, fromPipe;
+                        toPipe.create();
+                        fromPipe.create();
+                        pid = startProcess(
+                            [this,
+                             to{std::make_shared<AutoCloseFD>(std::move(fromPipe.writeSide))},
+                             from{std::make_shared<AutoCloseFD>(std::move(toPipe.readSide))}
+                            ]()
+                            {
+                                try {
+                                    worker(*to, *from);
+                                } catch (Error & e) {
+                                    printError("unexpected worker error: %s", e.msg());
+                                    _exit(1);
+                                }
+                            },
+                            ProcessOptions { .allowVfork = false });
+                        from = std::move(fromPipe.readSide);
+                        to = std::move(toPipe.writeSide);
+                        debug("created worker process %d", pid);
+                    }
+
+                    /* Check whether the existing worker process is still there. */
+                    auto s = readLine(from.get());
+                    if (s == "restart") {
+                        pid = -1;
+                        continue;
+                    } else if (s != "next")
+                        throw Error("unexpected worker request: %s", s);
+
+                    /* Wait for a job name to become available. */
+                    std::string attrPath;
+
+                    while (true) {
+                        checkInterrupt();
+                        auto state(state_.lock());
+                        if (state->todo.empty() && state->active.empty()) {
+                            writeLine(to.get(), "exit");
+                            return;
+                        }
+                        if (!state->todo.empty()) {
+                            attrPath = *state->todo.begin();
+                            state->todo.erase(state->todo.begin());
+                            state->active.insert(attrPath);
+                            break;
+                        } else
+                            state.wait(wakeup);
+                    }
+
+                    /* Tell the worker to evaluate it. */
+                    writeLine(to.get(), "do " + attrPath);
+
+                    /* Wait for the response. */
+                    auto response = nlohmann::json::parse(readLine(from.get()));
+
+                    /* Handle the response. */
+                    StringSet newAttrs;
+
+                    if (response.find("job") != response.end()) {
+                        auto state(state_.lock());
+                        if (json)
+                            state->result[attrPath] = response["job"];
                         else
-                    printError("in job '%s': %s", attrPath, e.what());
+                            std::cout << fmt("%d: %d\n", attrPath, (std::string) response["job"]["drvPath"]);
+                    }
+
+                    if (response.find("attrs") != response.end()) {
+                        for (auto & i : response["attrs"]) {
+                            auto s = (attrPath.empty() ? "" : attrPath + ".") + (std::string) i;
+                            newAttrs.insert(s);
+                        }
+                    }
+
+                    if (response.find("error") != response.end()) {
+                        auto state(state_.lock());
+                        if (json)
+                            state->result[attrPath]["error"] = response["error"];
+                        else
+                            printError("error in job '%s': %s",
+                                attrPath, (std::string) response["error"]);
+                    }
+
+                    /* Add newly discovered job names to the queue. */
+                    {
+                        auto state(state_.lock());
+                        state->active.erase(attrPath);
+                        for (auto & s : newAttrs)
+                            state->todo.insert(s);
+                        wakeup.notify_all();
+                    }
+                }
+            } catch (Error & e) {
+                printError("unexpected handler thread error: %s", e.msg());
+                abort();
             }
         };
 
-        findJobs(*v, "");
+        std::vector<std::thread> threads;
+        for (size_t i = 0; i < nrWorkers; i++)
+            threads.emplace_back(std::thread(handler));
+
+        for (auto & thread : threads)
+            thread.join();
+
+        if (json) std::cout << state_.lock()->result.dump(2) << "\n";
     }
 };