是否有类似于BigMemory的.NET系统？

Question

我刚刚阅读了关于BigMemory如何使Java系统进行纵向扩展而非横向扩展的文章。

关于BigMemory：

BigMemory为Java应用程序提供了即时、无缝访问大内存占用空间的能力，免除了垃圾回收的限制。

BigMemory是纯Java的，并提供了一个进程内、离堆缓存，让您将大量数据（高达一TB）存储在更靠近应用程序的地方。

这一突破性解决方案通过独立和分布式缓存改善了内存利用率和应用程序性能。

那么我该如何使用.net实现同样的功能，例如进程内、离堆缓存。（请注意，Asp.net缓存位于受垃圾回收管理的堆上。）

- Ian Ringrose

---

CLR已经内置了这个功能，它被称为大对象堆。 - Hans Passant

@adrianm OP想要一个“进程内”的东西。 - Tim Lloyd

@Hans，大对象堆仍然需要进行垃圾回收，并且必须由完整的GC进行扫描。它还只能容纳大型对象。尝试将128GB的数据放入大对象堆中，看看它对GC会产生什么影响... - Ian Ringrose

如果您想要手动内存管理，可以考虑对对象进行序列化和反序列化，并将它们放置在非托管堆上（即进程内）。但是，如果您经常这样做，性能可能会非常糟糕... - Tim Lloyd

@xantos 问题在于“序列化和反序列化”。 - Tim Lloyd

Answer 1

没有针对.Net的BigMemory系统（即进程内非GC堆内存管理器），但是您可以自己开发。 您可以利用一个非托管堆来实现不受垃圾收集的进程内堆，但如果您使用对象而不是原始内存，则必须对它们进行序列化和反序列化，这会很慢。

您需要保留堆信息的查找以便检索对象，这显然会增加其自己的内存开销，因此不适合大量非常小的对象，因为：

a. 管理对象将占用大量内存。
b. 垃圾回收将疯狂扫描管理对象。

如果对象足够大并且没有太多的对象，那么这可能适合您。

但是，您也可以将一些管理信息推入非托管堆中。有很多优化机会。

这可以全部封装成工作方式类似于键\值缓存，从而抽象化堆信息和堆。 更新内容 使用Protobuf更新了示例代码，它比.Net快得多地执行二进制序列化。这个简单的示例可以每秒放置+获取425k个对象，并带有键\值包装器。根据对象大小\复杂性，您的收益会有所不同。

对象大小存储在非托管堆上，以减少托管堆上的内存消耗。

...
...
using ProtoBuf;

[TestFixture]
public class UnmanagedHeap
{
    [Test]
    public void UnmanagedHeapAccess()
    {
        const int Iterations = 425 * 1000;
        const string Key = "woo";

        Bling obj = new Bling { Id = -666 };
        Cache cache = new Cache();
        Stopwatch sw = Stopwatch.StartNew();

        for (int i = 0; i < Iterations; i++)
        {
            cache.Put(Key, obj);

            obj = cache.Get<Bling>(Key);
        }

        cache.Remove(Key);

        Console.WriteLine(sw.Elapsed.TotalMilliseconds);
    }

    [DataContract]
    public class Bling
    {
        [DataMember(Order = 1)]
        public int Id { get; set; }
    }

    public class Cache
    {
        private const int SizeFieldWidth = 4;

        private readonly Dictionary<string, IntPtr> _lookup = new Dictionary<string, IntPtr>();

        public void Put(string key, object obj)
        {
            IntPtr oldPtr = _lookup.TryGetValue(key, out oldPtr) ? oldPtr : IntPtr.Zero;

            IntPtr newPtr = SerializeToHeap(obj, oldPtr);

            _lookup[key] = newPtr;
        }

        public T Get<T>(string key)
        {
            IntPtr ptr = _lookup[key];

            return DeserializeFromHeap<T>(ptr);
        }

        public void Remove(string key)
        {
            IntPtr ptr = _lookup[key];

            Marshal.FreeHGlobal(ptr);

            _lookup.Remove(key);
        }

        private static IntPtr SerializeToHeap(object obj, IntPtr oldPtr)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                Serializer.Serialize(ms, obj);
                byte[] objBytes = ms.GetBuffer();
                int newSize = (int)ms.Length;
                bool requiresAlloc = true;

                if (oldPtr != IntPtr.Zero)
                {
                    int oldSize = GetObjectSize(oldPtr);

                    requiresAlloc = (oldSize != newSize);
                }

                IntPtr newPtr = requiresAlloc ? Marshal.AllocHGlobal(newSize + SizeFieldWidth) : oldPtr;

                byte[] sizeField = BitConverter.GetBytes(newSize);
                Marshal.Copy(sizeField, 0, newPtr, SizeFieldWidth);
                Marshal.Copy(objBytes, 0, newPtr + SizeFieldWidth, newSize);
                return newPtr;
            }
        }

        private static T DeserializeFromHeap<T>(IntPtr ptr)
        {
            int size = GetObjectSize(ptr);
            byte[] objBytes = new byte[size];
            Marshal.Copy(ptr + SizeFieldWidth, objBytes, 0, size);

            using (MemoryStream ms = new MemoryStream(objBytes))
            {
                return Serializer.Deserialize<T>(ms);
            }
        }

        private static int GetObjectSize(IntPtr ptr)
        {
            byte[] sizeField = new byte[SizeFieldWidth];
            Marshal.Copy(ptr, sizeField, 0, SizeFieldWidth);
            int size = BitConverter.ToInt32(sizeField, 0);
            return size;
        }
    }
}

- Tim Lloyd

---

对于任何现在查看此内容的人，我建议使用Microsoft Bond而不是Protobuf。 - Chris Marisic

我认为每当您使用具有“requiresAlloc == true”的对象两次调用put并使用相同的键时，您都会有一个未经管理的内存泄漏。您需要在if (oldPtr！= IntPtr.Zero)块内部添加if (requiresAlloc) Marshal.FreeHGlobal(oldPtr)。此外，如果Cache不为空并且您让其超出范围，则会出现令人讨厌的内存泄漏。但是，如果您将IntPtr切换为调用Marshal.FreeHGlobal的SafeHandle，那么这个问题就可以解决了（使其可处置并使处置清空缓存也是一个不错的功能）。 - Scott Chamberlain

Answer 2

是的，这里有100%托管代码。 上面的答案中建议使用ProtoBuf将无法提供100%的透明度，因为它不能正确映射多态引用和循环 + 需要特殊属性。NFX Pile除了[Serializable]之外不需要任何其他东西。

https://github.com/aumcode/nfx https://github.com/aumcode/nfx/blob/master/Source/NFX/ApplicationModel/Pile/IPile.cs

https://github.com/aumcode/nfx/blob/master/Source/NFX/ApplicationModel/Pile/ICache.cs

查看视频： https://www.youtube.com/watch?v=IUBF2Ncvbbs

https://www.youtube.com/watch?v=Dz_7hukyejQ

Apache 2.0

- itadapter DKh