#pragma once
#include <atomic>
#include "sync.hh"
#include "types.hh"
namespace nix {
MakeError(NoTokens, Error);
/* This class hands out tokens. There are only ‘maxTokens’ tokens
   available. Calling get(N) will return a Token object, representing
   ownership of N tokens. If the requested number of tokens is
   unavailable, get() will sleep until another thread returns a
   token. */
class TokenServer
{
    const size_t maxTokens;
    Sync<size_t> inUse{0};
    std::condition_variable wakeup;
public:
    TokenServer(size_t maxTokens) : maxTokens(maxTokens) { }
    class Token
    {
        friend TokenServer;
        TokenServer * ts;
        size_t tokens;
        bool acquired = false;
        Token(TokenServer * ts, size_t tokens, unsigned int timeout)
            : ts(ts), tokens(tokens)
        {
            if (tokens >= ts->maxTokens)
                throw NoTokens("requesting more tokens (%d) than exist (%d)", tokens, ts->maxTokens);
            debug("acquiring %d tokens", tokens);
            auto inUse(ts->inUse.lock());
            while (*inUse + tokens > ts->maxTokens)
                if (timeout) {
                    if (!inUse.wait_for(ts->wakeup, std::chrono::seconds(timeout),
                            [&]() { return *inUse + tokens <= ts->maxTokens; }))
                        return;
                } else
                    inUse.wait(ts->wakeup);
            *inUse += tokens;
            acquired = true;
        }
    public:
        Token(Token && t) : ts(t.ts), tokens(t.tokens), acquired(t.acquired)
        {
            t.ts = 0;
            t.acquired = false;
        }
        Token(const Token & l) = delete;
        ~Token()
        {
            if (!ts || !acquired) return;
            {
                auto inUse(ts->inUse.lock());
                assert(*inUse >= t);
                *inUse -= t;
                tokens -= t;
            }
            // FIXME: inefficient. Should wake up waiters that can
            // proceed now.
            ts->wakeup.notify_all();
        }
    };
    Token get(size_t tokens = 1, unsigned int timeout = 0)
    {
        return Token(this, tokens, timeout);
    }
    size_t currentUse()
    {
        auto inUse_(inUse.lock());
        return *inUse_;
    }
};
}
    size_t capacity()
    {
        return maxTokens;
    }
            give_back(tokens);
        }
        bool operator ()() { return acquired; }
        void give_back(size_t t)
        {
            debug("returning %d tokens", t);
            if (!t) return;
            assert(acquired);
            assert(t <= tokens);

 build-result.hh counter.hh token-server.hh state.hh db.hh

 build-result.hh counter.hh state.hh db.hh

            /* Block until we have the required amount of memory
               available, which is twice the NAR size (namely the
               uncompressed and worst-case compressed NAR), plus 150
               MB for xz compression overhead. (The xz manpage claims
               ~94 MiB, but that's not was I'm seeing.) */
            auto resStart = std::chrono::steady_clock::now();
            size_t compressionCost = totalNarSize + 150 * 1024 * 1024;
            result.tokens = std::make_unique<nix::TokenServer::Token>(memoryTokens.get(totalNarSize + compressionCost));
            auto resStop = std::chrono::steady_clock::now();
            auto resMs = std::chrono::duration_cast<std::chrono::milliseconds>(resStop - resStart).count();
            if (resMs >= 1000)
                printMsg(lvlError, "warning: had to wait %d ms for %d memory tokens for %s",
                    resMs, totalNarSize, localStore->printStorePath(step->drvPath));

            /* Release the tokens pertaining to NAR
               compression. After this we only have the uncompressed
               NAR in memory. */
            result.tokens->give_back(compressionCost);

        } catch (NoTokens & e) {
            result.stepStatus = bsNarSizeLimitExceeded;

        result.tokens = 0;

    , memoryTokens(config->getIntOption("nar_buffer_size", getMemSize() / 2))

    debug("using %d bytes for the NAR buffer", memoryTokens.capacity());

        root.attr("memoryTokensInUse", memoryTokens.currentUse());

#include "token-server.hh"

    std::unique_ptr<nix::TokenServer::Token> tokens;

    /* Token server to prevent threads from allocating too many big
       strings concurrently while importing NARs from the build
       machines. When a thread imports a NAR of size N, it will first
       acquire N memory tokens, causing it to block until that many
       tokens are available. */
    nix::TokenServer memoryTokens;