Imported Upstream version 1.1.0upstream/1.1.0

2 files changed, 1748 insertions, 0 deletions

diff --git a/src/mscorlib/Common/PinnableBufferCache.cs b/src/mscorlib/Common/PinnableBufferCache.cs
new file mode 100644
index 0000000000..fee3e46f46
--- /dev/null
+++ b/src/mscorlib/Common/PinnableBufferCache.cs
@@ -0,0 +1,666 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+#define ENABLE
+#define MINBUFFERS
+using System;
+#if !FEATURE_CORECLR
+using System.Diagnostics.Tracing;
+#endif
+using System.Runtime.InteropServices;
+using System.Runtime.ConstrainedExecution;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Runtime.CompilerServices;
+using System.Diagnostics;
+using System.Security.Permissions;
+
+#if PINNABLEBUFFERCACHE_MSCORLIB
+namespace System.Threading
+#else
+namespace System
+#endif
+{
+    internal sealed class PinnableBufferCache
+    {
+        /// <summary>
+        /// Create a new cache for pinned byte[] buffers
+        /// </summary>
+        /// <param name="cacheName">A name used in diagnostic messages</param>
+        /// <param name="numberOfElements">The size of byte[] buffers in the cache (they are all the same size)</param>
+        public PinnableBufferCache(string cacheName, int numberOfElements) : this(cacheName, () => new byte[numberOfElements]) { }
+
+        /// <summary>
+        /// Get a buffer from the buffer manager.  If no buffers exist, allocate a new one.
+        /// </summary>
+        public byte[] AllocateBuffer() { return (byte[])Allocate(); }
+
+        /// <summary>
+        /// Return a buffer back to the buffer manager.
+        /// </summary>
+        public void FreeBuffer(byte[] buffer) { Free(buffer); }
+
+        /// <summary>
+        /// Create a PinnableBufferCache that works on any object (it is intended for OverlappedData)
+        /// This is only used in mscorlib.
+        /// </summary>
+#if (ENABLE || MINBUFFERS)
+#pragma warning disable 618
+        [EnvironmentPermission(SecurityAction.Assert, Unrestricted = true)]
+#pragma warning restore 618
+        [System.Security.SecuritySafeCritical]
+#endif
+        internal PinnableBufferCache(string cacheName, Func<object> factory)
+        {
+            m_NotGen2 = new List<object>(DefaultNumberOfBuffers);
+            m_factory = factory;
+#if ENABLE
+            // Check to see if we should disable the cache.
+            string envVarName = "PinnableBufferCache_" + cacheName + "_Disabled";
+            try
+            {
+                string envVar = Environment.GetEnvironmentVariable(envVarName);
+                if (envVar != null)
+                {
+                    PinnableBufferCacheEventSource.Log.DebugMessage("Creating " + cacheName + " PinnableBufferCacheDisabled=" + envVar);
+                    int index = envVar.IndexOf(cacheName, StringComparison.OrdinalIgnoreCase);
+                    if (0 <= index)
+                    {
+                        // The cache is disabled because we haven't set the cache name.
+                        PinnableBufferCacheEventSource.Log.DebugMessage("Disabling " + cacheName);
+                        return;
+                    }
+                }
+            }
+            catch
+            {
+                // Ignore failures when reading the environment variable.
+            }
+#endif
+#if MINBUFFERS
+            // Allow the environment to specify a minimum buffer count.
+            string minEnvVarName = "PinnableBufferCache_" + cacheName + "_MinCount";
+            try
+            {
+                string minEnvVar = Environment.GetEnvironmentVariable(minEnvVarName);
+                if (minEnvVar != null)
+                {
+                    if (int.TryParse(minEnvVar, out m_minBufferCount))
+                        CreateNewBuffers();
+                }
+            }
+            catch
+            {
+                // Ignore failures when reading the environment variable.
+            }
+#endif
+
+            PinnableBufferCacheEventSource.Log.Create(cacheName);
+            m_CacheName = cacheName;
+        }
+
+        /// <summary>
+        /// Get a object from the buffer manager.  If no buffers exist, allocate a new one.
+        /// </summary>
+        [System.Security.SecuritySafeCritical]
+        internal object Allocate()
+        {
+#if ENABLE
+            // Check to see whether or not the cache is disabled.
+            if (m_CacheName == null)
+                return m_factory();
+#endif
+            // Fast path, get it from our Gen2 aged m_FreeList.  
+            object returnBuffer;
+            if (!m_FreeList.TryPop(out returnBuffer))
+                Restock(out returnBuffer);
+
+            // Computing free count is expensive enough that we don't want to compute it unless logging is on.
+            if (PinnableBufferCacheEventSource.Log.IsEnabled())
+            {
+                int numAllocCalls = Interlocked.Increment(ref m_numAllocCalls);
+                if (numAllocCalls >= 1024)
+                {
+                    lock (this)
+                    {
+                        int previousNumAllocCalls = Interlocked.Exchange(ref m_numAllocCalls, 0);
+                        if (previousNumAllocCalls >= 1024)
+                        {
+                            int nonGen2Count = 0;
+                            foreach (object o in m_FreeList)
+                            {
+                                if (GC.GetGeneration(o) < GC.MaxGeneration)
+                                {
+                                    nonGen2Count++;
+                                }
+                            }
+
+                            PinnableBufferCacheEventSource.Log.WalkFreeListResult(m_CacheName, m_FreeList.Count, nonGen2Count);
+                        }
+                    }
+                }
+
+                PinnableBufferCacheEventSource.Log.AllocateBuffer(m_CacheName, PinnableBufferCacheEventSource.AddressOf(returnBuffer), returnBuffer.GetHashCode(), GC.GetGeneration(returnBuffer), m_FreeList.Count);
+            }
+            return returnBuffer;
+        }
+
+        /// <summary>
+        /// Return a buffer back to the buffer manager.
+        /// </summary>
+        [System.Security.SecuritySafeCritical]
+        internal void Free(object buffer)
+        {
+#if ENABLE
+            // Check to see whether or not the cache is disabled.
+            if (m_CacheName == null)
+                return;
+#endif
+            if (PinnableBufferCacheEventSource.Log.IsEnabled())
+                PinnableBufferCacheEventSource.Log.FreeBuffer(m_CacheName, PinnableBufferCacheEventSource.AddressOf(buffer), buffer.GetHashCode(), m_FreeList.Count);
+
+
+            // After we've done 3 gen1 GCs, assume that all buffers have aged into gen2 on the free path.
+            if ((m_gen1CountAtLastRestock + 3) > GC.CollectionCount(GC.MaxGeneration - 1))
+            {
+                lock (this)
+                {
+                    if (GC.GetGeneration(buffer) < GC.MaxGeneration)
+                    {
+                        // The buffer is not aged, so put it in the non-aged free list.
+                        m_moreThanFreeListNeeded = true;
+                        PinnableBufferCacheEventSource.Log.FreeBufferStillTooYoung(m_CacheName, m_NotGen2.Count);
+                        m_NotGen2.Add(buffer);
+                        m_gen1CountAtLastRestock = GC.CollectionCount(GC.MaxGeneration - 1);
+                        return;
+                    }
+                }
+            }
+
+            // If we discovered that it is indeed Gen2, great, put it in the Gen2 list.  
+            m_FreeList.Push(buffer);
+        }
+
+        #region Private
+
+        /// <summary>
+        /// Called when we don't have any buffers in our free list to give out.    
+        /// </summary>
+        /// <returns></returns>
+        [System.Security.SecuritySafeCritical]
+        private void Restock(out object returnBuffer)
+        {
+            lock (this)
+            {
+                // Try again after getting the lock as another thread could have just filled the free list.  If we don't check
+                // then we unnecessarily grab a new set of buffers because we think we are out.     
+                if (m_FreeList.TryPop(out returnBuffer))
+                    return;
+
+                // Lazy init, Ask that TrimFreeListIfNeeded be called on every Gen 2 GC.  
+                if (m_restockSize == 0)
+                    Gen2GcCallback.Register(Gen2GcCallbackFunc, this);
+
+                // Indicate to the trimming policy that the free list is insufficent.   
+                m_moreThanFreeListNeeded = true;
+                PinnableBufferCacheEventSource.Log.AllocateBufferFreeListEmpty(m_CacheName, m_NotGen2.Count);
+
+                // Get more buffers if needed.
+                if (m_NotGen2.Count == 0)
+                    CreateNewBuffers();
+
+                // We have no buffers in the aged freelist, so get one from the newer list.   Try to pick the best one.
+                // Debug.Assert(m_NotGen2.Count != 0);
+                int idx = m_NotGen2.Count - 1;
+                if (GC.GetGeneration(m_NotGen2[idx]) < GC.MaxGeneration && GC.GetGeneration(m_NotGen2[0]) == GC.MaxGeneration)
+                    idx = 0;
+                returnBuffer = m_NotGen2[idx];
+                m_NotGen2.RemoveAt(idx);
+
+                // Remember any sub-optimial buffer so we don't put it on the free list when it gets freed.   
+                if (PinnableBufferCacheEventSource.Log.IsEnabled() && GC.GetGeneration(returnBuffer) < GC.MaxGeneration)
+                {
+                    PinnableBufferCacheEventSource.Log.AllocateBufferFromNotGen2(m_CacheName, m_NotGen2.Count);
+                }
+
+                // If we have a Gen1 collection, then everything on m_NotGen2 should have aged.  Move them to the m_Free list.  
+                if (!AgePendingBuffers())
+                {
+                    // Before we could age at set of buffers, we have handed out half of them.
+                    // This implies we should be proactive about allocating more (since we will trim them if we over-allocate).  
+                    if (m_NotGen2.Count == m_restockSize / 2)
+                    {
+                        PinnableBufferCacheEventSource.Log.DebugMessage("Proactively adding more buffers to aging pool");
+                        CreateNewBuffers();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// See if we can promote the buffers to the free list.  Returns true if sucessful. 
+        /// </summary>
+        [System.Security.SecuritySafeCritical]
+        private bool AgePendingBuffers()
+        {
+            if (m_gen1CountAtLastRestock < GC.CollectionCount(GC.MaxGeneration - 1))
+            {
+                // Allocate a temp list of buffers that are not actually in gen2, and swap it in once
+                // we're done scanning all buffers.
+                int promotedCount = 0;
+                List<object> notInGen2 = new List<object>();
+                PinnableBufferCacheEventSource.Log.AllocateBufferAged(m_CacheName, m_NotGen2.Count);
+                for (int i = 0; i < m_NotGen2.Count; i++)
+                {
+                    // We actually check every object to ensure that we aren't putting non-aged buffers into the free list.
+                    object currentBuffer = m_NotGen2[i];
+                    if (GC.GetGeneration(currentBuffer) >= GC.MaxGeneration)
+                    {
+                        m_FreeList.Push(currentBuffer);
+                        promotedCount++;
+                    }
+                    else
+                    {
+                        notInGen2.Add(currentBuffer);
+                    }
+                }
+                PinnableBufferCacheEventSource.Log.AgePendingBuffersResults(m_CacheName, promotedCount, notInGen2.Count);
+                m_NotGen2 = notInGen2;
+
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Generates some buffers to age into Gen2.
+        /// </summary>
+        private void CreateNewBuffers()
+        {
+            // We choose a very modest number of buffers initially because for the client case.  This is often enough.
+            if (m_restockSize == 0)
+                m_restockSize = 4;
+            else if (m_restockSize < DefaultNumberOfBuffers)
+                m_restockSize = DefaultNumberOfBuffers;
+            else if (m_restockSize < 256)
+                m_restockSize = m_restockSize * 2;                // Grow quickly at small sizes
+            else if (m_restockSize < 4096)
+                m_restockSize = m_restockSize * 3 / 2;            // Less agressively at large ones
+            else
+                m_restockSize = 4096;                             // Cap how agressive we are
+
+            // Ensure we hit our minimums
+            if (m_minBufferCount > m_buffersUnderManagement)
+                m_restockSize = Math.Max(m_restockSize, m_minBufferCount - m_buffersUnderManagement);
+
+            PinnableBufferCacheEventSource.Log.AllocateBufferCreatingNewBuffers(m_CacheName, m_buffersUnderManagement, m_restockSize);
+            for (int i = 0; i < m_restockSize; i++)
+            {
+                // Make a new buffer.
+                object newBuffer = m_factory();
+
+                // Create space between the objects.  We do this because otherwise it forms a single plug (group of objects)
+                // and the GC pins the entire plug making them NOT move to Gen1 and Gen2.   by putting space between them
+                // we ensure that object get a chance to move independently (even if some are pinned).  
+                var dummyObject = new object();
+                m_NotGen2.Add(newBuffer);
+            }
+            m_buffersUnderManagement += m_restockSize;
+            m_gen1CountAtLastRestock = GC.CollectionCount(GC.MaxGeneration - 1);
+        }
+
+        /// <summary>
+        /// This is the static function that is called from the gen2 GC callback.
+        /// The input object is the cache itself.
+        /// NOTE: The reason that we make this functionstatic and take the cache as a parameter is that
+        /// otherwise, we root the cache to the Gen2GcCallback object, and leak the cache even when
+        /// the application no longer needs it.
+        /// </summary>
+        [System.Security.SecuritySafeCritical]
+        private static bool Gen2GcCallbackFunc(object targetObj)
+        {
+            return ((PinnableBufferCache)(targetObj)).TrimFreeListIfNeeded();
+        }
+
+        /// <summary>
+        /// This is called on every gen2 GC to see if we need to trim the free list.
+        /// NOTE: DO NOT CALL THIS DIRECTLY FROM THE GEN2GCCALLBACK.  INSTEAD CALL IT VIA A STATIC FUNCTION (SEE ABOVE).
+        /// If you register a non-static function as a callback, then this object will be leaked.
+        /// </summary>
+        [System.Security.SecuritySafeCritical]
+        private bool TrimFreeListIfNeeded()
+        {
+            int curMSec = Environment.TickCount;
+            int deltaMSec = curMSec - m_msecNoUseBeyondFreeListSinceThisTime;
+            PinnableBufferCacheEventSource.Log.TrimCheck(m_CacheName, m_buffersUnderManagement, m_moreThanFreeListNeeded, deltaMSec);
+
+            // If we needed more than just the set of aged buffers since the last time we were called,
+            // we obviously should not be trimming any memory, so do nothing except reset the flag 
+            if (m_moreThanFreeListNeeded)
+            {
+                m_moreThanFreeListNeeded = false;
+                m_trimmingExperimentInProgress = false;
+                m_msecNoUseBeyondFreeListSinceThisTime = curMSec;
+                return true;
+            }
+
+            // We require a minimum amount of clock time to pass  (10 seconds) before we trim.  Ideally this time
+            // is larger than the typical buffer hold time.  
+            if (0 <= deltaMSec && deltaMSec < 10000)
+                return true;
+
+            // If we got here we have spend the last few second without needing to lengthen the free list.   Thus
+            // we have 'enough' buffers, but maybe we have too many. 
+            // See if we can trim
+            lock (this)
+            {
+                // Hit a race, try again later.  
+                if (m_moreThanFreeListNeeded)
+                {
+                    m_moreThanFreeListNeeded = false;
+                    m_trimmingExperimentInProgress = false;
+                    m_msecNoUseBeyondFreeListSinceThisTime = curMSec;
+                    return true;
+                }
+
+                var freeCount = m_FreeList.Count;   // This is expensive to fetch, do it once.
+
+                // If there is something in m_NotGen2 it was not used for the last few seconds, it is trimable.  
+                if (m_NotGen2.Count > 0)
+                {
+                    // If we are not performing an experiment and we have stuff that is waiting to go into the
+                    // free list but has not made it there, it could be becasue the 'slow path' of restocking
+                    // has not happened, so force this (which should flush the list) and start over.  
+                    if (!m_trimmingExperimentInProgress)
+                    {
+                        PinnableBufferCacheEventSource.Log.TrimFlush(m_CacheName, m_buffersUnderManagement, freeCount, m_NotGen2.Count);
+                        AgePendingBuffers();
+                        m_trimmingExperimentInProgress = true;
+                        return true;
+                    }
+
+                    PinnableBufferCacheEventSource.Log.TrimFree(m_CacheName, m_buffersUnderManagement, freeCount, m_NotGen2.Count);
+                    m_buffersUnderManagement -= m_NotGen2.Count;
+
+                    // Possibly revise the restocking down.  We don't want to grow agressively if we are trimming.  
+                    var newRestockSize = m_buffersUnderManagement / 4;
+                    if (newRestockSize < m_restockSize)
+                        m_restockSize = Math.Max(newRestockSize, DefaultNumberOfBuffers);
+
+                    m_NotGen2.Clear();
+                    m_trimmingExperimentInProgress = false;
+                    return true;
+                }
+
+                // Set up an experiment where we use 25% less buffers in our free list.   We put them in 
+                // m_NotGen2, and if they are needed they will be put back in the free list again.  
+                var trimSize = freeCount / 4 + 1;
+
+                // We are OK with a 15% overhead, do nothing in that case.  
+                if (freeCount * 15 <= m_buffersUnderManagement || m_buffersUnderManagement - trimSize <= m_minBufferCount)
+                {
+                    PinnableBufferCacheEventSource.Log.TrimFreeSizeOK(m_CacheName, m_buffersUnderManagement, freeCount);
+                    return true;
+                }
+
+                // Move buffers from the free list back to the non-aged list.  If we don't use them by next time, then we'll consider trimming them.
+                PinnableBufferCacheEventSource.Log.TrimExperiment(m_CacheName, m_buffersUnderManagement, freeCount, trimSize);
+                object buffer;
+                for (int i = 0; i < trimSize; i++)
+                {
+                    if (m_FreeList.TryPop(out buffer))
+                        m_NotGen2.Add(buffer);
+                }
+                m_msecNoUseBeyondFreeListSinceThisTime = curMSec;
+                m_trimmingExperimentInProgress = true;
+            }
+
+            // Indicate that we want to be called back on the next Gen 2 GC.  
+            return true;
+        }
+
+        private const int DefaultNumberOfBuffers = 16;
+        private string m_CacheName;
+        private Func<object> m_factory;
+
+        /// <summary>
+        /// Contains 'good' buffers to reuse.  They are guarenteed to be Gen 2 ENFORCED!
+        /// </summary>
+        private ConcurrentStack<object> m_FreeList = new ConcurrentStack<object>();
+        /// <summary>
+        /// Contains buffers that are not gen 2 and thus we do not wish to give out unless we have to.
+        /// To implement trimming we sometimes put aged buffers in here as a place to 'park' them
+        /// before true deletion.  
+        /// </summary>
+        private List<object> m_NotGen2;
+        /// <summary>
+        /// What whas the gen 1 count the last time re restocked?  If it is now greater, then
+        /// we know that all objects are in Gen 2 so we don't have to check.  Should be updated
+        /// every time something gets added to the m_NotGen2 list.
+        /// </summary>
+        private int m_gen1CountAtLastRestock;
+
+        /// <summary>
+        /// Used to ensure we have a minimum time between trimmings.  
+        /// </summary>
+        private int m_msecNoUseBeyondFreeListSinceThisTime;
+        /// <summary>
+        /// To trim, we remove things from the free list (which is Gen 2) and see if we 'hit bottom'
+        /// This flag indicates that we hit bottom (we really needed a bigger free list).
+        /// </summary>
+        private bool m_moreThanFreeListNeeded;
+        /// <summary>
+        /// The total number of buffers that this cache has ever allocated.
+        /// Used in trimming heuristics. 
+        /// </summary>
+        private int m_buffersUnderManagement;
+        /// <summary>
+        /// The number of buffers we added the last time we restocked.
+        /// </summary>
+        private int m_restockSize;
+        /// <summary>
+        /// Did we put some buffers into m_NotGen2 to see if we can trim?
+        /// </summary>
+        private bool m_trimmingExperimentInProgress;
+        /// <summary>
+        /// A forced minimum number of buffers.
+        /// </summary>
+        private int m_minBufferCount;
+        /// <summary>
+        /// The number of calls to Allocate.
+        /// </summary>
+        private int m_numAllocCalls;
+
+        #endregion
+    }
+
+    /// <summary>
+    /// Schedules a callback roughly every gen 2 GC (you may see a Gen 0 an Gen 1 but only once)
+    /// (We can fix this by capturing the Gen 2 count at startup and testing, but I mostly don't care)
+    /// </summary>
+    internal sealed class Gen2GcCallback : CriticalFinalizerObject
+    {
+        [System.Security.SecuritySafeCritical]
+        public Gen2GcCallback()
+            : base()
+        {
+        }
+
+        /// <summary>
+        /// Schedule 'callback' to be called in the next GC.  If the callback returns true it is 
+        /// rescheduled for the next Gen 2 GC.  Otherwise the callbacks stop. 
+        /// 
+        /// NOTE: This callback will be kept alive until either the callback function returns false,
+        /// or the target object dies.
+        /// </summary>
+        public static void Register(Func<object, bool> callback, object targetObj)
+        {
+            // Create a unreachable object that remembers the callback function and target object.
+            Gen2GcCallback gcCallback = new Gen2GcCallback();
+            gcCallback.Setup(callback, targetObj);
+        }
+
+        #region Private
+
+        private Func<object, bool> m_callback;
+        private GCHandle m_weakTargetObj;
+
+        [System.Security.SecuritySafeCritical]
+        private void Setup(Func<object, bool> callback, object targetObj)
+        {
+            m_callback = callback;
+            m_weakTargetObj = GCHandle.Alloc(targetObj, GCHandleType.Weak);
+        }
+
+        [System.Security.SecuritySafeCritical]
+        ~Gen2GcCallback()
+        {
+            // Check to see if the target object is still alive.
+            object targetObj = m_weakTargetObj.Target;
+            if (targetObj == null)
+            {
+                // The target object is dead, so this callback object is no longer needed.
+                m_weakTargetObj.Free();
+                return;
+            }
+
+            // Execute the callback method.
+            try
+            {
+                if (!m_callback(targetObj))
+                {
+                    // If the callback returns false, this callback object is no longer needed.
+                    return;
+                }
+            }
+            catch
+            {
+                // Ensure that we still get a chance to resurrect this object, even if the callback throws an exception.
+            }
+
+            // Resurrect ourselves by re-registering for finalization.
+            if (!Environment.HasShutdownStarted && !AppDomain.CurrentDomain.IsFinalizingForUnload())
+            {
+                GC.ReRegisterForFinalize(this);
+            }
+        }
+
+        #endregion
+    }
+
+
+#if FEATURE_CORECLR
+    internal sealed class PinnableBufferCacheEventSource
+    {
+        public static readonly PinnableBufferCacheEventSource Log = new PinnableBufferCacheEventSource();
+
+        public bool IsEnabled() { return false; }
+        public void DebugMessage(string message) {}
+        public void DebugMessage1(string message, long value) {}
+        public void DebugMessage2(string message, long value1, long value2) {}
+        public void DebugMessage3(string message, long value1, long value2, long value3) {}
+        public void Create(string cacheName) {}
+        public void AllocateBuffer(string cacheName, ulong objectId, int objectHash, int objectGen, int freeCountAfter) {}
+        public void AllocateBufferFromNotGen2(string cacheName, int notGen2CountAfter) {}
+        public void AllocateBufferCreatingNewBuffers(string cacheName, int totalBuffsBefore, int objectCount) {}
+        public void AllocateBufferAged(string cacheName, int agedCount) {}
+        public void AllocateBufferFreeListEmpty(string cacheName, int notGen2CountBefore) {}
+        public void FreeBuffer(string cacheName, ulong objectId, int objectHash, int freeCountBefore) {}
+        public void FreeBufferStillTooYoung(string cacheName, int notGen2CountBefore) {}
+        public void TrimCheck(string cacheName, int totalBuffs, bool neededMoreThanFreeList, int deltaMSec) {}
+        public void TrimFree(string cacheName, int totalBuffs, int freeListCount, int toBeFreed) {}
+        public void TrimExperiment(string cacheName, int totalBuffs, int freeListCount, int numTrimTrial) {}
+        public void TrimFreeSizeOK(string cacheName, int totalBuffs, int freeListCount) {}
+        public void TrimFlush(string cacheName, int totalBuffs, int freeListCount, int notGen2CountBefore) {}
+        public void AgePendingBuffersResults(string cacheName, int promotedToFreeListCount, int heldBackCount) {}
+        public void WalkFreeListResult(string cacheName, int freeListCount, int gen0BuffersInFreeList) {}
+
+        static internal ulong AddressOf(object obj)
+        {
+            return 0;
+        }
+
+        [System.Security.SecuritySafeCritical]
+        static internal unsafe long AddressOfObject(byte[] array)
+        {
+            return 0;
+        }
+    }
+#else
+    /// <summary>
+    /// PinnableBufferCacheEventSource is a private eventSource that we are using to
+    /// debug and monitor the effectiveness of PinnableBufferCache
+    /// </summary>
+#if PINNABLEBUFFERCACHE_MSCORLIB
+    [EventSource(Name = "Microsoft-DotNETRuntime-PinnableBufferCache")]
+#else
+    [EventSource(Name = "Microsoft-DotNETRuntime-PinnableBufferCache-System")]
+#endif
+    internal sealed class PinnableBufferCacheEventSource : EventSource
+    {
+        public static readonly PinnableBufferCacheEventSource Log = new PinnableBufferCacheEventSource();
+
+        [Event(1, Level = EventLevel.Verbose)]
+        public void DebugMessage(string message) { if (IsEnabled()) WriteEvent(1, message); }
+        [Event(2, Level = EventLevel.Verbose)]
+        public void DebugMessage1(string message, long value) { if (IsEnabled()) WriteEvent(2, message, value); }
+        [Event(3, Level = EventLevel.Verbose)]
+        public void DebugMessage2(string message, long value1, long value2) { if (IsEnabled()) WriteEvent(3, message, value1, value2); }
+        [Event(18, Level = EventLevel.Verbose)]
+        public void DebugMessage3(string message, long value1, long value2, long value3) { if (IsEnabled()) WriteEvent(18, message, value1, value2, value3); }
+
+        [Event(4)]
+        public void Create(string cacheName) { if (IsEnabled()) WriteEvent(4, cacheName); }
+
+        [Event(5, Level = EventLevel.Verbose)]
+        public void AllocateBuffer(string cacheName, ulong objectId, int objectHash, int objectGen, int freeCountAfter) { if (IsEnabled()) WriteEvent(5, cacheName, objectId, objectHash, objectGen, freeCountAfter); }
+        [Event(6)]
+        public void AllocateBufferFromNotGen2(string cacheName, int notGen2CountAfter) { if (IsEnabled()) WriteEvent(6, cacheName, notGen2CountAfter); }
+        [Event(7)]
+        public void AllocateBufferCreatingNewBuffers(string cacheName, int totalBuffsBefore, int objectCount) { if (IsEnabled()) WriteEvent(7, cacheName, totalBuffsBefore, objectCount); }
+        [Event(8)]
+        public void AllocateBufferAged(string cacheName, int agedCount) { if (IsEnabled()) WriteEvent(8, cacheName, agedCount); }
+        [Event(9)]
+        public void AllocateBufferFreeListEmpty(string cacheName, int notGen2CountBefore) { if (IsEnabled()) WriteEvent(9, cacheName, notGen2CountBefore); }
+
+        [Event(10, Level = EventLevel.Verbose)]
+        public void FreeBuffer(string cacheName, ulong objectId, int objectHash, int freeCountBefore) { if (IsEnabled()) WriteEvent(10, cacheName, objectId, objectHash, freeCountBefore); }
+        [Event(11)]
+        public void FreeBufferStillTooYoung(string cacheName, int notGen2CountBefore) { if (IsEnabled()) WriteEvent(11, cacheName, notGen2CountBefore); }
+
+        [Event(13)]
+        public void TrimCheck(string cacheName, int totalBuffs, bool neededMoreThanFreeList, int deltaMSec) { if (IsEnabled()) WriteEvent(13, cacheName, totalBuffs, neededMoreThanFreeList, deltaMSec); }
+        [Event(14)]
+        public void TrimFree(string cacheName, int totalBuffs, int freeListCount, int toBeFreed) { if (IsEnabled()) WriteEvent(14, cacheName, totalBuffs, freeListCount, toBeFreed); }
+        [Event(15)]
+        public void TrimExperiment(string cacheName, int totalBuffs, int freeListCount, int numTrimTrial) { if (IsEnabled()) WriteEvent(15, cacheName, totalBuffs, freeListCount, numTrimTrial); }
+        [Event(16)]
+        public void TrimFreeSizeOK(string cacheName, int totalBuffs, int freeListCount) { if (IsEnabled()) WriteEvent(16, cacheName, totalBuffs, freeListCount); }
+        [Event(17)]
+        public void TrimFlush(string cacheName, int totalBuffs, int freeListCount, int notGen2CountBefore) { if (IsEnabled()) WriteEvent(17, cacheName, totalBuffs, freeListCount, notGen2CountBefore); }
+        [Event(20)]
+        public void AgePendingBuffersResults(string cacheName, int promotedToFreeListCount, int heldBackCount) { if (IsEnabled()) WriteEvent(20, cacheName, promotedToFreeListCount, heldBackCount); }
+        [Event(21)]
+        public void WalkFreeListResult(string cacheName, int freeListCount, int gen0BuffersInFreeList) { if (IsEnabled()) WriteEvent(21, cacheName, freeListCount, gen0BuffersInFreeList); }
+
+
+        static internal ulong AddressOf(object obj)
+        {
+            var asByteArray = obj as byte[];
+            if (asByteArray != null)
+                return (ulong)AddressOfByteArray(asByteArray);
+            return 0;
+        }
+
+        [System.Security.SecuritySafeCritical]
+        static internal unsafe long AddressOfByteArray(byte[] array)
+        {
+            if (array == null)
+                return 0;
+            fixed (byte* ptr = array)
+                return (long)(ptr - 2 * sizeof(void*));
+        }
+    }
+#endif
+}
diff --git a/src/mscorlib/Common/Preprocessed/AssemblyRefs.g.cs b/src/mscorlib/Common/Preprocessed/AssemblyRefs.g.cs
new file mode 100644
index 0000000000..24a1866a5d
--- /dev/null
+++ b/src/mscorlib/Common/Preprocessed/AssemblyRefs.g.cs
@@ -0,0 +1,1082 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
+
+/*
+ * Assembly attributes. This file is preprocessed to generate a .cs file
+ * with the correct information.  The original lives in VBL\Tools\DevDiv\
+ */
+
+using System;
+using System.Reflection;
+using System.Resources;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+
+
+// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+/**
+ * Version strings for Frameworks.
+ * 
+ */
+
+//
+// Insert just the #defines in winver.h, so that the
+// C# compiler can include this file after macro preprocessing.
+//
+
+
+
+
+
+
+
+
+
+// #line 21 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+
+//
+// winver.h is bad for rc.exe & csc.exe whereas verrsrc.h does not have an include guard
+// yet defines the same structure twice if RC_INVOKED is not #defined.
+// Temporarily enable RC_INVOKED protection around the #include.
+//
+
+
+
+
+
+
+// #line 1 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
+// #line 1 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
+/*
+
+
+
+Module Name:
+
+    winapifamily.h
+
+Abstract:
+
+    Master include file for API family partitioning.
+
+*/
+
+
+
+
+
+// #pragma once
+// #line 21 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
+
+/*
+ * When compiling C and C++ code using SDK header files, the development
+ * environment can specify a target platform by #define-ing the
+ * pre-processor symbol WINAPI_FAMILY to one of the following values.
+ * Each FAMILY value denotes an application family for which a different
+ * subset of the total set of header-file-defined APIs are available.
+ * Setting the WINAPI_FAMILY value will effectively hide from the
+ * editing and compilation environments the existence of APIs that
+ * are not applicable to the family of applications targeting a
+ * specific platform.
+ */
+
+/*
+ * The WINAPI_FAMILY values of 0 and 1 are reserved to ensure that
+ * an error will occur if WINAPI_FAMILY is set to any
+ * WINAPI_PARTITION value (which must be 0 or 1, see below).
+ */
+
+
+
+/* The value of WINAPI_FAMILY_DESKTOP_APP may change in future SDKs. */
+/* Additional WINAPI_FAMILY values may be defined in future SDKs. */
+
+/*
+ * For compatibility with Windows 8 header files, the following
+ * synonym for WINAPI_FAMILY_PC_APP is temporarily #define'd.
+ * Use of this symbol should be considered deprecated.
+ */
+
+
+/*
+ * If no WINAPI_FAMILY value is specified, then all APIs available to
+ * Windows desktop applications are exposed.
+ */
+
+
+// #line 59 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
+
+/*
+ * API PARTITONs are part of an indirection mechanism for mapping between
+ * individual APIs and the FAMILYs to which they apply.
+ * Each PARTITION is a category or subset of named APIs.  PARTITIONs
+ * are permitted to have overlapping membership -- some single API
+ * might be part of more than one PARTITION.  In support of new
+ * FAMILYs that might be added in future SDKs, any single current
+ * PARTITION might in that future SDK be split into two or more new PARTITIONs.
+ * Accordingly, application developers should avoid taking dependencies on
+ * PARTITION names; developers' only dependency upon the symbols defined
+ * in this file should be their reliance on the WINAPI_FAMILY names and values.
+ */
+
+/*
+ * Current PARTITIONS are each #undef'ed below, and then will be #define-ed
+ * to be either 1 or 0 or depending on the active WINAPI_FAMILY.
+ */
+
+
+
+
+
+
+
+/*
+ * The mapping between families and partitions is summarized here.
+ * An X indicates that the given partition is active for the given
+ * platform/family.
+ *
+ *                             +---------------+
+ *                             |  *Partition*  |
+ *                             +---+---+---+---+
+ *                             |   |   |   | P |
+ *                             |   |   |   | H |
+ *                             | D |   |   | O |
+ *                             | E |   | P | N |
+ *                             | S |   | C | E |
+ *                             | K |   | _ | _ |
+ *                             | T | A | A | A |
+ * +-------------------------+-+ O | P | P | P |
+ * |     *Platform/Family*    \| P | P | P | P |
+ * +---------------------------+---+---+---+---+
+ * | WINAPI_FAMILY_DESKTOP_APP | X | X | X |   |
+ * +---------------------------+---+---+---+---+
+ * |      WINAPI_FAMILY_PC_APP |   | X | X |   |
+ * +---------------------------+---+---+---+---+
+ * |   WINAPI_FAMILY_PHONE_APP |   | X |   | X |
+ * +---------------------------+---+---+---+---+
+ *
+ * The table above is encoded in the following expressions,
+ * each of which evaluates to 1 or 0.
+ *
+ * Whenever a new family is added, all of these expressions
+ * need to be reconsidered.
+ */
+
+
+// #line 118 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
+
+
+
+
+
+/*
+ * For compatibility with Windows Phone 8 header files, the following
+ * synonym for WINAPI_PARTITION_PHONE_APP is temporarily #define'd.
+ * Use of this symbol should be regarded as deprecated.
+ */
+
+
+/*
+ * Header files use the WINAPI_FAMILY_PARTITION macro to assign one or
+ * more declarations to some group of partitions.  The macro chooses
+ * whether the preprocessor will emit or omit a sequence of declarations
+ * bracketed by an #if/#endif pair.  All header file references to the
+ * WINAPI_PARTITION_* values should be in the form of occurrences of
+ * WINAPI_FAMILY_PARTITION(...).
+ *
+ * For example, the following usage of WINAPI_FAMILY_PARTITION identifies
+ * a sequence of declarations that are part of both the Windows Desktop
+ * Partition and the Windows-Phone-Specific Store Partition:
+ *
+ *     #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_PHONE_APP)
+ *     ...
+ *     #endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_PHONE_APP)
+ *
+ * The comment on the closing #endif allow tools as well as people to find the
+ * matching #ifdef properly.
+ *
+ * Usages of WINAPI_FAMILY_PARTITION may be combined, when the partitition definitions are
+ * related.  In particular one might use declarations like
+ * 
+ *     #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+ *
+ * or
+ *
+ *     #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
+ *
+ * Direct references to WINAPI_PARTITION_ values (eg #if !WINAPI_FAMILY_PARTITION_...)
+ * should not be used.
+ */ 
+
+
+/*
+ * Macro used to #define or typedef a symbol used for selective deprecation
+ * of individual methods of a COM interfaces that are otherwise available
+ * for a given set of partitions.
+ */
+
+
+/*
+ * For compatibility with Windows 8 header files, the following
+ * symbol is temporarily conditionally #define'd.  Additional symbols
+ * like this should be not defined in winapifamily.h, but rather should be
+ * introduced locally to the header files of the component that needs them.
+ */
+
+
+// #line 179 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
+
+// #line 181 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
+// #line 2 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
+
+/****************************************************************************
+**                                                                             *
+* verrsrc.h -   Version Resource definitions                                  *
+*                                                                             *
+*               Include file declaring version resources in rc files          *
+*                                                                             *
+*               *
+*                                                                             *
+\*****************************************************************************/
+
+// #pragma region Application Family
+
+
+/* ----- Symbols ----- */
+
+
+
+
+/* ----- VS_VERSION.dwFileFlags ----- */
+
+
+
+
+// #line 27 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
+
+
+
+/* ----- VS_VERSION.dwFileFlags ----- */
+
+
+
+
+
+
+
+/* ----- VS_VERSION.dwFileOS ----- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* ----- VS_VERSION.dwFileType ----- */
+
+
+
+
+
+
+
+
+/* ----- VS_VERSION.dwFileSubtype for VFT_WINDOWS_DRV ----- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* ----- VS_VERSION.dwFileSubtype for VFT_WINDOWS_FONT ----- */
+
+
+
+
+// #line 88 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
+// // #pragma region 
+
+// #pragma region Desktop Family
+
+
+/* ----- VerFindFile() flags ----- */
+
+
+
+
+
+
+/* ----- VerInstallFile() flags ----- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// #line 171 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
+// #pragma region 
+
+// #line 37 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+
+
+
+//
+// Include the definitions for rmj, rmm, rup, rpt
+//
+
+// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
+
+
+
+
+// #line 6 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
+
+// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\version.h"
+// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\ndpversion_generated.h"
+
+
+
+
+// #line 6 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\ndpversion_generated.h"
+
+
+
+
+
+// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\buildnumber.h"
+
+
+
+
+// #line 6 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\buildnumber.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// #line 12 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\ndpversion_generated.h"
+// #line 2 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\version.h"
+
+
+
+
+
+
+
+
+
+
+
+
+// #line 8 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
+
+
+
+// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\asm_version.h"
+
+
+
+
+
+
+
+
+
+
+
+// #line 13 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\asm_version.h"
+
+
+
+
+
+// #line 19 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\asm_version.h"
+
+// #line 12 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
+// #line 13 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// #line 161 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
+
+
+
+
+
+// #line 167 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
+
+
+
+
+
+// #line 173 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
+
+
+
+
+
+
+// #line 180 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
+
+// #line 48 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+/*
+ * Product version, name and copyright
+ */
+
+// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+
+    
+        
+
+// #line 6 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+            
+        
+
+// #line 10 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+    
+
+
+
+// #line 15 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+// #line 16 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+
+// The following copyright is intended for display in the Windows Explorer property box for a DLL or EXE
+// See \\lca\pdm\TMGUIDE\Copyright\Crt_Tmk_Notices.xls for copyright guidelines
+//
+
+    
+        
+
+// #line 25 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+            
+        
+
+// #line 29 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+    
+
+
+
+
+
+
+// #line 37 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+// #line 38 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+
+// VSWhidbey #495749
+// Note: The following legal copyright is intended for situations where the copyright symbol doesn't display 
+//       properly.  For example, the following copyright should be displayed as part of the logo for DOS command-line 
+//       applications.  If you change the format or wording of the following copyright, you should apply the same
+//       change to fxresstrings.txt (for managed applications).
+
+    
+    
+// #line 48 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
+// #line 54 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+/*
+ * File version, names, description.
+ */
+
+// FX_VER_INTERNALNAME_STR is passed in by the build environment.
+
+
+
+
+
+
+
+// FX_VER_FILEDESCRIPTION_STR is defined in RC files that include fxver.h
+
+
+
+// #line 72 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+
+
+// #line 78 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+
+
+
+// #line 85 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+//URT_VFT passed in by the build environment.
+
+
+
+
+
+
+
+/* default is nodebug */
+
+
+
+
+// #line 102 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+// DEBUG flag is set for debug build, not set for retail build
+// #if defined(DEBUG) || defined(_DEBUG)
+// #define VER_DEBUG        VS_FF_DEBUG
+// #else  // DEBUG
+// #define VER_DEBUG        0
+// #endif // DEBUG
+
+
+/* default is prerelease */
+
+
+// #line 115 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+// #line 117 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+// PRERELEASE flag is always set unless building SHIP version
+// #ifndef _SHIP
+// #define VER_PRERELEASE   VS_FF_PRERELEASE
+// #else
+// #define VER_PRERELEASE   0
+// #endif // _SHIP
+
+
+
+// #line 128 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+// #line 130 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+// PRIVATEBUILD flag is set if not built by build lab
+// #ifndef _VSBUILD
+// #define VER_PRIVATEBUILD VS_FF_PRIVATEBUILD
+// #else  // _VSBUILD
+// #define VER_PRIVATEBUILD 0
+// #endif // _VSBUILD
+
+
+
+// #line 141 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+// #line 143 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// #line 164 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+
+
+
+
+
+
+// #line 174 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+
+
+// #line 180 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+
+
+
+
+
+// #line 189 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+// #line 193 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// #line 248 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+// #line 250 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+
+
+// #line 254 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+
+// #line 256 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
+// #line 24 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
+
+internal static class FXAssembly {
+    internal const string Version = "4.0.0.0";
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// #line 44 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
+
+internal static class ThisAssembly {
+    internal const string Title = "System.Private.CoreLib.dll";
+    internal const string Description = "System.Private.CoreLib.dll";
+    internal const string DefaultAlias = "System.Private.CoreLib.dll";
+    internal const string Copyright = "\u00A9 Microsoft Corporation.  All rights reserved.";
+    internal const string Version = "4.0.0.0";
+    internal const string InformationalVersion = "4.0.22306.0";
+    internal const string DailyBuildNumberStr = "22306";
+    internal const string BuildRevisionStr = "0";
+    internal const int DailyBuildNumber = 22306;
+}
+
+
+#pragma warning disable 436
+internal static class AssemblyRef {
+    internal const string EcmaPublicKey                              = "b77a5c561934e089";
+    internal const string EcmaPublicKeyToken                         = "b77a5c561934e089";
+    internal const string EcmaPublicKeyFull                          = "00000000000000000400000000000000";
+
+    internal const string SilverlightPublicKey                       = "31bf3856ad364e35";
+    internal const string SilverlightPublicKeyToken                  = "31bf3856ad364e35";
+    internal const string SilverlightPublicKeyFull                   = "0024000004800000940000000602000000240000525341310004000001000100B5FC90E7027F67871E773A8FDE8938C81DD402BA65B9201D60593E96C492651E889CC13F1415EBB53FAC1131AE0BD333C5EE6021672D9718EA31A8AEBD0DA0072F25D87DBA6FC90FFD598ED4DA35E44C398C454307E8E33B8426143DAEC9F596836F97C8F74750E5975C64E2189F45DEF46B2A2B1247ADC3652BF5C308055DA9";
+
+    internal const string SilverlightPlatformPublicKey               = "7cec85d7bea7798e";
+    internal const string SilverlightPlatformPublicKeyToken          = "7cec85d7bea7798e";
+    internal const string SilverlightPlatformPublicKeyFull           = "00240000048000009400000006020000002400005253413100040000010001008D56C76F9E8649383049F383C44BE0EC204181822A6C31CF5EB7EF486944D032188EA1D3920763712CCB12D75FB77E9811149E6148E5D32FBAAB37611C1878DDC19E20EF135D0CB2CFF2BFEC3D115810C3D9069638FE4BE215DBF795861920E5AB6F7DB2E2CEEF136AC23D5DD2BF031700AEC232F6C6B1C785B4305C123B37AB";
+
+
+    internal const string PlatformPublicKey                          = SilverlightPlatformPublicKey;
+    internal const string PlatformPublicKeyToken                     = SilverlightPlatformPublicKeyToken;
+    internal const string PlatformPublicKeyFull                      = SilverlightPlatformPublicKeyFull;
+
+
+
+
+// #line 81 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
+
+    internal const string Mscorlib                                   = "mscorlib, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
+    internal const string SystemData                                 = "System.Data, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
+    internal const string SystemDataOracleClient                     = "System.Data.OracleClient, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
+    internal const string System                                     = "System, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
+    internal const string SystemCore                                 = "System.Core, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
+    internal const string SystemNumerics                             = "System.Numerics, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
+    internal const string SystemRuntimeRemoting                      = "System.Runtime.Remoting, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
+    internal const string SystemThreadingTasksDataflow               = "System.Threading.Tasks.Dataflow, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
+    internal const string SystemWindowsForms                         = "System.Windows.Forms, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
+    internal const string SystemXml                                  = "System.Xml, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
+    
+    internal const string MicrosoftPublicKey                         = "b03f5f7f11d50a3a";
+    internal const string MicrosoftPublicKeyToken                    = "b03f5f7f11d50a3a";
+    internal const string MicrosoftPublicKeyFull                     = "002400000480000094000000060200000024000052534131000400000100010007D1FA57C4AED9F0A32E84AA0FAEFD0DE9E8FD6AEC8F87FB03766C834C99921EB23BE79AD9D5DCC1DD9AD236132102900B723CF980957FC4E177108FC607774F29E8320E92EA05ECE4E821C0A5EFE8F1645C4C0C93C1AB99285D622CAA652C1DFAD63D745D6F2DE5F17E5EAF0FC4963D261C8A12436518206DC093344D5AD293";
+
+    internal const string SharedLibPublicKey                         = "31bf3856ad364e35";
+    internal const string SharedLibPublicKeyToken                    = "31bf3856ad364e35";
+    internal const string SharedLibPublicKeyFull                     = "0024000004800000940000000602000000240000525341310004000001000100B5FC90E7027F67871E773A8FDE8938C81DD402BA65B9201D60593E96C492651E889CC13F1415EBB53FAC1131AE0BD333C5EE6021672D9718EA31A8AEBD0DA0072F25D87DBA6FC90FFD598ED4DA35E44C398C454307E8E33B8426143DAEC9F596836F97C8F74750E5975C64E2189F45DEF46B2A2B1247ADC3652BF5C308055DA9";
+
+    internal const string SystemComponentModelDataAnnotations        = "System.ComponentModel.DataAnnotations, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
+    internal const string SystemConfiguration                        = "System.Configuration, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemConfigurationInstall                 = "System.Configuration.Install, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemDeployment                           = "System.Deployment, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemDesign                               = "System.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemDirectoryServices                    = "System.DirectoryServices, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemDrawingDesign                        = "System.Drawing.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemDrawing                              = "System.Drawing, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemEnterpriseServices                   = "System.EnterpriseServices, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemManagement                           = "System.Management, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemMessaging                            = "System.Messaging, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemNetHttp                              = "System.Net.Http, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemNetHttpWebRequest                    = "System.Net.Http.WebRequest, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemRuntimeSerializationFormattersSoap   = "System.Runtime.Serialization.Formatters.Soap, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemRuntimeWindowsRuntime                = "System.Runtime.WindowsRuntime, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
+    internal const string SystemRuntimeWindowsRuntimeUIXaml          = "System.Runtime.WindowsRuntimeUIXaml, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
+    internal const string SystemSecurity                             = "System.Security, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemServiceModelWeb                      = "System.ServiceModel.Web, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
+    internal const string SystemServiceProcess                       = "System.ServiceProcess, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemWeb                                  = "System.Web, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemWebAbstractions                      = "System.Web.Abstractions, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
+    internal const string SystemWebDynamicData                       = "System.Web.DynamicData, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
+    internal const string SystemWebDynamicDataDesign                 = "System.Web.DynamicData.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
+    internal const string SystemWebEntityDesign                      = "System.Web.Entity.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
+    internal const string SystemWebExtensions                        = "System.Web.Extensions, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
+    internal const string SystemWebExtensionsDesign                  = "System.Web.Extensions.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
+    internal const string SystemWebMobile                            = "System.Web.Mobile, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemWebRegularExpressions                = "System.Web.RegularExpressions, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string SystemWebRouting                           = "System.Web.Routing, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
+    internal const string SystemWebServices                          = "System.Web.Services, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    
+    internal const string WindowsBase                                = "WindowsBase, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
+    
+    internal const string MicrosoftVisualStudio                      = "Microsoft.VisualStudio, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string MicrosoftVisualStudioWindowsForms          = "Microsoft.VisualStudio.Windows.Forms, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string VJSharpCodeProvider                        = "VJSharpCodeProvider, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+
+    internal const string ASPBrowserCapsPublicKey                    = "b7bd7678b977bd8f";
+    internal const string ASPBrowserCapsFactory                      = "ASP.BrowserCapsFactory, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + ASPBrowserCapsPublicKey;
+
+
+    // We do not want these sitting in non-VS specific files.  If you need them,
+    // add this line to sources:  
+    // C_DEFINES=$(C_DEFINES) /DINCLUDE_VSREFS
+    //
+    // M.VS.dll and M.VSDesigner.dll should also be included here, but it
+    // turns out that everyone, from Data, to XSP to Winforms to diagnostics
+    // has thrown some designer-specific code into M.VS.dll or M.VSDesigner.dll.
+    //
+    
+
+
+
+
+
+// #line 157 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
+
+    // VS Provided Assemblies... we can't strong bind to these, they 
+    // update their assembly versions too often
+    //
+    internal const string MicrosoftVSDesigner                        = "Microsoft.VSDesigner, Version=10.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string MicrosoftVisualStudioWeb                   = "Microsoft.VisualStudio.Web, Version=10.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string MicrosoftWebDesign                         = "Microsoft.Web.Design.Client, Version=10.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string MicrosoftVSDesignerMobile                  = "Microsoft.VSDesigner.Mobile, Version=8.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    internal const string MicrosoftJScript                           = "Microsoft.JScript, Version=8.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    
+    //internal const string MicrosoftVSDesigner                        = "Microsoft.VSDesigner, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
+    //internal const string MicrosoftJScript                           = "Microsoft.JScript, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;   
+}
+#pragma warning restore 436
+// #line 172 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"