}
static std::string lastAttrPath;
static bool comma = false;
static size_t maxHeapSize;
struct BailOut { };
bool lte(const std::string & s1, const std::string & s2)
{
    size_t p1 = 0, p2 = 0;
    while (true) {
        if (p1 == s1.size()) return p2 == s2.size();
        if (p2 == s2.size()) return true;
        auto d1 = s1.find('.', p1);
        auto d2 = s2.find('.', p2);
        auto c = s1.compare(p1, d1 - p1, s2, p2, d2 - p2);
        if (c < 0) return true;
        if (c > 0) return false;
        p1 = d1 == std::string::npos ? s1.size() : d1 + 1;
        p2 = d2 == std::string::npos ? s2.size() : d2 + 1;
    }

    if (lastAttrPath != "" && lte(attrPath, lastAttrPath)) return;

            if (comma) { std::cout << ","; comma = false; }

            GC_prof_stats_s gc;
            GC_get_prof_stats(&gc, sizeof(gc));
            if (gc.heapsize_full > maxHeapSize) {
                printInfo("restarting hydra-eval-jobs after job '%s' because heap size is at %d bytes", attrPath, gc.heapsize_full);
                lastAttrPath = attrPath;
                throw BailOut();
            }

        if (comma) { std::cout << ","; comma = false; }

    assert(lte("abc", "def"));
    assert(lte("abc", "def.foo"));
    assert(!lte("def", "abc"));
    assert(lte("nixpkgs.hello", "nixpkgs"));
    assert(lte("nixpkgs.hello", "nixpkgs.hellooo"));
    assert(lte("gitAndTools.git-annex.x86_64-darwin", "gitAndTools.git-annex.x86_64-linux"));
    assert(lte("gitAndTools.git-annex.x86_64-linux", "gitAndTools.git-annex-remote-b2.aarch64-linux"));

        maxHeapSize = config->getIntOption("evaluator_max_heap_size", 1UL << 30);

        /* Read the current heap size, which is the initial heap size. */
        GC_prof_stats_s gc;
        GC_get_prof_stats(&gc, sizeof(gc));
        auto initialHeapSizeInt = gc.heapsize_full;
        /* Then make sure the maximum heap size will be bigger than the initial heap size. */
        if (initialHeapSizeInt > maxHeapSize) {
            printInfo("warning: evaluator_initial_heap_size (%d) bigger than evaluator_max_heap_size (%d).", initialHeapSizeInt, maxHeapSize);
            maxHeapSize = initialHeapSizeInt * 1.1;
            printInfo("         evaluator_max_heap_size now set to %d.", maxHeapSize);
        }

        do {
            Pipe pipe;
            pipe.create();
            ProcessOptions options;
            options.allowVfork = false;
            GC_atfork_prepare();
            auto pid = startProcess([&]() {
                pipe.readSide = -1;
                GC_atfork_child();
                GC_start_mark_threads();
                if (lastAttrPath != "") debug("resuming from '%s'", lastAttrPath);
                /* FIXME: The build hook in conjunction with import-from-derivation is causing "unexpected EOF" during eval */
                settings.builders = "";
                /* Prevent access to paths outside of the Nix search path and
                   to the environment. */
                evalSettings.restrictEval = true;
                if (releaseExpr == "") throw UsageError("no expression specified");
                if (gcRootsDir == "") printMsg(lvlError, "warning: `--gc-roots-dir' not specified");
                EvalState state(myArgs.searchPath, openStore());
                Bindings & autoArgs = *myArgs.getAutoArgs(state);
                Value v;
                state.evalFile(lookupFileArg(state, releaseExpr), v);

                comma = lastAttrPath != "";

        /* FIXME: The build hook in conjunction with import-from-derivation is causing "unexpected EOF" during eval */
        settings.builders = "";

                try {
                    findJobs(state, json, autoArgs, v, "");
                    lastAttrPath = "";
                } catch (BailOut &) { }
                writeFull(pipe.writeSide.get(), lastAttrPath);

        /* Prevent access to paths outside of the Nix search path and
           to the environment. */
        evalSettings.restrictEval = true;

                exit(0);
            }, options);

        if (releaseExpr == "") throw UsageError("no expression specified");

            GC_atfork_parent();

        if (gcRootsDir == "") printMsg(lvlError, "warning: `--gc-roots-dir' not specified");

            pipe.writeSide = -1;

        EvalState state(myArgs.searchPath, openStore());

            int status;
            while (true) {
                checkInterrupt();
                if (waitpid(pid, &status, 0) == pid) break;
                if (errno != EINTR) continue;
            }

        Bindings & autoArgs = *myArgs.getAutoArgs(state);

            if (status != 0)
                throw Exit(WIFEXITED(status) ? WEXITSTATUS(status) : 99);

        Value v;
        state.evalFile(lookupFileArg(state, releaseExpr), v);

            maxHeapSize += 64 * 1024 * 1024;

        findJobs(state, json, autoArgs, v, "");

            lastAttrPath = drainFD(pipe.readSide.get());
        } while (lastAttrPath != "");