精华内容
下载资源
问答
  • 托管内存
    2019-08-21 09:24:39

    C# 托管内存与非托管内存之间的转换

    c#有自己的内存回收机制,所以在c#中我们可以只new,不用关心怎样delete,c#使用gc来清理内存,这部分内存就是managed memory,大部分时候我们工作于c#环境中,都是在使用托管内存,然而c#毕竟运行在c++之上,有的时候,(比如可能我们需要引入一些第三方的c++或native代码的库,在Unity3d开发中很常见)我们需要直接在c#中操纵非托管的代码,这些non-managed memory我们就需要自己去处理他们的申请和释放了, c# 中提供了一些接口,完成托管和非托管之间的转换,以及对这部分内存的操作。

    基本上有以下几种:

    1.managed memory-> unmanaged memory

    比如在c#中调用第三方的某个c++库,库中有个函数是void func(float * data, int length).我们需要传入给data的就应该是一个非托管的代码(why?首先传入托管的内存,c#层很可能会把它gc掉,而c++还在使用,而且托管的mem它的指针地址可能会发生改变,因此直接传给c++可能拿到的地址是错误的)

    代码如下:

    using System.Runtime.InteropServices;
    float[] _managed_data  =... // this is the c# managed data
    GCHandle unmanaged_data_handle = GCHandle.Alloc(_managed_data, GCHandleType.Pinned); //这里将标记_managed_data暂时不能被gc回收,并且固定对象的地址
    func(unmanaged_data_handle.AddrOfPinnedObject(),_managed_data.Length);//这里将拿到非托管内存的固定地址,传给c++
    unmanaged_data_handle.Free();//使用完毕后,将其handle free,这样c#可以正常gc这块内存
    

    2.un-managed memory->managed memory

    在c++中返回一个un-managed mem给c#使用。有时需要在c++中分配一块处理好的内存,然后返回给c#来使用,如c++中某个接口 int func(int** data) (注意这里要使用指针的指针,因为data是得到的结果)

    IntPtr unmanaged_ptr=IntPtr.Zero; //定义这个c#中用来接收c++返回数据的指针类型
    int length = func(out unmanaged_ptr );//调用c++的函数,使unmanaged_ptr指向c++里分配的内存,注意这里用out ,才能与c++里面的**匹配。
    byte[] managed_data = new byte[length];
    Marshal.Copy(unmanaged_ptr, managed_data, 0, length);//将非托管内存拷贝成托管内存,才能在c#里面使用
    Marshal.FreeHGlobal(unmanaged_ptr);//释放非托管的内存
    

    3.在c#直接申请一个un-managed mem传给c++

    有时需要直接在c#开辟一块非托管的内存,传给c++用,这块内存同样可以在c#中用后销毁。代码如下

    IntPtr unmanaged_data_prt = Marshal. AllocHGlobal(100);// 直接分配100 byte的内存
    func(unmanaged_data_prt);//传给c++使用
    Marshal.FreeHGlobal(unmanaged_data_prt);使用后销毁非托管内存
    

    此外 Marshal类里面还有很多处理非托管内存的方法。

    备注

    托管内存和非托管内存在c#里面可以互相自由的转化,主要通过Marshal类和GCHandle类,编程时只要注意非托管的内存一定要负责好释放就可以了。

    更多相关内容
  • 在本篇文章里小编给大家整理了关于C#托管内存与非托管内存之间的转换的实例以及相关知识点,需要的朋友们学习下。
  • 以完全通用的非类型安全方式使用指针和非托管内存的不安全方法。 NuGet 当前的NuGet软件包名称为DotNetCross.Memory.Unsafe 。 在这里能找到它: 已过时的NuGet软件包名称和URL 不幸的是,当我第一次创建nuspec ...
  • 大部分时候我们工作于c#环境中,都是在使用托管内存,然而c#毕竟运行在c++之上,有的时候,(比如可能我们需要引入一些第三方的c++或native代码的库,在Unity3d开发中很常见)我们需要直接在c#中操纵非托管的代码,...

    https://blog.csdn.net/menjiawan/article/details/48734015

    C# 托管内存与非托管内存之间的转换

    c#有自己的内存回收机制,所以在c#中我们可以只new,不用关心怎样delete,c#使用gc来清理内存,这部分内存就是managed memory,大部分时候我们工作于c#环境中,都是在使用托管内存,然而c#毕竟运行在c++之上,有的时候,(比如可能我们需要引入一些第三方的c++或native代码的库,在Unity3d开发中很常见)我们需要直接在c#中操纵非托管的代码,这些non-managed memory我们就需要自己去处理他们的申请和释放了, c# 中提供了一些接口,完成托管和非托管之间的转换,以及对这部分内存的操作

    基本上有以下几种:

    1.managed memory-> unmanaged memory

    比如在c#中调用第三方的某个c++库,库中有个函数是void func(float * data, int length).我们需要传入给data的就应该是一个非托管的代码(why?首先传入托管的内存,c#层很可能会把它gc掉,而c++还在使用,而且托管的mem它的指针地址可能会发生改变,因此直接传给c++可能拿到的地址是错误的)

    代码如下:

    using System.Runtime.InteropServices;
    float[] _managed_data  =... // this is the c# managed data
    GCHandle unmanaged_data_handle = GCHandle.Alloc(_managed_data, GCHandleType.Pinned); //这里将标记_managed_data暂时不能被gc回收,并且固定对象的地址
    func(unmanaged_data_handle.AddrOfPinnedObject(),_managed_data.Length);//这里将拿到非托管内存的固定地址,传给c++
    unmanaged_data_handle.Free();//使用完毕后,将其handle free,这样c#可以正常gc这块内存
    

    2.un-managed memory->managed memory

    在c++中返回一个un-managed mem给c#使用。有时需要在c++中分配一块处理好的内存,然后返回给c#来使用,如c++中某个接口 int func(int** data) (注意这里要使用指针的指针,因为data是得到的结果)

    IntPtr unmanaged_ptr=IntPtr.Zero; //定义这个c#中用来接收c++返回数据的指针类型
    int length = func(out unmanaged_ptr );//调用c++的函数,使unmanaged_ptr指向c++里分配的内存,注意这里用out ,才能与c++里面的**匹配。
    byte[] managed_data = new byte[length];
    Marshal.Copy(unmanaged_ptr, managed_data, 0, length);//将非托管内存拷贝成托管内存,才能在c#里面使用
    Marshal.FreeHGlobal(unmanaged_ptr);//释放非托管的内存
    

    3.在c#直接申请一个un-managed mem传给c++

    有时需要直接在c#开辟一块非托管的内存,传给c++用,这块内存同样可以在c#中用后销毁。代码如下

    IntPtr unmanaged_data_prt = Marshal. AllocHGlobal(100);// 直接分配100 byte的内存
    func(unmanaged_data_prt);//传给c++使用
    Marshal.FreeHGlobal(unmanaged_data_prt);使用后销毁非托管内存
    

    此外 Marshal类里面还有很多处理非托管内存的方法。

    备注

    托管内存和非托管内存在c#里面可以互相自由的转化,主要通过Marshal类和GCHandle类,编程时只要注意非托管的内存一定要负责好释放就可以了。

    展开全文
  • 那我们如何在Unity中调用由C++封装的dll动态库中接口时将托管内存封装到非托管内存? Marshal类为此提供了方法集合,例如StringToHGlobalAnsi方法将ANSI字符从托管堆中的指定字符串复制到非托管堆中的缓冲区。 ...

            C++代码通常被称为非托管代码,而我们在Unity中使用的C#代码会被编译成通用中间语言CIL,CIL/.Net代码通常被称为托管代码。那我们如何在Unity中调用由C++封装的dll动态库中接口时将托管内存封装到非托管内存?

            Marshal类为此提供了方法集合,例如StringToHGlobalAnsi方法将ANSI字符从托管堆中的指定字符串复制到非托管堆中的缓冲区。

            图例为C++代码封装的一个dll动态库,包含以下接口:

    public static class Socket
    {
        /// <summary>
        /// 初始化函数
        /// </summary>
        /// <param name="path">配置文件目录</param>
        /// <returns>成功返回0 否则返回错误代码</returns>
        [DllImport("HWSocket.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern int HW_Initialize(IntPtr path);
        /// <summary>
        /// 发送数据函数
        /// </summary>
        /// <param name="buf">要发送数据的缓冲区地址</param>
        /// <param name="size">要发送的数据大小 最大为900</param>
        /// <returns>成功返回0 否则返回错误代码</returns>
        [DllImport("HWSocket.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern int HW_Send(IntPtr buf, int size);
        /// <summary>
        /// 接收数据函数
        /// </summary>
        /// <param name="id">终端ID(字符串,表示接收哪一台终端的数据)</param>
        /// <param name="buf">接收数据缓冲区地址</param>
        /// <returns>读取到的数据大小 小等于0表示没有读取到数据</returns>
        [DllImport("HWSocket.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern int HW_Read(IntPtr id, IntPtr buf);
        /// <summary>
        /// 关闭函数 
        /// </summary>
        /// <returns>成功返回0 否则返回错误代码</returns>
        [DllImport("HWSocket.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern int HW_Close();
    }

            以Send函数的使用为例:

    //申请内存
    sendIntPtr = Marshal.AllocHGlobal(1024);
    //开启发送消息线程
    sendThread = new Thread(() =>
    {
        while (true)
        {
            try
            {
                //将发送队列中消息依次取出发送
                if (sendQueue.Count > 0)
                {
                    var msg = sendQueue.Dequeue();
                    sendIntPtr = Marshal.StringToHGlobalAnsi(msg);
                    Socket.HW_Send(sendIntPtr, msg.Length);
                }
            }
            catch (Exception e)
            {
                Debug.LogError($"Send Error : {e.Message}");
            }
            Thread.Sleep(0);
        }
    });
    sendThread.Start();

      欢迎关注公众号 “当代野生程序猿”

    展开全文
  • 为了解决Flink作业使用RocksDB状态后端时的内存超用问题,Flink早在1.10版本就实现了RocksDB的托管内存(managed memory)机制。用户只需启用state.backend.rocksdb.memory.managed参数(默认即为true),再设定合适的...

    前言

    为了解决Flink作业使用RocksDB状态后端时的内存超用问题,Flink早在1.10版本就实现了RocksDB的托管内存(managed memory)机制。用户只需启用state.backend.rocksdb.memory.managed参数(默认即为true),再设定合适的TaskManager托管内存比例taskmanager.memory.managed.fraction,即可满足多数情况的需要。

    关于RocksDB使用托管内存,Flink官方文档给出了一段简短的解释:

    Flink does not directly manage RocksDB’s native memory allocations, but configures RocksDB in a certain way to ensure it uses exactly as much memory as Flink has for its managed memory budget. This is done on a per-slot level (managed memory is accounted per slot).

    To set the total memory usage of RocksDB instance(s), Flink leverages a shared cache and write buffer manager among all instances in a single slot. The shared cache will place an upper limit on the three components that use the majority of memory in RocksDB: block cache, index and bloom filters, and MemTables.

    本文先简单介绍一下RocksDB(版本5.17.2)内部的Cache和Write Buffer Manager这两个组件,然后看一眼Flink是如何借助它们来实现RocksDB内存托管的。

    [LRU]Cache

    Cache组件负责管理Block Cache,在RocksDB中的实现有两种,分别对应两种常用的缓存置换算法:LRUCache和ClockCache。由于ClockCache目前仍有bug,所以在生产环境总是使用默认的LRUCache。注意Cache有压缩的和非压缩的两种,这里只考虑默认的非压缩Cache。

    LRUCache最核心的四个参数列举如下:

    • capacity:缓存的总大小。
    • num_shard_bits:按2num_shard_bits的规则确定整个缓存区域的分片(CacheShard)总数,也就是分片编号的比特数。每个CacheShard均分缓存容量,读写时,会根据key哈希值的高num_shard_bits位来确定路由。
    • strict_capacity_limit:是否严格控制单个缓存分片的容量限制,默认为false。RocksDB的Iterator在遍历数据时,会将它要读取的一部分块暂时固定在Cache内,称为Iterator-pinned blocks。如果Iterator-pinned blocks的大小超过了分片容量,再插入数据就有造成OOM的风险。开启这个参数后,超额的缓存写入就会直接失败。
    • high_pri_pool_ratio:高优先级缓存区域占整个Cache的比例。所谓高优先级缓存一般是指SST文件索引和布隆过滤器对应的块,通过cache_index_and_filter_blockscache_index_and_filter_blocks_with_high_priority参数控制。

    笔者之前讲过实现LRU缓存的经典数据结构,即哈希表+双链表(参见《手撕一个LRU Cache》)。RocksDB的LRUCache也是以这种思路为基础实现,简单的示意图如下。

    每个缓存分片LRUCacheShard都有一套哈希表+循环双链表的结构。哈希表称为LRUHandleTable,是RocksDB自己实现的链地址法分桶,且每个分片上都有互斥锁,整体与JDK中的旧版ConcurrentHashMap非常相似。哈希桶的扩容和缩容也是按照2的幂次,并且会尽量保证扁平(即每个桶中尽量只有1个元素)。

    一个低优先级指针(图中Low-Pri)用于指示低优先级区域与高优先级区域的边界。如果高优先级LRUHandle的量超过了high_pri_pool_ratio比例规定的量,就会将溢出的高优先级LRUHandle降格成低优先级。当然,淘汰LRUHandle时也是从低优先级区域开始淘汰。

    LRUHandle是LRUCache的最小单元,其key是SST文件的ID加上块在SST内的偏移量,value则是缓存的块数据(代码中为void*类型),另外还有数据大小、指针域和引用计数域等。
    为什么要有引用计数呢?因为RocksDB的实现方法与传统结构略有不同,链表中保存的并不是全部LRUHandle,而是可以被淘汰的那些LRUHandle,“可以被淘汰”的标准就是LRUHandle的引用计数为1——只有哈希表中存在,而没有外部引用者。也就是说,如果LRUHandle在链表中,那么一定在哈希表中,反之则不成立。

    Write Buffer Manager(WBM)

    顾名思义,Write Buffer Manager(以下简称WBM)是用来管理写缓存的组件。除了负责MemTable分配、Flush等细节,我们所关注的另一个作用则是追踪和控制MemTable的内存用量,它可以以两种形式生效:

    • 传入一个设定的阈值,WBM将多个列族或RocksDB实例的MemTable总大小限制在阈值内;
    • 将WBM传给Cache,可以使两者共同控制RocksDB总内存占用量的上限。

    Flink也正是利用了上述特性来实现RocksDB托管内存的。那么WBM与Cache如何协同工作?如下图所示。

    RocksDB Wiki中用了一句不符合英语语法的话来描述,即"Cost memory used in memtable to block cache",此时Block Cache的内存配额就是RocksDB全部的内存配额。

    MemTable的分配单元称为Arena Block,默认大小为8MB。每分配一个Arena Block,WBM就会将它的内存消耗向LRUCache记账——所谓“记账”就是向Cache的低优先级区域内写入Dummy LRUHandle。这些LRUHandle没有value,只有key,但携带有Arena Block的内存消耗,且每个Dummy LRUHandle代表1MB的空间。也就是说它们仅占用了逻辑配额,并未占用物理空间,并且同样受Cache的LRU规则的控制。由于MemTable本身既是读缓存也是写缓存,所以把它和Block Cache统一起来倒也合理。

    WBM控制下的MemTable Flush策略也变得更加激进了一些:

    • 当可变MemTable的大小超过WBM可用内存配额的7 / 8时,会触发Flush;
    • 当所有MemTable的大小超过内存配额,且可变MemTable的大小超过配额的一半时,也会触发Flush。

    下面来简单看看Flink是如何利用WBM和Cache的。

    To RocksDB Backend

    直接上源码,即org.apache.flink.contrib.streaming.state.RocksDBMemoryControllerUtils类。

    public class RocksDBMemoryControllerUtils {
        public static RocksDBSharedResources allocateRocksDBSharedResources(
                long totalMemorySize, double writeBufferRatio, double highPriorityPoolRatio) {
            long calculatedCacheCapacity =
                    RocksDBMemoryControllerUtils.calculateActualCacheCapacity(
                            totalMemorySize, writeBufferRatio);
            final Cache cache =
                    RocksDBMemoryControllerUtils.createCache(
                            calculatedCacheCapacity, highPriorityPoolRatio);
    
            long writeBufferManagerCapacity =
                    RocksDBMemoryControllerUtils.calculateWriteBufferManagerCapacity(
                            totalMemorySize, writeBufferRatio);
            final WriteBufferManager wbm =
                    RocksDBMemoryControllerUtils.createWriteBufferManager(
                            writeBufferManagerCapacity, cache);
    
            return new RocksDBSharedResources(cache, wbm, writeBufferManagerCapacity);
        }
    
        @VisibleForTesting
        static long calculateActualCacheCapacity(long totalMemorySize, double writeBufferRatio) {
            return (long) ((3 - writeBufferRatio) * totalMemorySize / 3);
        }
    
        @VisibleForTesting
        static long calculateWriteBufferManagerCapacity(long totalMemorySize, double writeBufferRatio) {
            return (long) (2 * totalMemorySize * writeBufferRatio / 3);
        }
    
        @VisibleForTesting
        static Cache createCache(long cacheCapacity, double highPriorityPoolRatio) {
            // TODO use strict capacity limit until FLINK-15532 resolved
            return new LRUCache(cacheCapacity, -1, false, highPriorityPoolRatio);
        }
    
        @VisibleForTesting
        static WriteBufferManager createWriteBufferManager(
                long writeBufferManagerCapacity, Cache cache) {
            return new WriteBufferManager(writeBufferManagerCapacity, cache);
        }
    
        static long calculateRocksDBDefaultArenaBlockSize(long writeBufferSize) {
            long arenaBlockSize = writeBufferSize / 8;
    
            // Align up to 4k
            final long align = 4 * 1024;
            return ((arenaBlockSize + align - 1) / align) * align;
        }
    
        static long calculateRocksDBMutableLimit(long bufferSize) {
            return bufferSize * 7 / 8;
        }
    
        @VisibleForTesting
        static boolean validateArenaBlockSize(long arenaBlockSize, long mutableLimit) {
            return arenaBlockSize <= mutableLimit;
        }
    }

    其中的writeBufferRatio就是state.backend.rocksdb.write-buffer-ratio参数,表示MemTable占托管内存(即Block Cache)的比例,默认0.5。同理,highPriorityPoolRatio就是state.backend.memory.high-prio-pool-ratio参数,表示高优先级内存占托管内存的比例,默认0.1。

    托管内存在TaskManager的Slot之间平均分配,每个Slot都会有一组Cache和WBM。需要特别注意,实际的Cache和WBM配额是:

    cache_capacity =  (3 - write_buffer_ratio) * total_memory_size / 3
    write_buffer_manager_capacity = 2 * total_memory_size * write_buffer_ratio / 3

    也就是说,如果TM总的托管内存的大小是3GB,默认比例下的Block Cache大小其实是2.5GB,MemTable配额其实是1GB,都略偏小一些。这是因为FLINK-15532尚未解决,strict_capacity_limit在Flink的场景下暂时不能生效,所以要留出一部分缓冲。推算的依据就是上一节提到的MemTable Flush策略,具体的关系如下:

    write_buffer_manager_memory = 1.5 * write_buffer_manager_capacity
    write_buffer_manager_memory = total_memory_size * write_buffer_ratio
    write_buffer_manager_memory + other_part = total_memory_size
    write_buffer_manager_capacity + other_part = cache_capacity

    The End

    写的很潦草,就这样吧。

    下班跑路,民那晚安。

    展开全文
  • Unity 托管内存(Managed Memory)

    千次阅读 2019-02-21 19:57:20
    有关分析托管内存和如何优化内存的更多信息,请参阅了解 Unity 中的理解优化部分。 一、Assets 资产在运行时引起本机内存和托管内存隐含。 在用户终止应用程序之前,Unity 运行时不会将托管内 存返回到操作系统进行...
  • 佩格洛特 自托管内存中的PEG解析器生成器。
  • :dna: Conari引擎代表了一个强大的平台,可与非托管内存,pe模块,相关的PInvoke功能一起使用,并且还可以用于以下方面:库,可执行模块,.NET世界中非托管本机C / C ++的使用以及其他原始二进制数据。 甚至完全不...
  • c#关于非托管内存的释放问题

    千次阅读 2019-04-08 23:00:49
    背景:近期在做大华工业相机SDK的采集的时候,用到Marshal.copy,将托管的代码转换成非托管的指针内存,由于没有及时释放内存指针,导致pc的内存一直上涨,通过查看代码之后发现是因为内存指针的原因,所以使用...
  • 单个头文件进行c#转换 无法计算有意义的大小或偏移量 UnmanagedType.ByValArray 自定义类型,使用struct 结构体定义 [MarshalAs(UnmanagedType.ByValTStr 定义string成员 MarshalAs,char中文转换容易出现内存错误...
  • 一个病人住院太久,一次性打印护理表单超过3000条时报如标题所示的错误, 个人查阅分析应该可以从如下几方面入手: 一:查看程序客户端和服务端...三、其实最主要原因应该是数据过大导致内存不够,关于内存方面的...
  • c#有自己的内存回收机制,所以在c#中我们可以只new,不用关心怎样delete,c#使用gc来清理内存,这部分内存就是managed memory,大部分时候我们工作于c#环境中,都是在使用托管内存,然而c#毕竟运行在c++之上,有的...
  • c#有自己的内存回收机制,所以在c#中我们可以只new,不用关心怎样delete,c#使用gc来清理内存,这部分内存就是managed memory,大部分时候我们工作于c#环境中,都是在使用托管内存,然而c#毕竟运行在c++之上,有的...
  • 如果没有手动释放内存,会有内存溢出; 发生OutOfMemoryException 没有足够的内存继续执行程序时引发的异常。 调用Marshal.AllocHGlobal必须调用 Marshal.FreeHGlobal(ptr);来手动释放内存,即使调用GC.Collect...
  • C# 申请非托管内存

    2018-02-08 13:27:00
    方式一:使用 stackalloc 关键字 int* block = stackalloc int[100]; 注:此关键字仅在局部变量初始值设定项中有效。 以下代码导致编译器错误。 int* block; // The following assignment statement causes ...
  • Marshal类支持从托管内存空间复制数据到非托管内存空间 Marshal类支持从托管内存空间复制数据到非托管内存空间,或是从非托管内存空间到托管内存空间。如果你研究在线的MSDN文档库,你会看到在桌面.NET...
  • 主要是为了解决可以实现托管代码调用非托管代码过程中,非托管代码内存泄露(无源代码,无法修改)导致的主程序奔溃,而控制台程序则可以针对非托管代码再次封装,处理内存泄露异常。 WinFormInvoke为调用主程序,...
  • VB.NET中指针和非托管内存的应用

    千次阅读 2015-08-24 09:56:12
    介绍 Visual Basic 从来不像在C或C++里一样灵活的操纵指针和原始内存。... 这些structures 和classes 允许你在托管和非托管环境中进行交互。本文中,我 将向您展示如何使用这些structures 和 classes
  • 托管堆”是由项目脚本运行时(Mono 或 IL2CPP)的内存管理器自动管理的一段内存。必须在托管堆上分配托管代码中创建的所有对象(2)(__注意:__严格来说,必须在托管堆上分配所有非 null 引用类型对象和所有装箱值...
  • 这标题或许有些大,叫做“CSharp非托管内存拷贝转换数据”之类的也许更贴近本文主题。考虑到本文有扩展的可能,就先这样子吧!本篇的内容主要包括: 1、简介 2、利用非托管内存转换基本类型数组1、简介 C#专门提供了...
  • c#内存检测工具-----

    2020-12-18 15:37:07
    c#内存检测工具-----
  • Delphi 10.3 Rio 将在语言中添加内联变量。Marco 在介绍该概念的博客文章中提到了各 种好处(http://blog.marcocantu.com/blog/2018-october-inline-variables-delphi.html),此外...联变量还可以潜在地提高代码的性能。
  • 托管资源与非托管资源 “非托管资源”指的是不受.net垃圾回收器控制的资源。比如打开一个数据库连接,所访问的数据库资源来源于服务器而不受.net控制。或者是客户机上其他非.net资源,资源的提供者不是通过托管代码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 92,688
精华内容 37,075
关键字:

托管内存

友情链接: today_c#.zip