[ORC] Rename SymbolSource to MaterializationUnit, and make the materialization

operation all-or-nothing, rather than allowing materialization on a per-symbol
basis.

This addresses a shortcoming of per-symbol materialization: If a
MaterializationUnit (/SymbolSource) wants to materialize more symbols than
requested (which is likely: most materializers will want to materialize whole
modules) then it needs a way to notify the symbol table about the extra symbols
being materialized. This process (checking what has been requested against what
is being provided and notifying the symbol table about the difference) has to
be repeated at every level of the JIT stack. Making materialization
all-or-nothing eliminates this issue, simplifying both materializer
implementations and the symbol table (VSO class) API. The cost is that
per-symbol materialization (e.g. for individual symbols in a module) now
requires multiple MaterializationUnits.

llvm-svn: 327946

1 files changed, 58 insertions, 47 deletions

diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index 5a74246b1c3..d37596ec5df 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -19,23 +19,28 @@ using namespace llvm::orc;
 
 namespace {
 
-class SimpleSource : public SymbolSource {
+class SimpleMaterializationUnit : public MaterializationUnit {
 public:
-  using MaterializeFunction = std::function<Error(VSO &, SymbolNameSet)>;
+  using GetSymbolsFunction = std::function<SymbolFlagsMap()>;
+  using MaterializeFunction = std::function<Error(VSO &)>;
   using DiscardFunction = std::function<void(VSO &, SymbolStringPtr)>;
 
-  SimpleSource(MaterializeFunction Materialize, DiscardFunction Discard)
-      : Materialize(std::move(Materialize)), Discard(std::move(Discard)) {}
+  SimpleMaterializationUnit(GetSymbolsFunction GetSymbols,
+                            MaterializeFunction Materialize,
+                            DiscardFunction Discard)
+      : GetSymbols(std::move(GetSymbols)), Materialize(std::move(Materialize)),
+        Discard(std::move(Discard)) {}
 
-  Error materialize(VSO &V, SymbolNameSet Symbols) override {
-    return Materialize(V, std::move(Symbols));
-  }
+  SymbolFlagsMap getSymbols() override { return GetSymbols(); }
+
+  Error materialize(VSO &V) override { return Materialize(V); }
 
   void discard(VSO &V, SymbolStringPtr Name) override {
     Discard(V, std::move(Name));
   }
 
 private:
+  GetSymbolsFunction GetSymbols;
   MaterializeFunction Materialize;
   DiscardFunction Discard;
 };
@@ -142,26 +147,28 @@ TEST(CoreAPIsTest, LookupFlagsTest) {
   auto Bar = SP.intern("bar");
   auto Baz = SP.intern("baz");
 
+  JITSymbolFlags FooFlags = JITSymbolFlags::Exported;
+  JITSymbolFlags BarFlags = static_cast<JITSymbolFlags::FlagNames>(
+      JITSymbolFlags::Exported | JITSymbolFlags::Weak);
+
   VSO V;
 
-  auto Source = std::make_shared<SimpleSource>(
-      [](VSO &V, SymbolNameSet Symbols) -> Error {
+  auto MU = llvm::make_unique<SimpleMaterializationUnit>(
+      [=]() {
+        return SymbolFlagsMap({{Bar, BarFlags}});
+      },
+      [](VSO &V) -> Error {
         llvm_unreachable("Symbol materialized on flags lookup");
       },
       [](VSO &V, SymbolStringPtr Name) -> Error {
         llvm_unreachable("Symbol finalized on flags lookup");
       });
 
-  JITSymbolFlags FooFlags = JITSymbolFlags::Exported;
-  JITSymbolFlags BarFlags = static_cast<JITSymbolFlags::FlagNames>(
-      JITSymbolFlags::Exported | JITSymbolFlags::Weak);
-
   SymbolMap InitialDefs;
   InitialDefs[Foo] = JITEvaluatedSymbol(0xdeadbeef, FooFlags);
   cantFail(V.define(std::move(InitialDefs)));
 
-  SymbolFlagsMap InitialLazyDefs({{Bar, BarFlags}});
-  cantFail(V.defineLazy(InitialLazyDefs, Source));
+  cantFail(V.defineLazy(std::move(MU)));
 
   SymbolNameSet Names({Foo, Bar, Baz});
 
@@ -193,12 +200,15 @@ TEST(CoreAPIsTest, AddAndMaterializeLazySymbol) {
 
   VSO V;
 
-  auto Source = std::make_shared<SimpleSource>(
-      [&](VSO &V, SymbolNameSet Symbols) {
-        EXPECT_EQ(Symbols.size(), 1U)
-            << "Expected Symbols set size to be 1 ({ Foo })";
-        EXPECT_EQ(*Symbols.begin(), Foo) << "Expected Symbols == { Foo }";
-
+  auto MU = llvm::make_unique<SimpleMaterializationUnit>(
+      [=]() {
+        return SymbolFlagsMap(
+            {{Foo, JITSymbolFlags::Exported},
+             {Bar, static_cast<JITSymbolFlags::FlagNames>(
+                       JITSymbolFlags::Exported | JITSymbolFlags::Weak)}});
+      },
+      [&](VSO &V) {
+        assert(BarDiscarded && "Bar should have been discarded by this point");
         SymbolMap SymbolsToResolve;
         SymbolsToResolve[Foo] =
             JITEvaluatedSymbol(FakeFooAddr, JITSymbolFlags::Exported);
@@ -214,11 +224,7 @@ TEST(CoreAPIsTest, AddAndMaterializeLazySymbol) {
         BarDiscarded = true;
       });
 
-  SymbolFlagsMap InitialSymbols(
-      {{Foo, JITSymbolFlags::Exported},
-       {Bar, static_cast<JITSymbolFlags::FlagNames>(JITSymbolFlags::Exported |
-                                                    JITSymbolFlags::Weak)}});
-  cantFail(V.defineLazy(InitialSymbols, Source));
+  cantFail(V.defineLazy(std::move(MU)));
 
   SymbolMap BarOverride;
   BarOverride[Bar] = JITEvaluatedSymbol(FakeBarAddr, JITSymbolFlags::Exported);
@@ -248,8 +254,8 @@ TEST(CoreAPIsTest, AddAndMaterializeLazySymbol) {
 
   auto LR = V.lookup(std::move(Q), Names);
 
-  for (auto &SWKV : LR.MaterializationWork)
-    cantFail(SWKV.first->materialize(V, std::move(SWKV.second)));
+  for (auto &SWKV : LR.MaterializationUnits)
+    cantFail(SWKV->materialize(V));
 
   EXPECT_TRUE(LR.UnresolvedSymbols.empty()) << "Could not find Foo in dylib";
   EXPECT_TRUE(FooMaterialized) << "Foo was not materialized";
@@ -276,9 +282,8 @@ TEST(CoreAPIsTest, TestLambdaSymbolResolver) {
       },
       [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
         auto LR = V.lookup(std::move(Q), Symbols);
-        assert(LR.MaterializationWork.empty() &&
-               "Test generated unexpected materialization "
-               "work?");
+        assert(LR.MaterializationUnits.empty() &&
+               "Test generated unexpected materialization work?");
         return std::move(LR.UnresolvedSymbols);
       });
 
@@ -333,8 +338,11 @@ TEST(CoreAPIsTest, TestLookupWithUnthreadedMaterialization) {
   SymbolStringPool SSP;
   auto Foo = SSP.intern("foo");
 
-  auto Source = std::make_shared<SimpleSource>(
-      [&](VSO &V, SymbolNameSet Symbols) -> Error {
+  auto MU = llvm::make_unique<SimpleMaterializationUnit>(
+      [=]() {
+        return SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}});
+      },
+      [&](VSO &V) -> Error {
         V.resolve({{Foo, FooSym}});
         V.finalize({Foo});
         return Error::success();
@@ -345,8 +353,7 @@ TEST(CoreAPIsTest, TestLookupWithUnthreadedMaterialization) {
 
   VSO V;
 
-  SymbolFlagsMap InitialSymbols({{Foo, JITSymbolFlags::Exported}});
-  cantFail(V.defineLazy(InitialSymbols, Source));
+  cantFail(V.defineLazy(std::move(MU)));
 
   ExecutionSession ES(SSP);
   auto FooLookupResult =
@@ -366,8 +373,11 @@ TEST(CoreAPIsTest, TestLookupWithThreadedMaterialization) {
   SymbolStringPool SSP;
   auto Foo = SSP.intern("foo");
 
-  auto Source = std::make_shared<SimpleSource>(
-      [&](VSO &V, SymbolNameSet Symbols) -> Error {
+  auto MU = llvm::make_unique<SimpleMaterializationUnit>(
+      [=]() {
+        return SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}});
+      },
+      [&](VSO &V) -> Error {
         V.resolve({{Foo, FooSym}});
         V.finalize({Foo});
         return Error::success();
@@ -378,19 +388,20 @@ TEST(CoreAPIsTest, TestLookupWithThreadedMaterialization) {
 
   VSO V;
 
-  SymbolFlagsMap InitialSymbols({{Foo, JITSymbolFlags::Exported}});
-  cantFail(V.defineLazy(InitialSymbols, Source));
+  cantFail(V.defineLazy(std::move(MU)));
 
   ExecutionSession ES(SSP);
 
-  auto MaterializeOnNewThread =
-    [&ES](VSO &V, std::shared_ptr<SymbolSource> Source, SymbolNameSet Names) {
-      std::thread(
-        [&ES, &V, Source, Names]() {
-          if (auto Err = Source->materialize(V, std::move(Names)))
-            ES.reportError(std::move(Err));
-        }).detach();
-    };
+  auto MaterializeOnNewThread = [&ES](VSO &V,
+                                      std::unique_ptr<MaterializationUnit> MU) {
+    // FIXME: Use move capture once we move to C++14.
+    std::shared_ptr<MaterializationUnit> SharedMU = std::move(MU);
+    std::thread([&ES, &V, SharedMU]() {
+      if (auto Err = SharedMU->materialize(V))
+        ES.reportError(std::move(Err));
+    })
+        .detach();
+  };
 
   auto FooLookupResult =
     cantFail(lookup({&V}, Foo, MaterializeOnNewThread));