在 `unsafeDupablePerformIO` 中分配内存是否安全？

Question

假设我有一个外部函数：

-- | Turns char* of the given size into a char* of size 16.
doSomethingFfi :: Ptr CUChar -> Ptr CUChar -> CSize -> IO ()
doSomethingFfi = undefined

函数是纯函数，所以我想在 Haskell 中将其表示为纯函数：

doSomething :: ByteArray bytes => bytes -> bytes
doSomething bs = unsafePerformIO $
  alloc 16 $ \outPtr ->
  withByteArray bs $ \inPtr ->
    doSomethingFfi outPtr inPtr (fromIntegral $ length bs)

（这里我使用来自memory的alloc。）

我的理解是unsafePerformIO和unsafeDupablePerformIO之间的唯一区别是后者中的IO操作可以在不进行任何清理的情况下静默终止。

在我上面的例子中，基本上发生了两个 IO 操作： 1. 内存分配； 2.外呼。我不关心2，因为它是纯粹的，但是我担心内存。

如果计算被静默中断，是否可以保证以这种方式分配的内存不会泄漏？如果外部函数还需要我必须分配/清理的临时存储并且我为此使用了alloca，那么使用unsafeDupablePerformIO 是否仍然安全？

Answer 1

大部分是我在 cmets 中解释的，但不完全是：

alloca

由于当前已实施alloca，因此这是安全的。 alloca 是通过调用allocaBytesAligned 来实现的，其定义如下：

allocaBytesAligned :: Int -> Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned (I# size) (I# align) action = IO $ \ s0 ->
     case newAlignedPinnedByteArray# size align s0 of { (# s1, mbarr# #) ->
     case unsafeFreezeByteArray# mbarr# s1 of { (# s2, barr#  #) ->
     let addr = Ptr (byteArrayContents# barr#) in
     case action addr     of { IO action' ->
     case action' s2      of { (# s3, r #) ->
     case touch# barr# s3 of { s4 ->
     (# s4, r #)
  }}}}}

这会在垃圾收集堆中分配固定内存。如果您的操作提前中止，那么垃圾收集器迟早会回收它分配的内存。

alloc

这不一定安全，但实际上可能是安全的。 alloc 是使用类方法allocRet 定义的，不同类型可以不同地实现。

与我在 cmets 中的猜测相反，memory 中定义的实例似乎都很好——它们也分配了固定内存。但是该类没有将此记录为要求，原则上有人可以使用Foreign.Marshall.Alloc.malloc 分配内存，在这种情况下垃圾收集器不会自动处理内存。如果计算提前中止，这样的假设实现将无法确保释放内存。