mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-21 12:35:47 -04:00
9fdfb66780
Explicitly defines ThreadSafeModule's move-assignment operator to move fields in reverse order. This is required to ensure that the context field outlives the module field. llvm-svn: 343149
95 lines
3.4 KiB
C++
95 lines
3.4 KiB
C++
//===--- ThreadSafeModuleTest.cpp - Test basic use of ThreadSafeModule ----===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
#include <atomic>
|
|
#include <future>
|
|
#include <thread>
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::orc;
|
|
|
|
namespace {
|
|
|
|
TEST(ThreadSafeModuleTest, ContextWhollyOwnedByOneModule) {
|
|
// Test that ownership of a context can be transferred to a single
|
|
// ThreadSafeModule.
|
|
ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
|
|
ThreadSafeModule TSM(llvm::make_unique<Module>("M", *TSCtx.getContext()),
|
|
std::move(TSCtx));
|
|
}
|
|
|
|
TEST(ThreadSafeModuleTest, ContextOwnershipSharedByTwoModules) {
|
|
// Test that ownership of a context can be shared between more than one
|
|
// ThreadSafeModule.
|
|
ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
|
|
|
|
ThreadSafeModule TSM1(llvm::make_unique<Module>("M1", *TSCtx.getContext()),
|
|
TSCtx);
|
|
ThreadSafeModule TSM2(llvm::make_unique<Module>("M2", *TSCtx.getContext()),
|
|
std::move(TSCtx));
|
|
}
|
|
|
|
TEST(ThreadSafeModuleTest, ContextOwnershipSharedWithClient) {
|
|
// Test that ownership of a context can be shared with a client-held
|
|
// ThreadSafeContext so that it can be re-used for new modules.
|
|
ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
|
|
|
|
{
|
|
// Create and destroy a module.
|
|
ThreadSafeModule TSM1(llvm::make_unique<Module>("M1", *TSCtx.getContext()),
|
|
TSCtx);
|
|
}
|
|
|
|
// Verify that the context is still available for re-use.
|
|
ThreadSafeModule TSM2(llvm::make_unique<Module>("M2", *TSCtx.getContext()),
|
|
std::move(TSCtx));
|
|
}
|
|
|
|
TEST(ThreadSafeModuleTest, ThreadSafeModuleMoveAssignment) {
|
|
// Move assignment needs to move the module before the context (opposite
|
|
// to the field order) to ensure that overwriting with an empty
|
|
// ThreadSafeModule does not destroy the context early.
|
|
ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
|
|
ThreadSafeModule TSM(llvm::make_unique<Module>("M", *TSCtx.getContext()),
|
|
std::move(TSCtx));
|
|
TSM = ThreadSafeModule();
|
|
}
|
|
|
|
TEST(ThreadSafeModuleTest, BasicContextLockAPI) {
|
|
// Test that basic lock API calls work.
|
|
ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
|
|
ThreadSafeModule TSM(llvm::make_unique<Module>("M", *TSCtx.getContext()),
|
|
TSCtx);
|
|
|
|
{ auto L = TSCtx.getLock(); }
|
|
|
|
{ auto L = TSM.getContextLock(); }
|
|
}
|
|
|
|
TEST(ThreadSafeModuleTest, ContextLockPreservesContext) {
|
|
// Test that the existence of a context lock preserves the attached
|
|
// context.
|
|
// The trick to verify this is a bit of a hack: We attach a Module
|
|
// (without the ThreadSafeModule wrapper) to the context, then verify
|
|
// that this Module destructs safely (which it will not if its context
|
|
// has been destroyed) even though all references to the context have
|
|
// been thrown away (apart from the lock).
|
|
|
|
ThreadSafeContext TSCtx(llvm::make_unique<LLVMContext>());
|
|
auto L = TSCtx.getLock();
|
|
auto &Ctx = *TSCtx.getContext();
|
|
auto M = llvm::make_unique<Module>("M", Ctx);
|
|
TSCtx = ThreadSafeContext();
|
|
}
|
|
|
|
} // end anonymous namespace
|