1 //===- MCJITObjectCacheTest.cpp - Unit tests for MCJIT object caching -----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ADT/OwningPtr.h"
11 #include "llvm/ADT/SmallVector.h"
12 #include "llvm/ADT/StringMap.h"
13 #include "llvm/ADT/StringSet.h"
14 #include "llvm/ExecutionEngine/JIT.h"
15 #include "llvm/ExecutionEngine/MCJIT.h"
16 #include "llvm/ExecutionEngine/ObjectCache.h"
17 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
18 #include "MCJITTestBase.h"
19 #include "gtest/gtest.h"
25 class TestObjectCache : public ObjectCache {
27 TestObjectCache() : DuplicateInserted(false) { }
29 virtual ~TestObjectCache() {
30 // Free any buffers we've allocated.
31 SmallVectorImpl<MemoryBuffer *>::iterator it, end;
32 end = AllocatedBuffers.end();
33 for (it = AllocatedBuffers.begin(); it != end; ++it) {
36 AllocatedBuffers.clear();
39 virtual void notifyObjectCompiled(const Module *M, const MemoryBuffer *Obj) {
40 // If we've seen this module before, note that.
41 const std::string ModuleID = M->getModuleIdentifier();
42 if (ObjMap.find(ModuleID) != ObjMap.end())
43 DuplicateInserted = true;
44 // Store a copy of the buffer in our map.
45 ObjMap[ModuleID] = copyBuffer(Obj);
48 virtual MemoryBuffer* getObject(const Module* M) {
49 const MemoryBuffer* BufferFound = getObjectInternal(M);
50 ModulesLookedUp.insert(M->getModuleIdentifier());
53 // Our test cache wants to maintain ownership of its object buffers
54 // so we make a copy here for the execution engine.
55 return MemoryBuffer::getMemBufferCopy(BufferFound->getBuffer());
58 // Test-harness-specific functions
59 bool wereDuplicatesInserted() { return DuplicateInserted; }
61 bool wasModuleLookedUp(const Module *M) {
62 return ModulesLookedUp.find(M->getModuleIdentifier())
63 != ModulesLookedUp.end();
66 const MemoryBuffer* getObjectInternal(const Module* M) {
67 // Look for the module in our map.
68 const std::string ModuleID = M->getModuleIdentifier();
69 StringMap<const MemoryBuffer *>::iterator it = ObjMap.find(ModuleID);
70 if (it == ObjMap.end())
76 MemoryBuffer *copyBuffer(const MemoryBuffer *Buf) {
77 // Create a local copy of the buffer.
78 MemoryBuffer *NewBuffer = MemoryBuffer::getMemBufferCopy(Buf->getBuffer());
79 AllocatedBuffers.push_back(NewBuffer);
83 StringMap<const MemoryBuffer *> ObjMap;
84 StringSet<> ModulesLookedUp;
85 SmallVector<MemoryBuffer *, 2> AllocatedBuffers;
86 bool DuplicateInserted;
89 class MCJITObjectCacheTest : public testing::Test, public MCJITTestBase {
97 virtual void SetUp() {
98 M.reset(createEmptyModule("<main>"));
99 Main = insertMainFunction(M.get(), OriginalRC);
102 void compileAndRun(int ExpectedRC = OriginalRC) {
103 // This function shouldn't be called until after SetUp.
104 ASSERT_TRUE(TheJIT.isValid());
105 ASSERT_TRUE(0 != Main);
107 // We may be using a null cache, so ensure compilation is valid.
108 TheJIT->finalizeObject();
109 void *vPtr = TheJIT->getPointerToFunction(Main);
111 EXPECT_TRUE(0 != vPtr)
112 << "Unable to get pointer to main() from JIT";
114 int (*FuncPtr)(void) = (int(*)(void))(intptr_t)vPtr;
115 int returnCode = FuncPtr();
116 EXPECT_EQ(returnCode, ExpectedRC);
122 TEST_F(MCJITObjectCacheTest, SetNullObjectCache) {
123 SKIP_UNSUPPORTED_PLATFORM;
127 TheJIT->setObjectCache(NULL);
133 TEST_F(MCJITObjectCacheTest, VerifyBasicObjectCaching) {
134 SKIP_UNSUPPORTED_PLATFORM;
136 OwningPtr<TestObjectCache> Cache(new TestObjectCache);
138 // Save a copy of the module pointer before handing it off to MCJIT.
139 const Module * SavedModulePointer = M.get();
143 TheJIT->setObjectCache(Cache.get());
145 // Verify that our object cache does not contain the module yet.
146 const MemoryBuffer *ObjBuffer = Cache->getObjectInternal(SavedModulePointer);
147 EXPECT_EQ(0, ObjBuffer);
151 // Verify that MCJIT tried to look-up this module in the cache.
152 EXPECT_TRUE(Cache->wasModuleLookedUp(SavedModulePointer));
154 // Verify that our object cache now contains the module.
155 ObjBuffer = Cache->getObjectInternal(SavedModulePointer);
156 EXPECT_TRUE(0 != ObjBuffer);
158 // Verify that the cache was only notified once.
159 EXPECT_FALSE(Cache->wereDuplicatesInserted());
162 TEST_F(MCJITObjectCacheTest, VerifyLoadFromCache) {
163 SKIP_UNSUPPORTED_PLATFORM;
165 OwningPtr<TestObjectCache> Cache(new TestObjectCache);
167 // Compile this module with an MCJIT engine
169 TheJIT->setObjectCache(Cache.get());
170 TheJIT->finalizeObject();
172 // Destroy the MCJIT engine we just used
175 // Create a new memory manager.
176 MM = new SectionMemoryManager;
178 // Create a new module and save it. Use a different return code so we can
179 // tell if MCJIT compiled this module or used the cache.
180 M.reset(createEmptyModule("<main>"));
181 Main = insertMainFunction(M.get(), ReplacementRC);
182 const Module * SecondModulePointer = M.get();
184 // Create a new MCJIT instance to load this module then execute it.
186 TheJIT->setObjectCache(Cache.get());
189 // Verify that MCJIT tried to look-up this module in the cache.
190 EXPECT_TRUE(Cache->wasModuleLookedUp(SecondModulePointer));
192 // Verify that MCJIT didn't try to cache this again.
193 EXPECT_FALSE(Cache->wereDuplicatesInserted());
196 TEST_F(MCJITObjectCacheTest, VerifyNonLoadFromCache) {
197 SKIP_UNSUPPORTED_PLATFORM;
199 OwningPtr<TestObjectCache> Cache(new TestObjectCache);
201 // Compile this module with an MCJIT engine
203 TheJIT->setObjectCache(Cache.get());
204 TheJIT->finalizeObject();
206 // Destroy the MCJIT engine we just used
209 // Create a new memory manager.
210 MM = new SectionMemoryManager;
212 // Create a new module and save it. Use a different return code so we can
213 // tell if MCJIT compiled this module or used the cache. Note that we use
214 // a new module name here so the module shouldn't be found in the cache.
215 M.reset(createEmptyModule("<not-main>"));
216 Main = insertMainFunction(M.get(), ReplacementRC);
217 const Module * SecondModulePointer = M.get();
219 // Create a new MCJIT instance to load this module then execute it.
221 TheJIT->setObjectCache(Cache.get());
223 // Verify that our object cache does not contain the module yet.
224 const MemoryBuffer *ObjBuffer = Cache->getObjectInternal(SecondModulePointer);
225 EXPECT_EQ(0, ObjBuffer);
227 // Run the function and look for the replacement return code.
228 compileAndRun(ReplacementRC);
230 // Verify that MCJIT tried to look-up this module in the cache.
231 EXPECT_TRUE(Cache->wasModuleLookedUp(SecondModulePointer));
233 // Verify that our object cache now contains the module.
234 ObjBuffer = Cache->getObjectInternal(SecondModulePointer);
235 EXPECT_TRUE(0 != ObjBuffer);
237 // Verify that MCJIT didn't try to cache this again.
238 EXPECT_FALSE(Cache->wereDuplicatesInserted());