mirror of
https://github.com/privatevoid-net/nix-super.git
synced 2024-11-14 18:26:16 +02:00
6644b6099b
This exploits the hermetic nature of flake evaluation to speed up
repeated evaluations of a flake output attribute.
For example (doing 'nix build' on an already present package):
$ time nix build nixpkgs:firefox
real 0m1.497s
user 0m1.160s
sys 0m0.139s
$ time nix build nixpkgs:firefox
real 0m0.052s
user 0m0.038s
sys 0m0.007s
The cache is ~/.cache/nix/eval-cache-v1.sqlite, which has entries like
INSERT INTO Attributes VALUES(
X'92a907d4efe933af2a46959b082cdff176aa5bfeb47a98fabd234809a67ab195',
'packages.firefox',
1,
'/nix/store/pbalzf8x19hckr8cwdv62rd6g0lqgc38-firefox-67.0.drv /nix/store/g6q0gx0v6xvdnizp8lrcw7c4gdkzana0-firefox-67.0 out');
where the hash 92a9... is a fingerprint over the flake store path and
the contents of the lockfile. Because flakes are evaluated in pure
mode, this uniquely identifies the evaluation result.
117 lines
2.9 KiB
C++
117 lines
2.9 KiB
C++
#pragma once
|
|
|
|
#include "types.hh"
|
|
#include "flakeref.hh"
|
|
#include "lockfile.hh"
|
|
|
|
namespace nix {
|
|
|
|
struct Value;
|
|
class EvalState;
|
|
|
|
namespace flake {
|
|
|
|
static const size_t FLAG_REGISTRY = 0;
|
|
static const size_t USER_REGISTRY = 1;
|
|
static const size_t GLOBAL_REGISTRY = 2;
|
|
|
|
struct FlakeRegistry
|
|
{
|
|
std::map<FlakeRef, FlakeRef> entries;
|
|
};
|
|
|
|
typedef std::vector<std::shared_ptr<FlakeRegistry>> Registries;
|
|
|
|
std::shared_ptr<FlakeRegistry> readRegistry(const Path &);
|
|
|
|
void writeRegistry(const FlakeRegistry &, const Path &);
|
|
|
|
Path getUserRegistryPath();
|
|
|
|
enum HandleLockFile : unsigned int
|
|
{ AllPure // Everything is handled 100% purely
|
|
, TopRefUsesRegistries // The top FlakeRef uses the registries, apart from that, everything happens 100% purely
|
|
, UpdateLockFile // Update the existing lockfile and write it to file
|
|
, UseUpdatedLockFile // `UpdateLockFile` without writing to file
|
|
, RecreateLockFile // Recreate the lockfile from scratch and write it to file
|
|
, UseNewLockFile // `RecreateLockFile` without writing to file
|
|
};
|
|
|
|
struct SourceInfo
|
|
{
|
|
// Immutable flakeref that this source tree was obtained from.
|
|
FlakeRef resolvedRef;
|
|
|
|
Path storePath;
|
|
|
|
// Number of ancestors of the most recent commit.
|
|
std::optional<uint64_t> revCount;
|
|
|
|
// NAR hash of the store path.
|
|
Hash narHash;
|
|
|
|
// A stable timestamp of this source tree. For Git and GitHub
|
|
// flakes, the commit date (not author date!) of the most recent
|
|
// commit.
|
|
std::optional<time_t> lastModified;
|
|
|
|
SourceInfo(const FlakeRef & resolvRef) : resolvedRef(resolvRef) {};
|
|
};
|
|
|
|
struct Flake
|
|
{
|
|
FlakeId id;
|
|
FlakeRef originalRef;
|
|
std::string description;
|
|
SourceInfo sourceInfo;
|
|
std::vector<FlakeRef> inputs;
|
|
std::map<FlakeAlias, FlakeRef> nonFlakeInputs;
|
|
Value * vOutputs; // FIXME: gc
|
|
unsigned int epoch;
|
|
|
|
Flake(const FlakeRef & origRef, const SourceInfo & sourceInfo)
|
|
: originalRef(origRef), sourceInfo(sourceInfo) {};
|
|
};
|
|
|
|
struct NonFlake
|
|
{
|
|
FlakeRef originalRef;
|
|
SourceInfo sourceInfo;
|
|
NonFlake(const FlakeRef & origRef, const SourceInfo & sourceInfo)
|
|
: originalRef(origRef), sourceInfo(sourceInfo) {};
|
|
};
|
|
|
|
Flake getFlake(EvalState &, const FlakeRef &, bool impureIsAllowed);
|
|
|
|
/* Fingerprint of a locked flake; used as a cache key. */
|
|
typedef Hash Fingerprint;
|
|
|
|
struct ResolvedFlake
|
|
{
|
|
Flake flake;
|
|
LockFile lockFile;
|
|
|
|
ResolvedFlake(Flake && flake, LockFile && lockFile)
|
|
: flake(flake), lockFile(lockFile) {}
|
|
|
|
Fingerprint getFingerprint() const;
|
|
};
|
|
|
|
ResolvedFlake resolveFlake(EvalState &, const FlakeRef &, HandleLockFile);
|
|
|
|
void callFlake(EvalState & state,
|
|
const Flake & flake,
|
|
const FlakeInputs & inputs,
|
|
Value & v);
|
|
|
|
void callFlake(EvalState & state,
|
|
const ResolvedFlake & resFlake,
|
|
Value & v);
|
|
|
|
void updateLockFile(EvalState &, const FlakeRef & flakeRef, bool recreateLockFile);
|
|
|
|
void gitCloneFlake(FlakeRef flakeRef, EvalState &, Registries, const Path & destDir);
|
|
|
|
}
|
|
|
|
}
|