Eelco Dolstra
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.
112 lines
2.8 KiB
C++
112 lines
2.8 KiB
C++
#include "eval-cache.hh"
|
|
#include "sqlite.hh"
|
|
|
|
#include <set>
|
|
|
|
namespace nix::flake {
|
|
|
|
static const char * schema = R"sql(
|
|
|
|
create table if not exists Fingerprints (
|
|
fingerprint blob primary key not null,
|
|
timestamp integer not null
|
|
);
|
|
|
|
create table if not exists Attributes (
|
|
fingerprint blob not null,
|
|
attrPath text not null,
|
|
type integer,
|
|
value text,
|
|
primary key (fingerprint, attrPath),
|
|
foreign key (fingerprint) references Fingerprints(fingerprint) on delete cascade
|
|
);
|
|
)sql";
|
|
|
|
struct EvalCache::State
|
|
{
|
|
SQLite db;
|
|
SQLiteStmt insertFingerprint;
|
|
SQLiteStmt insertAttribute;
|
|
SQLiteStmt queryAttribute;
|
|
std::set<Fingerprint> fingerprints;
|
|
};
|
|
|
|
EvalCache::EvalCache()
|
|
: _state(std::make_unique<Sync<State>>())
|
|
{
|
|
auto state(_state->lock());
|
|
|
|
Path dbPath = getCacheDir() + "/nix/eval-cache-v1.sqlite";
|
|
createDirs(dirOf(dbPath));
|
|
|
|
state->db = SQLite(dbPath);
|
|
state->db.isCache();
|
|
state->db.exec(schema);
|
|
|
|
state->insertFingerprint.create(state->db,
|
|
"insert or ignore into Fingerprints(fingerprint, timestamp) values (?, ?)");
|
|
|
|
state->insertAttribute.create(state->db,
|
|
"insert or replace into Attributes(fingerprint, attrPath, type, value) values (?, ?, ?, ?)");
|
|
|
|
state->queryAttribute.create(state->db,
|
|
"select type, value from Attributes where fingerprint = ? and attrPath = ?");
|
|
}
|
|
|
|
enum ValueType {
|
|
Derivation = 1,
|
|
};
|
|
|
|
void EvalCache::addDerivation(
|
|
const Fingerprint & fingerprint,
|
|
const std::string & attrPath,
|
|
const Derivation & drv)
|
|
{
|
|
auto state(_state->lock());
|
|
|
|
if (state->fingerprints.insert(fingerprint).second)
|
|
// FIXME: update timestamp
|
|
state->insertFingerprint.use()
|
|
(fingerprint.hash, fingerprint.hashSize)
|
|
(time(0)).exec();
|
|
|
|
state->insertAttribute.use()
|
|
(fingerprint.hash, fingerprint.hashSize)
|
|
(attrPath)
|
|
(ValueType::Derivation)
|
|
(drv.drvPath + " " + drv.outPath + " " + drv.outputName).exec();
|
|
}
|
|
|
|
std::optional<EvalCache::Derivation> EvalCache::getDerivation(
|
|
const Fingerprint & fingerprint,
|
|
const std::string & attrPath)
|
|
{
|
|
auto state(_state->lock());
|
|
|
|
auto queryAttribute(state->queryAttribute.use()
|
|
(fingerprint.hash, fingerprint.hashSize)
|
|
(attrPath));
|
|
if (!queryAttribute.next()) return {};
|
|
|
|
// FIXME: handle negative results
|
|
|
|
auto type = (ValueType) queryAttribute.getInt(0);
|
|
auto s = queryAttribute.getStr(1);
|
|
|
|
if (type != ValueType::Derivation) return {};
|
|
|
|
auto ss = tokenizeString<std::vector<std::string>>(s, " ");
|
|
|
|
debug("evaluation cache hit for '%s'", attrPath);
|
|
|
|
return Derivation { ss[0], ss[1], ss[2] };
|
|
}
|
|
|
|
EvalCache & EvalCache::singleton()
|
|
{
|
|
static std::unique_ptr<EvalCache> evalCache(new EvalCache());
|
|
return *evalCache;
|
|
}
|
|
|
|
}
|