在 Haskell 和 C 之间交换结构化数据

Question

首先，我是 Haskell 初学者。

我计划将 Haskell 集成到 C 中以实现实时游戏。 Haskell 负责逻辑，C 负责渲染。为此，我必须在每次更新之间相互传递大量复杂的结构化数据（游戏状态）（每秒至少 30 次）。所以传递的数据应该是轻量级的。该状态数据可以放置在存储器上的连续空间上。 Haskell 和 C 部分都应该可以自由访问各州的每个区域。

在最好的情况下，传递数据的成本可能是将指针复制到内存。在最坏的情况下，复制整个数据并进行转换。

我正在阅读 Haskell 的 FFI(http://www.haskell.org/haskellwiki/FFICookBook#Working_with_structs< /a>) Haskell 代码看起来明确指定了内存布局。

我有几个问题。

1. Haskell 可以显式指定内存布局吗？ （与C结构体完全匹配）
2. 这是真正的内存布局吗？或者需要任何类型的转换？ （性能损失）
3. 如果 Q#2 为真，那么显式指定内存布局时是否会产生性能损失？
4. #{alignment foo} 的语法是什么？我在哪里可以找到有关此内容的文档？
5. 如果我想以最佳性能传递大量数据，我应该怎么做？

*附注 我所说的显式内存布局功能只是 C# 的 [StructLayout] 属性。这是明确指定内存中的位置和大小。 http://www.developerfusion.com/article/84519/mastering- structs-in-c/

我不确定 Haskell 是否有与 C 结构体字段相匹配的语言结构。

Answer 1

我强烈建议使用预处理器。我喜欢 c2hs，但 hsc2hs 很常见，因为它包含在 ghc 中。绿卡似乎被放弃了。

回答您的问题：

1）是的，通过Storable实例的定义。使用 Storable 是通过 FFI 传递数据的唯一安全机制。 Storable 实例定义如何在 Haskell 类型和原始内存（Haskell Ptr、ForeignPtr、StablePtr 或 C 指针）之间编组数据。下面是一个示例：

data PlateC = PlateC {
  numX :: Int,
  numY :: Int,
  v1   :: Double,
  v2   :: Double } deriving (Eq, Show)

instance Storable PlateC where
  alignment _ = alignment (undefined :: CDouble)
  sizeOf _ = {#sizeof PlateC#}
  peek p =
    PlateC <
gt; fmap fI ({#get PlateC.numX #} p)
           <*> fmap fI ({#get PlateC.numY #} p)
           <*> fmap realToFrac ({#get PlateC.v1 #} p)
           <*> fmap realToFrac ({#get PlateC.v2 #} p)
  poke p (PlateC xv yv v1v v2v) = do
    {#set PlateC.numX #} p (fI xv)
    {#set PlateC.numY #} p (fI yv)
    {#set PlateC.v1 #}   p (realToFrac v1v)
    {#set PlateC.v2 #}   p (realToFrac v2v)

{# ... #} 片段是 c2hs 代码。 fI 是 fromIntegral。 get 和 set 片段中的值引用包含标头中的以下结构，而不是同名的 Haskell 类型：

struct PlateCTag ;

typedef struct PlateCTag {
  int numX;
  int numY;
  double v1;
  double v2;
} PlateC ;

c2hs 将其转换为以下普通 Haskell：

instance Storable PlateC where
  alignment _ = alignment (undefined :: CDouble)
  sizeOf _ = 24
  peek p =
    PlateC <
gt; fmap fI ((\ptr -> do {peekByteOff ptr 0 ::IO CInt}) p)
           <*> fmap fI ((\ptr -> do {peekByteOff ptr 4 ::IO CInt}) p)
           <*> fmap realToFrac ((\ptr -> do {peekByteOff ptr 8 ::IO CDouble}) p)
           <*> fmap realToFrac ((\ptr -> do {peekByteOff ptr 16 ::IO CDouble}) p)
  poke p (PlateC xv yv v1v v2v) = do
    (\ptr val -> do {pokeByteOff ptr 0 (val::CInt)}) p (fI xv)
    (\ptr val -> do {pokeByteOff ptr 4 (val::CInt)}) p (fI yv)
    (\ptr val -> do {pokeByteOff ptr 8 (val::CDouble)})   p (realToFrac v1v)
    (\ptr val -> do {pokeByteOff ptr 16 (val::CDouble)})   p (realToFrac v2v)

偏移量当然取决于体系结构，因此使用预定义处理器允许您编写可移植的代码。

您可以通过为数据类型（new、malloc 等）分配空间并将数据poke放入 Ptr（或foreignPtr）来使用它。 ）。

2）这才是真正的内存布局。

3) 使用peek/poke进行读/写会受到惩罚。如果您有大量数据，最好只转换您需要的数据，例如仅从 C 数组中读取一个元素，而不是将整个数组编组到 Haskell 列表。

4) 语法取决于您选择的预处理器。 c2hs 文档。 hsc2hs 文档。令人困惑的是，hsc2​​hs 使用语法 #stuff 或 #{stuff}，而 c2hs 使用 {#stuff #}。

5）@sclv的建议也是我会做的。编写一个 Storable 实例并保留指向数据的指针。您可以编写 C 函数来完成所有工作并通过 FFI 调用它们，或者（不太好）使用 peek 和 poke 编写低级 Haskell 来仅对您需要的数据部分进行操作。来回编组整个事情（即在整个数据结构上调用peek或poke）将是昂贵的，但如果您只传递指针，则成本将是最小的。

通过 FFI 调用导入函数会受到严重惩罚，除非它们被标记为“不安全”。声明导入“不安全”意味着该函数不应回调到 Haskell 或未定义的行为结果。如果您使用并发或并行性，这也意味着相同功能（即 CPU）上的所有 Haskell 线程将阻塞，直到调用返回，因此它应该相当快地返回。如果这些条件可以接受，“不安全”调用相对较快。

Hackage 上有很多处理此类事情的软件包。我可以推荐 hsndfile 和 hCsound 展示了 c2hs 的良好实践。如果您查看与您熟悉的小型 C 库的绑定，可能会更容易。

Answer 2

尽管您可以获得严格的未装箱 Haskell 结构的确定性内存布局，但没有任何保证，这确实是一个非常糟糕的主意。

如果您愿意接受转换，可以使用 Storeable：http://www.haskell.org/ghc/docs/6.12.3/html/libraries/base-4.2.0.2/Foreign-Storable.html

我会做什么构造 C 结构，然后构造使用 FFI 直接对其进行操作的 Haskell 函数，而不是尝试生成与它们“等价”的 Haskell 函数。

或者，您可以决定只需要向 C 传递选定的信息 - 不是整个游戏状态，而只是关于对象在世界上的位置的一些信息，以及关于如何进行操作的实际信息。画出他们只生活在等式的C端。然后，您在 Haskell 中执行所有逻辑，对本机 Haskell 结构进行操作，并且仅将 C 实际需要渲染的数据的微小子集投影到 C 世界。

编辑：我应该补充一点，矩阵和其他常见的 c 结构已经拥有出色的库/绑定，可以将繁重的工作保持在 c 端。

Answer 3

hsc2hs，c→hs 和 Green Card 都提供自动化的 Haskell⇆C 结构 peek/poke 或编组。我建议使用它们，而不是手动确定大小和偏移量以及在 Haskell 中使用指针操作，尽管这也是可能的。

1. 据我所知，如果我没理解错的话。 Haskell 没有任何对外部聚合数据结构的内置处理。
2.  
3.  
4. 正如该页面所描述的，它是带有一些 C 魔法的 hsc2hs。