blocks|key|2319256|text|理解指针何时变得未被引用并不是一件容易的事。据我所知，没有办法执行您的请求，即通知GC指针现在不再可达。充其量，一个人可以触发GC周期，但没有硬保证。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2319257|根据您的描述，您可能更喜欢引用计数机制，而不是垃圾收集。然而，特别是在复杂的纯代码中，很难识别计数器应该递增或递减的点:在状态或基于IO的monad中，这将更容易，其中这些副作用被适当地排序w.r.t.计算的其余部分。|2319258|如果你真的不需要“1”以外的引用计数，一种常见的习惯用法是使用with-style函数来处理分配和释放。这可能会变得有点棘手，无法正确处理。|offset|length|style|CODE|2319259|例如，一个简单的实现可能是|2319260|--+very+simplified+code
withMyResource+::+(ResourcePtr+->+IO+r)+->+IO+r
withMyResource+action+=+do
+++p+<-+allocResourcePtr
+++result+<-+action+p
+++deallocResourcePtr+p
+++return+result|code-block|syntax|javascript|2319261|然后，可以将其用作|2319262|withResource+$+\ptr+->+do
+++use+ptr|2319263|请注意，这并不是完全安全的，因为可能会返回指针，使其在释放后仍然有效|2319264|ptr+<-+withResource+return
use+ptr+--+dangerous!|2319265|正确的指针处理例程应该像ST+monad及其标记的STRef一样工作，它们的设计目的是防止指针超出其预期的作用域(如上所述)。这利用了rank-2类型，但很有效。|2319266|尽管如此，人们仍然可以接受简单的with例程，只是要小心不要让指针外泄。|2319267|另一个不安全的问题是action能够抛出异常。(这可以使用库中的bracket-like例程来处理)。|2319268|entityMap^0|0|0|V|4|0|0|0|0|0|0|0|C|2|P|5|0|G|4|0|A|6|W|7|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@$F|19|G|1A|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1B|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1C|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|1E|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|X|5|N|7|1G|8|@]|9|@]|A|$O|P]]|$1|Y|3|Z|5|6|7|1H|8|@$F|1I|G|1J|H|I]|$F|1K|G|1L|H|I]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1M|8|@$F|1N|G|1O|H|I]]|9|@]|A|$]]|$1|12|3|13|5|6|7|1P|8|@$F|1Q|G|1R|H|I]|$F|1S|G|1T|H|I]]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|15|$]]

Understanding when a pointer becomes unreferenced is not trivial. 
As far as I know, there is no way to perform what you request, namely inform the GC that a pointer is now no longer reachable. At best, one can trigger a GC cycle, but there are no hard guarantees.

From your description, you probably would prefer a reference-counting mechanism instead of garbage collection. However, especially in complex pure code, it is hard to identify the points where the counter should be incremented or decremented: it would be easier in a state or IO-based monad where such side effects are properly sequenced w.r.t. the rest of the computation.

If you don't really need reference counting beyond "one", a somehow common idiom is using a <code>with</code>-style function for handling the allocation and deallocation. 
This can get a bit tricky to handle correctly.

For instance, a trivial implementation could be

<pre><code>-- very simplified code
withMyResource :: (ResourcePtr -&gt; IO r) -&gt; IO r
withMyResource action = do
 p &lt;- allocResourcePtr
 result &lt;- action p
 deallocResourcePtr p
 return result
</code></pre>

This can then be used as

<pre><code>withResource $ \ptr -&gt; do
 use ptr
</code></pre>

Note that this is not completely safe, since one might return the pointer, making it live after its deallocation

<pre><code>ptr &lt;- withResource return
use ptr -- dangerous!
</code></pre>

A properly pointer-handling routine should work like the <code>ST</code> monad and its tagged <code>STRef</code>s, which are designed so to prevent pointers to escape their intended scope (as done above). This exploits rank-2 types, but is effective.

Still, one can live with the naive <code>with</code> routine, and just be careful to not let pointers escape.

Another unsafety issue is caused by <code>action</code> being able to throw exceptions. (This can be handled using <code>bracket</code>-like routines from the library).

blocks|key|1865212|text|在运行GC之前，RTS不知道是否有任何数据未被引用。GHC没有引用计数GC，这将允许对垃圾立即采取行动。您可以尝试自己实现引用计数，或者使用System.Mem中的手动GC。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1865213|在Haskell-land中不跟踪国外分配。如果您想要更多控制，但没有自定义GC或引用计数，则可以使用Foreign.Marhsal.Array进行手动/作用域分配和释放。|1865214|另一种选择是在GHC+RTS中使用固定分配。这为您提供了不被GC移动的内存。对固定数据的引用可以在没有开销的情况下传递给外部代码，但是固定数据是被跟踪的，可以是GC-d，并且触发GC的方式与通常的堆数据相同。用于固定数据的Here's+one+API。另一种选择是简单的ByteString。固定数据的可能缺点是内存碎片和较慢的分配，但这也适用于(任何)返回稳定指针的外部分配。|1865215|entityMap|0|LINK|mutability|MUTABLE|url|https://hackage.haskell.org/package/base-4.10.1.0/docs/System-Mem.html|1|https://hackage.haskell.org/package/base-4.10.1.0/docs/Foreign-Marshal-Array.html|2|https://hackage.haskell.org/package/primitive-0.6/candidate/docs/Data-Primitive-ByteArray.html|3|https://hackage.haskell.org/package/bytestring-0.10.8.2/docs/Data-ByteString.html^0|1Y|A|1Y|A|0|0|1F|L|1F|L|1|0|3R|A|33|6|2|3R|A|3|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|H|3|I|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@$9|1C|A|1D|1|1E]|$9|1F|A|1G|1|1H]]|E|$]]|$1|J|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]|T|$5|M|N|O|E|$P|U]]|V|$5|M|N|O|E|$P|W]]]]

The RTS has no idea whether any piece of data is unreferenced until GC is run. GHC does not have reference counting GC, which would allow immediate action on garbage. You could try to implement reference counting yourself, or use manual GC from <a href="https://hackage.haskell.org/package/base-4.10.1.0/docs/System-Mem.html" rel="nofollow noreferrer"><code>System.Mem</code></a>.

Foreign allocation isn't tracked in Haskell-land. If you want more control, but no custom GC or reference counting, you can use e. g. <a href="https://hackage.haskell.org/package/base-4.10.1.0/docs/Foreign-Marshal-Array.html" rel="nofollow noreferrer"><code>Foreign.Marhsal.Array</code></a> for manual/scoped allocation and deallocation.

Another option is to use pinned allocation in GHC RTS. This gives you memory which is not moved by GC. References to pinned data can be passed to foreign code without overhead, but pinned data is tracked, can be GC-d, and triggers GC the same way as usual heap data does. <a href="https://hackage.haskell.org/package/primitive-0.6/candidate/docs/Data-Primitive-ByteArray.html" rel="nofollow noreferrer">Here's</a> one API for pinned data. Another choice is simply <a href="https://hackage.haskell.org/package/bytestring-0.10.8.2/docs/Data-ByteString.html" rel="nofollow noreferrer"><code>ByteString</code></a>. The possible drawback of pinned data is memory fragmentation and slower allocation, but that also holds for (any) foreign allocation which returns stable pointers.

When I allocate some data via FFI and associate a finalizer with it, I get a <code>ForeignPtr</code> in Haskell. When this pointer becomes unreferenced, GC collects the pointer, which causes finalizer to run. But the collecting only happens when GC has run and "unreferencing" doesn't force GC to run. I.e. there can be many pointers lying around, but since pointers themselves do not occupy much memory, RTS simply doesn't see a reason to start GC, because the size of foreign data is not tracked by the RTS, according to my <a href="https://github.com/effectfully/haskell-ffi-example/blob/f7837c4304442a3b595caf0533dae1d47a78ab66/src/Main.hs#L28" rel="nofollow noreferrer">investigations</a>. Is this correct?

How do I communicate "when this pointer becomes unreferenced, collect it immediately" to the RTS? Are there any flags that allow to control when to start GC? Is this a problem for a real program (as any real program always has enough explicit garbage to stimulate GC)?

Foreign data and garbage collection

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

当我通过FFI分配一些数据并将终结器与其关联时，我在Haskell中得到了一个ForeignPtr。当该指针变为未引用时，GC将收集该指针，这会导致终结器运行。但收集仅在GC运行时发生，并且“取消引用”不会强制GC运行。也就是说，可以有许多指针，但由于指针本身不占用太多内存，RTS根本看不到启动GC的理由，因为根据我的...

问外部数据和垃圾收集
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问外部数据和垃圾收集EN