Multithreaded evaluator

configure.ac

@@ -362,7 +362,7 @@ AC_ARG_ENABLE(gc, AS_HELP_STRING([--enable-gc],[enable garbage collection in the
   gc=$enableval, gc=yes)
 if test "$gc" = yes; then
   PKG_CHECK_MODULES([BDW_GC], [bdw-gc])
-  CXXFLAGS="$BDW_GC_CFLAGS $CXXFLAGS"
+  CXXFLAGS="$BDW_GC_CFLAGS -DGC_THREADS $CXXFLAGS"
   AC_DEFINE(HAVE_BOEHMGC, 1, [Whether to use the Boehm garbage collector.])
 
   # See `fixupBoehmStackPointer`, for the integration between Boehm GC

src/libcmd/installables.cc

@@ -289,10 +289,10 @@ void SourceExprCommand::completeInstallable(AddCompletions & completions, std::s
 
             if (v2.type() == nAttrs) {
                 for (auto & i : *v2.attrs()) {
-                    std::string name = state->symbols[i.name];
+                    std::string_view name = state->symbols[i.name];
                     if (name.find(searchWord) == 0) {
                         if (prefix_ == "")
-                            completions.add(name);
+                            completions.add(std::string(name));
                         else
                             completions.add(prefix_ + "." + name);
                     }

src/libexpr-c/nix_api_value.cc

@@ -383,7 +383,7 @@ nix_value * nix_get_attr_byidx(
     try {
         auto & v = check_value_in(value);
         const nix::Attr & a = (*v.attrs())[i];
-        *name = ((const std::string &) (state->state.symbols[a.name])).c_str();
+        *name = state->state.symbols[a.name].c_str();
         nix_gc_incref(nullptr, a.value);
         state->state.forceValue(*a.value, nix::noPos);
         return as_nix_value_ptr(a.value);
@@ -399,7 +399,7 @@ nix_get_attr_name_byidx(nix_c_context * context, const nix_value * value, EvalSt
     try {
         auto & v = check_value_in(value);
         const nix::Attr & a = (*v.attrs())[i];
-        return ((const std::string &) (state->state.symbols[a.name])).c_str();
+        return state->state.symbols[a.name].c_str();
     }
     NIXC_CATCH_ERRS_NULL
 }

src/libexpr/attr-path.cc

@@ -76,7 +76,7 @@ std::pair<Value *, PosIdx> findAlongAttrPath(EvalState & state, const std::strin
             if (!a) {
                 std::set<std::string> attrNames;
                 for (auto & attr : *v->attrs())
-                    attrNames.insert(state.symbols[attr.name]);
+                    attrNames.insert(std::string(state.symbols[attr.name]));
 
                 auto suggestions = Suggestions::bestMatches(attrNames, attr);
                 throw AttrPathNotFound(suggestions, "attribute '%1%' in selection path '%2%' not found", attr, attrPath);

src/libexpr/eval-cache.cc

@@ -484,7 +484,7 @@ Suggestions AttrCursor::getSuggestionsForAttr(Symbol name)
     auto attrNames = getAttrs();
     std::set<std::string> strAttrNames;
     for (auto & name : attrNames)
-        strAttrNames.insert(root->state.symbols[name]);
+        strAttrNames.insert(std::string(root->state.symbols[name]));
 
     return Suggestions::bestMatches(strAttrNames, root->state.symbols[name]);
 }

src/libexpr/eval-gc.cc

@@ -157,6 +157,8 @@ static inline void initGCReal()
 
     GC_INIT();
 
+    GC_allow_register_threads();
+
     GC_set_oom_fn(oomHandler);
 
     StackAllocator::defaultAllocator = &boehmGCStackAllocator;

src/libexpr/eval-inline.hh

@@ -32,6 +32,8 @@ Value * EvalState::allocValue()
        GC_malloc_many returns a linked list of objects of the given size, where the first word
        of each object is also the pointer to the next object in the list. This also means that we
        have to explicitly clear the first word of every object we take. */
+    thread_local static std::shared_ptr<void *> valueAllocCache{std::allocate_shared<void *>(traceable_allocator<void *>(), nullptr)};
+
     if (!*valueAllocCache) {
         *valueAllocCache = GC_malloc_many(sizeof(Value));
         if (!*valueAllocCache) throw std::bad_alloc();
@@ -62,6 +64,8 @@ Env & EvalState::allocEnv(size_t size)
 #if HAVE_BOEHMGC
     if (size == 1) {
         /* see allocValue for explanations. */
+        thread_local static std::shared_ptr<void *> env1AllocCache{std::allocate_shared<void *>(traceable_allocator<void *>(), nullptr)};
+
         if (!*env1AllocCache) {
             *env1AllocCache = GC_malloc_many(sizeof(Env) + sizeof(Value *));
             if (!*env1AllocCache) throw std::bad_alloc();
@@ -84,9 +88,33 @@ Env & EvalState::allocEnv(size_t size)
 [[gnu::always_inline]]
 void EvalState::forceValue(Value & v, const PosIdx pos)
 {
+    auto type = v.internalType.load(std::memory_order_acquire);
+
+    if (isFinished(type))
+        goto done;
+
+    if (type == tThunk) {
+        try {
+            if (!v.internalType.compare_exchange_strong(type, tPending, std::memory_order_acquire, std::memory_order_acquire)) {
+                if (type == tPending || type == tAwaited) {
+                    waitOnThunk(v, type == tAwaited);
+                    goto done;
+                }
+                if (isFinished(type))
+                    goto done;
+                printError("NO LONGER THUNK %x %d", this, type);
+                abort();
+            }
+            Env * env = v.payload.thunk.env;
+            Expr * expr = v.payload.thunk.expr;
+            expr->eval(*this, *env, v);
+        } catch (...) {
+            v.mkFailed();
+            throw;
+        }
+    }
+    #if 0
     if (v.isThunk()) {
-        Env * env = v.payload.thunk.env;
-        Expr * expr = v.payload.thunk.expr;
         try {
             v.mkBlackhole();
             //checkInterrupt();
@@ -97,8 +125,31 @@ void EvalState::forceValue(Value & v, const PosIdx pos)
             throw;
         }
     }
-    else if (v.isApp())
-        callFunction(*v.payload.app.left, *v.payload.app.right, v, pos);
+    #endif
+    else if (type == tApp) {
+        try {
+            if (!v.internalType.compare_exchange_strong(type, tPending, std::memory_order_acquire, std::memory_order_acquire)) {
+                if (type == tPending || type == tAwaited) {
+                    waitOnThunk(v, type == tAwaited);
+                    goto done;
+                }
+                if (isFinished(type))
+                    goto done;
+                printError("NO LONGER APP %x %d", this, type);
+                abort();
+            }
+            callFunction(*v.payload.app.left, *v.payload.app.right, v, pos);
+        } catch (...) {
+            v.mkFailed();
+            throw;
+        }
+    }
+    else if (type == tPending || type == tAwaited)
+        type = waitOnThunk(v, type == tAwaited);
+
+ done:
+    if (type == tFailed)
+        std::rethrow_exception(v.payload.failed->ex);
 }