void State::builder(Step::ptr step, Machine::ptr machine, std::shared_ptr<MaintainCount> reservation)

void State::builder(MachineReservation::ptr reservation)

    auto step = reservation->step;

        retry = doBuildStep(store, step, machine);

        retry = doBuildStep(store, step, reservation->machine);

            % step->drvPath % machine->sshName % e.what());

            % step->drvPath % reservation->machine->sshName % e.what());

    ~MaintainCount() { c--; }

    ~MaintainCount() { auto prev = c--; assert(prev); }

#include <unordered_map>

        std::unordered_map<std::string, unsigned int> runnablePerType;

                runnablePerType[step->drv.platform]++;

                    assert(runnablePerType[step->drv.platform]);
                    runnablePerType[step->drv.platform]--;

                auto reservation = std::make_shared<MaintainCount>(mi.machine->state->currentJobs);
                auto builderThread = std::thread(&State::builder, this, step, mi.machine, reservation);

                auto builderThread = std::thread(&State::builder, this,
                    std::make_shared<MachineReservation>(*this, step, mi.machine));

        }
        /* Update the stats for the auto-scaler. */
        {
            auto machineTypes_(machineTypes.lock());
            for (auto & i : *machineTypes_)
                i.second.runnable = 0;
            for (auto & i : runnablePerType)
                (*machineTypes_)[i.first].runnable = i.second;

    }
}
State::MachineReservation::MachineReservation(State & state, Step::ptr step, Machine::ptr machine)
    : state(state), step(step), machine(machine)
{
    machine->state->currentJobs++;
    {
        auto machineTypes_(state.machineTypes.lock());
        (*machineTypes_)[step->drv.platform].running++;
    }
}
State::MachineReservation::~MachineReservation()
{
    auto prev = machine->state->currentJobs--;
    assert(prev);
    if (prev == 1)
        machine->state->idleSince = time(0);
    {
        auto machineTypes_(state.machineTypes.lock());
        auto & machineType = (*machineTypes_)[step->drv.platform];
        assert(machineType.running);
        machineType.running--;
        if (machineType.running == 0)
            machineType.lastActive = time(0);

                if (s->currentJobs == 0)
                    nested2.attr("idleSince", s->idleSince);

        {
            root.attr("machineTypes");
            JSONObject nested(out);
            auto machineTypes_(machineTypes.lock());
            for (auto & i : *machineTypes_) {
                nested.attr(i.first);
                JSONObject nested2(out);
                nested2.attr("runnable", i.second.runnable);
                nested2.attr("running", i.second.running);
                if (i.second.running == 0)
                    nested2.attr("lastActive", i.second.lastActive);
            }
        }

        std::atomic<time_t> idleSince{0};

    /* Statistics per machine type for the Hydra auto-scaler. */
    struct MachineType
    {
        unsigned int runnable{0}, running{0};
        time_t lastActive{0};
    };
    Sync<std::map<std::string, MachineType>> machineTypes;
    struct MachineReservation
    {
        typedef std::shared_ptr<MachineReservation> ptr;
        State & state;
        Step::ptr step;
        Machine::ptr machine;
        MachineReservation(State & state, Step::ptr step, Machine::ptr machine);
        ~MachineReservation();
    };

    void builder(Step::ptr step, Machine::ptr machine, std::shared_ptr<MaintainCount> reservation);

    void builder(MachineReservation::ptr reservation);