internal ScopedLock(RuntimeSystem parent)
{
writeScope = parent.assemblyLock.EnterWriteScope();
Parent = parent;
AssemblyVersion = parent.assemblyVersion;
}
/// <summary>
/// Constructs a new ILGPU main context
/// </summary>
/// <param name="builder">The parent builder instance.</param>
/// <param name="devices">The array of accelerator descriptions.</param>
internal Context(
Builder builder,
ImmutableArray <Device> devices)
{
InstanceId = InstanceId.CreateNew();
TargetPlatform = Backend.RuntimePlatform;
RuntimeSystem = new RuntimeSystem();
Properties = builder.InstantiateProperties();
// Initialize verifier
Verifier = builder.EnableVerifier ? Verifier.Instance : Verifier.Empty;
// Initialize main contexts
TypeContext = new IRTypeContext(this);
IRContext = new IRContext(this);
// Initialize intrinsic manager
IntrinsicManager = builder.IntrinsicManager;
// Create frontend
DebugInformationManager frontendDebugInformationManager =
Properties.DebugSymbolsMode > DebugSymbolsMode.Disabled
? DebugInformationManager
: null;
ILFrontend = builder.EnableParallelCodeGenerationInFrontend
? new ILFrontend(this, frontendDebugInformationManager)
: new ILFrontend(this, frontendDebugInformationManager, 1);
// Create default IL backend
DefautltILBackend = new DefaultILBackend(this);
// Initialize default transformer
ContextTransformer = Optimizer.CreateTransformer(
Properties.OptimizationLevel,
TransformerConfiguration.Transformed,
Properties.InliningMode);
// Initialize all devices
Devices = devices;
if (devices.IsDefaultOrEmpty)
{
// Add a default CPU device
Devices = ImmutableArray.Create <Device>(CPUDevice.Default);
}
// Create a mapping
deviceMapping = new Dictionary <AcceleratorType, List <Device> >(Devices.Length);
foreach (var device in Devices)
{
if (!deviceMapping.TryGetValue(device.AcceleratorType, out var devs))
{
devs = new List <Device>(8);
deviceMapping.Add(device.AcceleratorType, devs);
}
devs.Add(device);
}
}
/// <summary>
/// Clears internal caches. However, this does not affect individual accelerator
/// caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
/// <remarks>
/// This method is not thread-safe.
/// </remarks>
public override void ClearCache(ClearCacheMode mode)
{
IRContext.ClearCache(mode);
TypeContext.ClearCache(mode);
DebugInformationManager.ClearCache(mode);
DefautltILBackend.ClearCache(mode);
RuntimeSystem.ClearCache(mode);
base.ClearCache(mode);
}
/// <summary>
/// Constructs a new ILGPU main context
/// </summary>
/// <param name="optimizationLevel">The optimization level.</param>
/// <param name="flags">The context flags.</param>
public Context(ContextFlags flags, OptimizationLevel optimizationLevel)
{
// Enable debug information automatically when a debugger is attached
if (Debugger.IsAttached)
{
flags |= DefaultDebug;
}
InstanceId = InstanceId.CreateNew();
OptimizationLevel = optimizationLevel;
Flags = flags.Prepare();
TargetPlatform = Backend.RuntimePlatform;
RuntimeSystem = new RuntimeSystem();
// Initialize enhanced PTX backend feature flags
if (optimizationLevel > OptimizationLevel.O1 &&
!Flags.HasFlags(ContextFlags.DefaultPTXBackendFeatures))
{
Flags |= ContextFlags.EnhancedPTXBackendFeatures;
}
// Initialize verifier
Verifier = flags.HasFlags(ContextFlags.EnableVerifier)
? Verifier.Instance
: Verifier.Empty;
// Initialize main contexts
TypeContext = new IRTypeContext(this);
IRContext = new IRContext(this);
// Create frontend
DebugInformationManager frontendDebugInformationManager =
HasFlags(ContextFlags.EnableDebugSymbols)
? DebugInformationManager
: null;
ILFrontend = HasFlags(ContextFlags.EnableParallelCodeGenerationInFrontend)
? new ILFrontend(this, frontendDebugInformationManager)
: new ILFrontend(this, frontendDebugInformationManager, 1);
// Create default IL backend
DefautltILBackend = new DefaultILBackend(this);
// Initialize default transformer
ContextTransformer = Optimizer.CreateTransformer(
OptimizationLevel,
TransformerConfiguration.Transformed,
Flags);
// Intrinsics
IntrinsicManager = new IntrinsicImplementationManager();
InitIntrinsics();
}
/// <summary>
/// Constructs a new ILGPU main context
/// </summary>
/// <param name="builder">The parent builder instance.</param>
/// <param name="devices">The array of accelerator descriptions.</param>
internal Context(
Builder builder,
ImmutableArray <Device> devices)
{
InstanceId = InstanceId.CreateNew();
TargetPlatform = Backend.RuntimePlatform;
RuntimeSystem = new RuntimeSystem();
Properties = builder.InstantiateProperties();
// Initialize verifier
Verifier = builder.EnableVerifier ? Verifier.Instance : Verifier.Empty;
// Initialize main contexts
TypeContext = new IRTypeContext(this);
IRContext = new IRContext(this);
// Initialize intrinsic manager
IntrinsicManager = builder.IntrinsicManager;
// Create frontend
DebugInformationManager frontendDebugInformationManager =
Properties.DebugSymbolsMode > DebugSymbolsMode.Disabled
? DebugInformationManager
: null;
ILFrontend = builder.EnableParallelCodeGenerationInFrontend
? new ILFrontend(this, frontendDebugInformationManager)
: new ILFrontend(this, frontendDebugInformationManager, 1);
// Create default IL backend
DefautltILBackend = new DefaultILBackend(this);
// Initialize default transformer
ContextTransformer = Optimizer.CreateTransformer(
Properties.OptimizationLevel,
TransformerConfiguration.Transformed,
Properties.InliningMode);
// Initialize the default CPU device
// NB: Ensure that the current accelerator is not changed when creating the
// implicit CPU accelerator. Otherwise, we may unintentionally initialize
// Accelerator.Current before an accelerator has been created by the user.
var currentAccelerator = Accelerator.Current;
CPUAccelerator = new CPUAccelerator(
this,
CPUDevice.Implicit,
CPUAcceleratorMode.Parallel,
ThreadPriority.Lowest);
Debug.Assert(Accelerator.Current == currentAccelerator);
// Initialize all devices
Devices = devices;
if (devices.IsDefaultOrEmpty)
{
// Add a default CPU device
Devices = ImmutableArray.Create <Device>(CPUDevice.Default);
}
// Create a mapping
deviceMapping = new Dictionary <AcceleratorType, List <Device> >(Devices.Length);
foreach (var device in Devices)
{
if (!deviceMapping.TryGetValue(device.AcceleratorType, out var devs))
{
devs = new List <Device>(8);
deviceMapping.Add(device.AcceleratorType, devs);
}
devs.Add(device);
}
}