Question

我用Google搜索并获得了一些答案，可以通过GCJNI（现在网站已关闭）和LambdaVM完成Java和Haskell之间的通信。要使用LambdaVM / GCJNI，我是否需要下载任何构建工具？我在哪里可以了解更多关于它们的信息，因为我在网上找不到太多资源？

我想开发一个在Java和Haskell之间进行通信的应用程序（我将从Java获取输入将其传递给Haskell并在那里处理并将结果返回给Java）。这就是我想要做的。请帮帮我......

Answer 1

Calling Haskell from C看起来非常简单，因此也可以使用JavaCPP从Java轻松调用。例如，要从示例代码fibonacci_hs()调用Safe.hs函数：

{-# LANGUAGE ForeignFunctionInterface #-}

module Safe where

import Foreign.C.Types

fibonacci :: Int -> Int
fibonacci n = fibs !! n
    where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

fibonacci_hs :: CInt -> CInt
fibonacci_hs = fromIntegral . fibonacci . fromIntegral

foreign export ccall fibonacci_hs :: CInt -> CInt

我们可以通过Java这样做：

import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;

@Platform(include={"<HsFFI.h>","Safe_stub.h"})
public class Safe {
    static { Loader.load(); }
    public static native void hs_init(int[] argc, @Cast("char***") @ByPtrPtr PointerPointer argv);
    public static native int fibonacci_hs(int i);
    public static void main(String[] args) {
        hs_init(null, null);
        int i = fibonacci_hs(42);
        System.out.println("Fibonacci: " + i);
    }
}

在Linux下，编译过程如下所示：

$ ghc -fPIC -dynamic -c -O Safe.hs
$ javac -cp javacpp.jar Safe.java
$ java -jar javacpp.jar -Dplatform.compiler=ghc -Dplatform.compiler.output="-optc-O3 -Wall Safe.o -dynamic -fPIC -shared -lstdc++ -lHSrts-ghc7.6.3 -o " -Dplatform.linkpath.prefix2="-optl -Wl,-rpath," Safe

程序使用通常的java命令正常运行：

$ java -cp javacpp.jar:. Safe
Fibonacci: 267914296

<小时/> 编辑：我冒昧地对调用开销做了一些微基准测试。使用以下C头文件Safe.h：

inline int fibonacci_c(int n) {
    return n < 2 ? n : fibonacci_c(n - 1) + fibonacci_c(n - 2);
}

以下Java类：

import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;

@Platform(include={"<HsFFI.h>","Safe_stub.h", "Safe.h"})
public class Safe {
    static { Loader.load(); }
    public static native void hs_init(int[] argc, @Cast("char***") @ByPtrPtr PointerPointer argv);
    public static native int fibonacci_hs(int i);
    public static native int fibonacci_c(int n);
    public static int fibonacci(int n) {
        return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
    }
    public static void main(String[] args) {
        hs_init(null, null);

        for (int i = 0; i < 1000000; i++) {
            fibonacci_hs(0);
            fibonacci_c(0);
            fibonacci(0);
        }
        long t1 = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            fibonacci_hs(0);
        }
        long t2 = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            fibonacci_c(0);
        }
        long t3 = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            fibonacci(0);
        }
        long t4 = System.nanoTime();
        System.out.println("fibonacci_hs(0): " + (t2 - t1)/1000000 + " ns");
        System.out.println("fibonacci_c(0): "  + (t3 - t2)/1000000 + " ns");
        System.out.println("fibonacci(0): "    + (t4 - t3)/1000000 + " ns");
    }
}

使用Intel Core i7-3632QM CPU @ 2.20GHz，Fedora 20 x86_64，GCC 4.8.3，GHC 7.6.3和OpenJDK 8输出：

fibonacci_hs(0): 200 ns
fibonacci_c(0): 9 ns
fibonacci(0): 2 ns

平心而论，我应该提到将调用 JVM也是相当昂贵的......

<小时/> 更新：With recent changes to JavaCPP，用户现在可以通过C / C ++中的名称访问回调函数（指针），从而可以轻松地从Haskell调用JVM。例如，根据wiki page regarding Haskell's FFI上的信息，将以下代码放在Main.hs中：

{-# LANGUAGE ForeignFunctionInterface #-}
module Main where

import Foreign.C -- get the C types
import Foreign.Ptr (Ptr,nullPtr)

-- impure function
foreign import ccall "JavaCPP_init" c_javacpp_init :: CInt -> Ptr (Ptr CString) -> IO ()
javacpp_init :: IO ()
javacpp_init = c_javacpp_init 0 nullPtr

-- pure function
foreign import ccall "fibonacci" c_fibonacci :: CInt -> CInt
fibonacci :: Int -> Int
fibonacci i = fromIntegral (c_fibonacci (fromIntegral i))

main = do
  javacpp_init
  print $ fibonacci 42

以及用Java定义的fibonacci函数：

import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;

@Platform
public class Main {
    public static class Fibonacci extends FunctionPointer {
        public @Name("fibonacci") int call(int n) {
            return n < 2 ? n : call(n - 1) + call(n - 2);
        }
    }
}

我们可以在Linux x86_64下构建类似的东西：

$ javac -cp javacpp.jar Main.java
$ java -jar javacpp.jar Main -header
$ ghc --make Main.hs linux-x86_64/libjniMain.so

并且程序正确执行此输出：

$ ./Main
267914296

Answer 2

如果您选择Haskell服务器进程方法，则可以使用 MessagePack 序列化/ rpc库。它具有Java和Haskell的绑定，并且Haskell绑定似乎得到了很好的维护。在Hackage上寻找 msgpack 和 msgpack-rpc 。

这是使用MessagePack进行Java / Haskell交互的玩具示例：Java server，Haskell client（链接转到GitHub）。但是，沟通与你想要的方向相反。

Answer 3

这取决于您希望他们如何沟通。让Java和Haskell代码在同一个进程中本地运行并通过各自的FFI在内存中交换数据是一个巨大的问题，尤其是因为你有两个GCs争夺数据，两个编译器都有自己的代表想法各种数据类型。在JVM下编译Haskell同样很困难，因为JVM（目前）没有任何闭包概念。

当然可以做这些事情，但从演示者到工业工具需要付出巨大努力。我的理解是，你提到的工具从未进入过示范阶段。

一个更简单（如果不太优雅）的解决方案是将Haskell程序编写为服务器进程，该进程通过Java上的套接字发送数据。如果性能和体积不是太高，那么用JSON编写它可能很简单，因为双方都有库来支持它。

Answer 4

TL; DR：使用消息传递（即RPC客户端 - 服务器或对等方）模式。

为什么？它更安全，可扩展，灵活且可调试。打电话给FFI将是脆弱的，难以测试。

RPC框架/规范

gRPC Google的Protobufs RPC over HTTP / 2的公共分支
- unofficial Haskell gRPC bindings
msgpack-rpc 不包含传输。
zerorpc ZeroMQ + msgpack。只有Python和Node实现。似乎也放弃了。
XML-RPC 成熟。广泛的互操作性，但它也是XML。
JSON-RPC 更易于调试。不是二进制协议，虽然BSON可能侵入某些库。

<强>序列化

协议缓冲区（protobufs）有许多工具比其他工具更多。它支持版本化/可选数据成员，这些成员不需要重新编译（或破坏）世界进行互操作。
msgpack 可爱，简单，高效，但它不支持向前兼容的架构更改。它纯粹是一个愚蠢的二进制编解码器。实际使用可能过于简单和低级。

<强>输送

ZeroMQ 可能是最快的，非Infiniband / FC / 10 GbE，非线程安全的邮件传输。
Nanomsg 从其创始人之一重新构想ZeroMQ的更新，线程安全的UNIX哲学。
HTTP / 2 （由gRPC使用）这里的优点是它是在数据中心内部和之间工作的标准，并且还具有TLS（gRPC本机代码使用BoringSSL，Google＆＃39; s＆＃34;更安全＆＃34; OpenSSL fork）。
MQTT 当您需要为十亿台设备实施推送通知并使用人类可读的协议时。

Java和Haskell之间的通信

4 个答案: