Added support to clear internal caches.

See #10.

Src/ILGPU/Backends/ArgumentMapper.cs

@@ -27,7 +27,7 @@ namespace ILGPU.Backends
     /// can be accessed by the native kernel.
     /// </summary>
     /// <remarks>Members of this class are not thread safe.</remarks>
-    public abstract class ArgumentMapper
+    public abstract class ArgumentMapper : ICache
     {
         #region Nested Types
 
@@ -526,6 +526,15 @@ protected Type MapType(Type type)
             }
         }
 
+        /// <summary>
+        /// Clears internal caches.
+        /// </summary>
+        /// <param name="mode">The clear mode.</param>
+        public void ClearCache(ClearCacheMode mode)
+        {
+            typeMapping.Clear();
+        }
+
         #endregion
     }
 }

Src/ILGPU/Backends/Backend.cs

@@ -43,7 +43,7 @@ public enum TargetPlatform
     /// <summary>
     /// Represents a general ILGPU backend.
     /// </summary>
-    public abstract class Backend : DisposeBase
+    public abstract class Backend : DisposeBase, ICache
     {
         #region Nested Types
 
@@ -460,6 +460,16 @@ protected static TargetPlatform GetPlatform(TargetPlatform? platform)
             in BackendContext backendContext,
             in KernelSpecialization specialization);
 
+        /// <summary>
+        /// Clears all internal caches.
+        /// </summary>
+        /// <param name="mode">The clear mode.</param>
+        /// <remarks>This method is not thread-safe.</remarks>
+        public void ClearCache(ClearCacheMode mode)
+        {
+            ArgumentMapper?.ClearCache(mode);
+        }
+
         #endregion
 
         #region IDisposable

Src/ILGPU/Context.Constants.cs

@@ -18,10 +18,15 @@ partial class Context
         /// </summary>
         public const string RuntimeAssemblyName = "ILGPURuntime";
 
+        /// <summary>
+        /// Represents the general ILGPU assembly name.
+        /// </summary>
+        public const string AssemblyName = "ILGPU";
+
         /// <summary>
         /// Represents the general ILGPU assembly module name.
         /// </summary>
-        public const string AssemblyModuleName = "ILGPU.dll";
+        public const string FullAssemblyModuleName = AssemblyName + ".dll";
 
         /// <summary>
         /// The ILGPU assembly file extension.

Src/ILGPU/Context.cs

@@ -32,7 +32,7 @@ namespace ILGPU
     /// Represents the main ILGPU context.
     /// </summary>
     /// <remarks>Members of this class are thread safe.</remarks>
-    public sealed partial class Context : DisposeBase
+    public sealed partial class Context : DisposeBase, ICache
     {
         #region Static
 
@@ -129,8 +129,9 @@ static Context()
         private PTXContextData ptxContextData;
 
         private readonly object assemblyLock = new object();
-        private readonly AssemblyBuilder assemblyBuilder;
-        private readonly ModuleBuilder moduleBuilder;
+        private int assemblyVersion = 0;
+        private AssemblyBuilder assemblyBuilder;
+        private ModuleBuilder moduleBuilder;
         private volatile int typeBuilderIdx = 0;
 
         /// <summary>
@@ -195,13 +196,9 @@ public Context(ContextFlags flags, OptimizationLevel optimizationLevel)
                 TransformerConfiguration.Transformed,
                 Flags);
 
-            // Initialize assembly and module builder
-            var assemblyName = new AssemblyName(RuntimeAssemblyName);
-            assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
-            moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name);
-
-            // Initialize context-dependent information
-            ptxContextData = new PTXContextData(this);
+            // Initialize assembly builder and context data
+            ReloadAssemblyBuilder();
+            ReloadContextData();
         }
 
         #endregion
@@ -257,6 +254,31 @@ public Context(ContextFlags flags, OptimizationLevel optimizationLevel)
 
         #region Methods
 
+        /// <summary>
+        /// Reloads the assembly builder.
+        /// </summary>
+        private void ReloadAssemblyBuilder()
+        {
+            var assemblyName = new AssemblyName(RuntimeAssemblyName)
+            {
+                Version = new Version(1, assemblyVersion++),
+            };
+            assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(
+                assemblyName,
+                AssemblyBuilderAccess.RunAndCollect);
+            moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name);
+        }
+
+        /// <summary>
+        /// Reloads context-dependent information.
+        /// </summary>
+        private void ReloadContextData()
+        {
+            Dispose(ref ptxContextData);
+
+            ptxContextData = new PTXContextData(this);
+        }
+
         /// <summary>
         /// Returns true if the current context has the given flags.
         /// </summary>
@@ -346,6 +368,24 @@ public Task<ContextCodeGenerationPhase> BeginCodeGenerationAsync(IRContext irCon
             return Task.Run(() => BeginCodeGeneration(irContext));
         }
 
+        /// <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 void ClearCache(ClearCacheMode mode)
+        {
+            mainContext.ClearCache(mode);
+            typeContext.ClearCache(mode);
+            debugInformationManager.ClearCache(mode);
+            defaultILBackend.ClearCache(mode);
+
+            ReloadAssemblyBuilder();
+            ReloadContextData();
+        }
+
         #endregion
 
         #region Runtime Assembly

Src/ILGPU/ContextFlags.cs

@@ -128,6 +128,8 @@ public enum ContextFlags : int
         /// <remarks>
         /// However, IR nodes, type information and debug information will still
         /// be cached, since they are used for different kernel compilation operations.
+        /// If you want to clear those caches as well, you will have to clear them
+        /// manually using <see cref="Context.ClearCache(ClearCacheMode)"/>.
         /// </remarks>
         DisableKernelCaching = 1 << 24,
 

Src/ILGPU/Frontend/DebugInformation/DebugInformationManager.cs

@@ -24,7 +24,7 @@ namespace ILGPU.Frontend.DebugInformation
     /// <summary>
     /// Represents a debug-information manager.
     /// </summary>
-    public sealed class DebugInformationManager : DisposeBase
+    public sealed class DebugInformationManager : DisposeBase, ICache
     {
         #region Constants
 
@@ -203,7 +203,7 @@ public bool Load(Assembly assembly, out AssemblyDebugInformation assemblyDebugIn
 
         #region Instance
 
-        private ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim(
+        private readonly ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim(
             LockRecursionPolicy.SupportsRecursion);
         private readonly Dictionary<string, string> pdbFiles = new Dictionary<string, string>();
         private readonly HashSet<string> lookupDirectories = new HashSet<string>();
@@ -432,6 +432,44 @@ public MethodScopeEnumerator LoadScopes(MethodBase methodBase)
             return MethodScopeEnumerator.Empty;
         }
 
+        /// <summary>
+        /// Clears cached debug information.
+        /// </summary>
+        /// <param name="mode">The clear mode.</param>
+        public void ClearCache(ClearCacheMode mode)
+        {
+            cacheLock.EnterWriteLock();
+            try
+            {
+                if (mode == ClearCacheMode.Everything)
+                {
+                    foreach (var debugInformation in assemblies.Values)
+                        debugInformation.Dispose();
+                    assemblies.Clear();
+                }
+                else
+                {
+                    // Do not dispose system assemblies
+                    var assembliesToRemove = new List<Assembly>(assemblies.Count);
+                    foreach (var assembly in assemblies.Keys)
+                    {
+                        if (assembly.FullName.StartsWith(Context.AssemblyName, StringComparison.OrdinalIgnoreCase))
+                            continue;
+                        assembliesToRemove.Add(assembly);
+                    }
+                    foreach (var assemblyToRemove in assembliesToRemove)
+                    {
+                        assemblies[assemblyToRemove].Dispose();
+                        assemblies.Remove(assemblyToRemove);
+                    }
+                }
+            }
+            finally
+            {
+                cacheLock.ExitWriteLock();
+            }
+        }
+
         #endregion
 
         #region IDisposable
@@ -441,10 +479,8 @@ public MethodScopeEnumerator LoadScopes(MethodBase methodBase)
             Justification = "Dispose method will be invoked by a helper method")]
         protected override void Dispose(bool disposing)
         {
-            foreach (var assembly in assemblies.Values)
-                assembly.Dispose();
-            assemblies.Clear();
-            Dispose(ref cacheLock);
+            ClearCache(ClearCacheMode.Everything);
+            cacheLock.Dispose();
         }
 
         #endregion

Src/ILGPU/ICache.cs

@@ -0,0 +1,44 @@
+// -----------------------------------------------------------------------------
+//                                    ILGPU
+//                     Copyright (c) 2016-2019 Marcel Koester
+//                                www.ilgpu.net
+//
+// File: ICache.cs
+//
+// This file is part of ILGPU and is distributed under the University of
+// Illinois Open Source License. See LICENSE.txt for details
+// -----------------------------------------------------------------------------
+
+namespace ILGPU
+{
+    /// <summary>
+    /// Specifies which resources should be removed from the cache.
+    /// </summary>
+    public enum ClearCacheMode : int
+    {
+        /// <summary>
+        /// Removes all non-ILGPU objects form the caches.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// Removes everything from the caches.
+        /// </summary>
+        Everything = 1,
+    }
+
+    /// <summary>
+    /// Represents an object that contains internal caches.
+    /// </summary>
+    public interface ICache
+    {
+        /// <summary>
+        /// Clears all internal caches.
+        /// </summary>
+        /// <param name="mode">The clear mode.</param>
+        /// <remarks>
+        /// Implementations of this method are not guaranteed to be thread-safe.
+        /// </remarks>
+        void ClearCache(ClearCacheMode mode);
+    }
+}

Src/ILGPU/IR/IRContext.cs

@@ -30,7 +30,7 @@ namespace ILGPU.IR
     /// <summary>
     /// Represents an IR context.
     /// </summary>
-    public sealed partial class IRContext : DisposeBase
+    public sealed partial class IRContext : DisposeBase, ICache
     {
         #region Nested Types
 
@@ -554,9 +554,16 @@ public void GC()
         }
 
         /// <summary>
-        /// Clears this context and removes all nodes
+        /// Clears cached IR nodes.
         /// </summary>
-        public void Clear()
+        [Obsolete("Use ClearCache(ClearCacheMode.Everything) instead")]
+        public void Clear() => ClearCache(ClearCacheMode.Everything);
+
+        /// <summary>
+        /// Clears cached IR nodes.
+        /// </summary>
+        /// <param name="mode">The clear mode.</param>
+        public void ClearCache(ClearCacheMode mode)
         {
             irLock.EnterWriteLock();
             try

Src/ILGPU/IR/Transformations/Inliner.cs

@@ -53,7 +53,7 @@ public sealed class Inliner : OrderedTransformation
 
                 if ((source.MethodImplementationFlags & MethodImplAttributes.AggressiveInlining)
                     == MethodImplAttributes.AggressiveInlining ||
-                    source.Module.Name == Context.AssemblyModuleName)
+                    source.Module.Name == Context.FullAssemblyModuleName)
                     method.AddFlags(MethodFlags.Inline);
             }
 

Src/ILGPU/IR/Types/IRTypeContext.cs

@@ -253,7 +253,7 @@ public TypeNode CreateType(Type type, MemoryAddressSpace addressSpace)
         }
 
         /// <summary>
-        /// Specializes the address space of the given <see cref="AddressSpaceType"/>.
+        /// Specializes the address space of the given <seeVoidType cref="AddressSpaceType"/>.
         /// </summary>
         /// <param name="addressSpaceType">The source type.</param>
         /// <param name="addressSpace">The new address space.</param>
@@ -334,6 +334,47 @@ private T CreateType<T>(T type)
             }
         }
 
+        /// <summary>
+        /// Clears all internal caches.
+        /// </summary>
+        /// <param name="mode">The clear mode.</param>
+        public override void ClearCache(ClearCacheMode mode)
+        {
+            base.ClearCache(mode);
+
+            typeLock.EnterWriteLock();
+            try
+            {
+                unifiedTypes.Clear();
+
+                unifiedTypes.Add(VoidType, VoidType);
+                unifiedTypes.Add(StringType, StringType);
+
+                foreach (var basicType in BasicValueTypes)
+                {
+                    var type = GetPrimitiveType(basicType);
+                    unifiedTypes.Add(type, type);
+                }
+
+                unifiedTypes.Add(IndexType, IndexType);
+            }
+            finally
+            {
+                typeLock.ExitWriteLock();
+            }
+        }
+
+        #endregion
+
+        #region IDisposable
+
+        /// <summary cref="DisposeBase.Dispose(bool)"/>
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+            typeLock.Dispose();
+        }
+
         #endregion
     }
 }