store Symbols in a table as well, like positions

this slightly increases the amount of memory used for any given symbol, but this
increase is more than made up for if the symbol is referenced more than once in
the EvalState that holds it. on average every symbol should be referenced at
least twice (once to introduce a binding, once to use it), so we expect no
increase in memory on average.

symbol tables are limited to 2³² entries like position tables, and similar
arguments apply to why overflow is not likely: 2³² symbols would require as many
string instances (at 24 bytes each) and map entries (at 24 bytes or more each,
assuming that the map holds on average at most one item per bucket as the docs
say). a full symbol table would require at least 192GB of memory just for
symbols, which is well out of reach. (an ofborg eval of nixpks today creates
less than a million symbols!)

1 files changed, 9 insertions, 19 deletions

diff --git a/src/libexpr/eval-cache.cc b/src/libexpr/eval-cache.cc
index 7d3fd01a4..0d2160efd 100644
--- a/src/libexpr/eval-cache.cc
+++ b/src/libexpr/eval-cache.cc
@@ -253,7 +253,7 @@ struct AttrDb
                 std::vector<Symbol> attrs;
                 auto queryAttributes(state->queryAttributes.use()(rowId));
                 while (queryAttributes.next())
-                    attrs.push_back(symbols.create(queryAttributes.getStr(0)));
+                    attrs.emplace_back(queryAttributes.getStr(0));
                 return {{rowId, attrs}};
             }
             case AttrType::String: {
@@ -325,7 +325,7 @@ AttrCursor::AttrCursor(
 AttrKey AttrCursor::getKey()
 {
     if (!parent)
-        return {0, root->state.sEpsilon};
+        return {0, {""}};
     if (!parent->first->cachedValue) {
         parent->first->cachedValue = root->db->getAttr(
             parent->first->getKey(), root->state.symbols);
@@ -340,7 +340,7 @@ Value & AttrCursor::getValue()
         if (parent) {
             auto & vParent = parent->first->getValue();
             root->state.forceAttrs(vParent, noPos);
-            auto attr = vParent.attrs->get(parent->second);
+            auto attr = vParent.attrs->get(root->state.symbols.create(parent->second));
             if (!attr)
                 throw Error("attribute '%s' is unexpectedly missing", getAttrPathStr());
             _value = allocRootValue(attr->value);
@@ -419,7 +419,7 @@ Suggestions AttrCursor::getSuggestionsForAttr(Symbol name)
     return Suggestions::bestMatches(strAttrNames, name);
 }
 
-std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(Symbol name, bool forceErrors)
+std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(std::string_view name, bool forceErrors)
 {
     if (root->db) {
         if (!cachedValue)
@@ -461,10 +461,10 @@ std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(Symbol name, bool forceErro
 
     for (auto & attr : *v.attrs) {
         if (root->db)
-            root->db->setPlaceholder({cachedValue->first, attr.name});
+            root->db->setPlaceholder({cachedValue->first, root->state.symbols[attr.name]});
     }
 
-    auto attr = v.attrs->get(name);
+    auto attr = v.attrs->get(root->state.symbols.create(name));
 
     if (!attr) {
         if (root->db) {
@@ -486,12 +486,7 @@ std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(Symbol name, bool forceErro
         root, std::make_pair(shared_from_this(), name), attr->value, std::move(cachedValue2));
 }
 
-std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(std::string_view name)
-{
-    return maybeGetAttr(root->state.symbols.create(name));
-}
-
-ref<AttrCursor> AttrCursor::getAttr(Symbol name, bool forceErrors)
+ref<AttrCursor> AttrCursor::getAttr(std::string_view name, bool forceErrors)
 {
     auto p = maybeGetAttr(name, forceErrors);
     if (!p)
@@ -499,11 +494,6 @@ ref<AttrCursor> AttrCursor::getAttr(Symbol name, bool forceErrors)
     return ref(p);
 }
 
-ref<AttrCursor> AttrCursor::getAttr(std::string_view name)
-{
-    return getAttr(root->state.symbols.create(name));
-}
-
 OrSuggestions<ref<AttrCursor>> AttrCursor::findAlongAttrPath(const std::vector<Symbol> & attrPath, bool force)
 {
     auto res = shared_from_this();
@@ -616,7 +606,7 @@ std::vector<Symbol> AttrCursor::getAttrs()
 
     std::vector<Symbol> attrs;
     for (auto & attr : *getValue().attrs)
-        attrs.push_back(attr.name);
+        attrs.push_back(root->state.symbols[attr.name]);
     std::sort(attrs.begin(), attrs.end(), [](const Symbol & a, const Symbol & b) {
         return (const std::string &) a < (const std::string &) b;
     });
@@ -635,7 +625,7 @@ bool AttrCursor::isDerivation()
 
 StorePath AttrCursor::forceDerivation()
 {
-    auto aDrvPath = getAttr(root->state.sDrvPath, true);
+    auto aDrvPath = getAttr("drvPath", true);
     auto drvPath = root->state.store->parseStorePath(aDrvPath->getString());
     if (!root->state.store->isValidPath(drvPath) && !settings.readOnlyMode) {
         /* The eval cache contains 'drvPath', but the actual path has