ruby - 如何使用 Go 共享库在 Ruby 中传递字符串数组并获取字符串数组？

Question

我正在尝试从 Ruby 调用 Go 项目。当我传递一个字符串并取回一个字符串时，它确实工作得很好：

去：

package main

import "C"
import (
    "fmt"

    "gitlab.com/gogna/gnparser"
)

//export ParseToJSON
func ParseToJSON(name *C.char) *C.char {
    goname := C.GoString(name)
    gnp := gnparser.NewGNparser()
    parsed, err := gnp.ParseAndFormat(goname)
    if err != nil {
        fmt.Println(err)
        return C.CString("")
    }
    return C.CString(parsed)
}

func main() {}

我用它编译

go build -buildmode=c-shared -o libgnparser.so main.go

红宝石：

require 'ffi'

# test
module GNparser
  extend FFI::Library
  if Gem.platforms[1].os == 'darwin'
      ffi_lib './clib/mac/libgnparser.so'
  else
      ffi_lib './clib/linux/libgnparser.so'
  end
  attach_function :ParseToJSON, [:string], :string
end

puts GNparser.ParseToJSON("Homo sapiens L.")

对于这样的示例，如何将 Ruby 字符串数组传递给 Go 并取回字符串数组？（Go项目中有一个方法可以并行处理这样的数组）

标签： rubygoffi

Answer 1

这里的主要问题是流程中有两个不同的运行时，Ruby 和 Go，而且它们都不像其他人那样在其内部进行探索。因此，为了从 Ruby 调用 Go，您必须首先从 Ruby 中获取数据，然后进入 Go，然后从 Go 中获取结果，然后再进入 Ruby。实际上，即使没有实际的 C 代码，您也必须通过 C 从 Ruby 转到 Go。

从 Go 方面开始，假设您要使用的函数具有如下签名：

func TheFunc(in []string) []string

您可以将其导出到您的共享库中，这将给出以下 C 签名：

extern GoSlice TheFunc(GoSlice p0);

GoSlice在哪里

typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;

虽然这可能有效，但它可以直接访问 Go 数据，尤其是返回值，因此并不安全。

一个解决方案是提供一个包装函数，它接受一个指向 C 字符串数组的指针（即**char）和数组的长度。然后该函数可以解包这些数据并将其转换为 Go 数组（或切片）并将其传递给执行该工作的真正函数。这个包装函数还需要一种获取结果的方法。一种方法是传入一个指向字符串数组（即***char）的指针的指针，该函数可以分配数组，用结果字符串填充它，并将其地址写入该指针指向的位置。

这种解决方案的缺点是在 Go 中分配内存并依赖调用代码来释放它。

这有点混乱，但它看起来像这样：

// #include <stdlib.h>
import "C"
import "unsafe"

//export CTheFunc
func CTheFunc(in **C.char, len C.int, out ***C.char) {

    inSlice := make([]string, int(len))

    // We need to do some pointer arithmetic.
    start := unsafe.Pointer(in)
    pointerSize := unsafe.Sizeof(in)

    for i := 0; i< int(len); i++ {
        // Copy each input string into a Go string and add it to the slice.
        pointer := (**C.char)(unsafe.Pointer(uintptr(start) + uintptr(i)*pointerSize))
        inSlice[i] = C.GoString(*pointer)
    }

    // Call the real function.
    resultSlice := TheFunc(inSlice)

    // Allocate an array for the string pointers.
    outArray := (C.malloc(C.ulong(len) * C.ulong(pointerSize)))

    // Make the output variable point to this array.
    *out = (**C.char)(outArray)

    // Note this is assuming the input and output arrays are the same size.
    for i := 0; i< int(len); i++ {
        // Find where to store the address of the next string.
        pointer := (**C.char)(unsafe.Pointer(uintptr(outArray) + uintptr(i)*pointerSize))
        // Copy each output string to a C string, and add it to the array.
        // C.CString uses malloc to allocate memory.
        *pointer = C.CString(resultSlice[i])
    }

}

这提供了一个具有以下签名的 C 函数，我们可以使用 FFI 从 Ruby 访问该函数。

extern void CDouble(char** p0, int p1, char*** p2);

Ruby 方面非常相似，但相反。我们需要将数据复制到 C 数组中，并分配一些内存，我们可以传递地址来接收结果，然后将数组、其长度和输出指针传递给 Go 函数。当它返回时，我们需要将 C 数据复制回 Ruby 字符串和数组并释放内存。它可能看起来像这样：

require 'ffi'

# We need this to be able to use free to tidy up.
class CLib
  extend FFI::Library
  ffi_lib FFI::Library::LIBC
  attach_function :free, [:pointer], :void
end

class GoCaller
  extend FFI::Library
  ffi_lib "myamazinggolibrary.so"
  POINTER_SIZE = FFI.type_size(:pointer)

  attach_function :CTheFunc, [:pointer, :int, :pointer], :void

  # Wrapper method that prepares the data and calls the Go function.
  def self.the_func(ary)
    # Allocate a buffer to hold the input pointers.
    in_ptr = FFI::MemoryPointer.new(:pointer, ary.length)
    # Copy the input strings to C strings, and write the pointers to in_ptr.
    in_ptr.write_array_of_pointer(ary.map {|s| FFI::MemoryPointer.from_string(s)})

    # Allocate some memory to receive the address of the output array.
    out_var = FFI::MemoryPointer.new(:pointer)

    # Call the actual function.
    CTheFunc(in_ptr, ary.length, out_var)

    # Follow the pointer in out_var, and convert to an array of Ruby strings.
    # This is the return value.
    out_var.read_pointer.get_array_of_string(0, ary.length)
  ensure
    # Free the memory allocated in the Go code. We don’t need to free
    # the memory in the MemoryPointers, it is done automatically.
    out_var.read_pointer.get_array_of_pointer(0, ary.length).each {|p| CLib.free(p)}
    CLib.free(out_var.read_pointer)
  end
end

这确实涉及在每个方向复制数据两次，从（或到）Ruby 中，然后到（或从）Go 中，但我认为没有运行时（尤其是垃圾收集器）不可能以任何其他方式进行) 互相绊倒。可以将数据直接存储在某个共享区域并对其进行操作，而无需FFI::Pointer在 Ruby 和unsafeGo 中复制 using s，但这首先会破坏使用这些语言的目的。