company_banner

Вызов функций Go из других языков

https://dev.to/vladimirvivien/calling-go-functions-from-other-languages
  • Перевод

image


С версии 1.5 компилятор Go поддерживает несколько режимов сборки, определяемых флагом buildmode. Их ещё называют режимами исполнения Go (Go Execution Modes). С их помощью go tool может компилировать пакеты Go в нескольких форматах, включая архивы и библиотеки общего пользования Go (shared libraries), архивы и библиотеки общего пользования Си, а с версии 1.8 — и динамические плагины Go.


В статье мы рассмотрим компилирование пакетов Go в библиотеки Си. В этом режиме сборки компилятор генерирует стандартный бинарный файл объекта (shared object) (.so), передавая функции Go в качестве API в стиле Си. Мы поговорим о том, как создавать библиотеки Go, которые можно вызывать из C, Python, Ruby, Node и Java.


Весь код доступен на GitHub.


Код на Go


Сначала напишем код на Go. Допустим, у нас есть библиотека awesome, цель — сделать её доступной для других языков. Прежде чем компилировать код в библиотеку, нужно соблюсти четыре условия:


  • Пакет должен относиться к пакетам типа main. Тогда компилятор соберёт его и все зависимости в один бинарный файл общего объекта.
  • Источник должен импортировать псевдопакет "C".
  • Для аннотирования функций, которые нужно сделать доступными для других языков, используйте комментарий //export.
  • Должна быть объявлена пустая функция main.

Следующий источник Go экспортирует четыре функции: Add, Cosine, Sort и Log. Нужно признаться, что библиотека awesome не столь впечатляющая. Однако её разнообразные сигнатуры функций (function signatures) помогут нам изучить возможные последствия отображения типов (type mapping).


Файл awesome.go:


package main

import "C"

import (
    "fmt"
    "math"
    "sort"
    "sync"
)

var count int
var mtx sync.Mutex

//export Add
func Add(a, b int) int {
    return a + b
}

//export Cosine
func Cosine(x float64) float64 {
    return math.Cos(x)
}

//export Sort
func Sort(vals []int) {
    sort.Ints(vals)
}

//export Log
func Log(msg string) int {
    mtx.Lock()
    defer mtx.Unlock()
    fmt.Println(msg)
    count++
    return count
}

func main() {}

Пакет скомпилирован с флагом -buildmode=c-shared, чтобы создать бинарный файл объекта:


go build -o awesome.so -buildmode=c-shared awesome.go

Компилятор создаёт заголовочный С-файл awesome.h и файл объекта awesome.so:


-rw-rw-r —    1362 Feb 11 07:59 awesome.h
-rw-rw-r — 1997880 Feb 11 07:59 awesome.so

Обратите внимание, что размер файла .so около 2 Мб. Довольно много для такой маленькой библиотеки. Дело в том, что в этот файл запихивается вся runtime-механика Go и зависимые пакеты.


Заголовочный файл


Он определяет С-типы, которые с помощью семантики cgo мапятся в совместимые Go-типы.


/* Created by “go tool cgo” — DO NOT EDIT. */
...
typedef long long GoInt64;
typedef unsigned long long GoUint64;
typedef GoInt64 GoInt;
typedef double GoFloat64;
...
typedef struct { const char *p; GoInt n; } GoString;
typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
...
#endif
...
extern GoInt Add(GoInt p0, GoInt p1);
extern GoFloat64 Cosine(GoFloat64 p0);
extern void Sort(GoSlice p0);
extern GoInt Log(GoString p0);
...

Файл разделяемого объекта


Это 64-битный бинарный ELF-файл общего объекта. Можно верифицировать его содержимое с помощью команды file.


$> file awesome.so
awesome.so: ELF 64-bit LSB shared object, x86–64, version 1 (SYSV), dynamically linked, BuildID[sha1]=1fcf29a2779a335371f17219fffbdc47b2ed378a, not stripped

С помощью команд nm и grep можно проверить, что наши функции Go экспортированы в файл объекта.


$> nm awesome.so | grep -e "T Add" -e "T Cosine" -e "T Sort" -e "T Log"
00000000000d0db0 T Add
00000000000d0e30 T Cosine
00000000000d0f30 T Log
00000000000d0eb0 T Sort

Из Cи


Есть два способа использования библиотеки для вызова функций Go из Си. Сначала привязать (bind) библиотеку: статически — на стадии компилирования, динамически — во время runtime. Либо динамически загружать и связывать (bound) символы функции Go.


Динамическое линкование


В данном случае мы используем заголовочный файл для создания статических связей между типами и функциями, экспортируемыми в файле объекта. Код получается простым и чистым (опущены некоторые выражения print):


Файл client1.c


#include <stdio.h>
#include "awesome.h"

int main() {
    printf("Using awesome lib from C:\n");

    GoInt a = 12;
    GoInt b = 99;
    printf("awesome.Add(12,99) = %d\n", Add(a, b)); 
    printf("awesome.Cosine(1) = %f\n", (float)(Cosine(1.0)));

    GoInt data[6] = {77, 12, 5, 99, 28, 23};
    GoSlice nums = {data, 6, 6};
    Sort(nums);
    ...
    GoString msg = {"Hello from C!", 13};
    Log(msg);
}

Теперь компилируем С-код с указанием библиотеки объектов:


$> gcc -o client client1.c ./awesome.so

Когда запускается получившийся бинарный файл, он линкуется с библиотекой awesome.so, вызывает экспортированные из Go функции и выдаёт:


$> ./client
awesome.Add(12,99) = 111
awesome.Cosine(1) = 0.540302
awesome.Sort(77,12,5,99,28,23): 5,12,23,28,77,99,
Hello from C!

Динамическая загрузка


При таком подходе С-код использует библиотеку загрузчика динамических связей (dynamic link loader library) для динамической загрузки и привязки экспортированных символов. Определённые в dhfcn.h функции применяются:


  • для открывания файла библиотеки — dlopen,
  • для поиска символов — dlsym,
  • для получения ошибок — dlerror,
  • для закрывания файла библиотеки — dlclose.

Эта версия будет длиннее, поскольку привязка и линкование выполняются в вашем исходном коде. Но она делает всё то же самое, что и предыдущий вариант (опущены некоторые выражения обработки ошибок и print):


Файл client2.c


#include <stdlib.h>
#include <stdio.h>
#include <dlfcn.h>

// define types needed
typedef long long go_int;
typedef double go_float64;
typedef struct{void *arr; go_int len; go_int cap;} go_slice;
typedef struct{const char *p; go_int len;} go_str;

int main(int argc, char **argv) {
    void *handle;
    char *error;

    handle = dlopen ("./awesome.so", RTLD_LAZY);
    if (!handle) {
        fputs (dlerror(), stderr);
        exit(1);
    }

    go_int (*add)(go_int, go_int)  = dlsym(handle, "Add");
    if ((error = dlerror()) != NULL)  { ... }
    go_int sum = (*add)(12, 99); 
    printf("awesome.Add(12, 99) = %d\n", sum);

    go_float64 (*cosine)(go_float64) = dlsym(handle, "Cosine");
    go_float64 cos = (*cosine)(1.0);
    printf("awesome.Cosine(1) = %f\n", cos);

    void (*sort)(go_slice) = dlsym(handle, "Sort");
    go_int data[5] = {44,23,7,66,2};
    go_slice nums = {data, 5, 5};
    sort(nums);

    go_int (*log)(go_str) = dlsym(handle, "Log");
    go_str msg = {"Hello from C!", 13};
    log(msg);

    dlclose(handle);
}

В предыдущем коде мы определили наше собственное подмножество совместимых с Go типов С: go_int, go_float, go_slice и go_str. Для загрузки символов Add, Cosine, Sort и Log с последующей привязкой к соответствующим указателям функций мы использовали dlsym. Затем скомпилировали код, сославшись на библиотеку dl (не awesome.so):


$> gcc -o client client2.c -ldl

При выполнении кода бинарный файл С загружает и линкует библиотеку awesome.so. В результате получаем:


$> ./client
awesome.Add(12, 99) = 111
awesome.Cosine(1) = 0.540302
awesome.Sort(44,23,7,66,2): 2,7,23,44,66,
Hello from C!

Из Python


С Python всё несколько проще. Мы используем библиотеку внешних функций (foreign function library) ctypes, чтобы вызвать функции Go из библиотеки awesome.so, как показано в следующем примере (опущены некоторые выражения print):


Файл client.py


from ctypes import *

lib = cdll.LoadLibrary("./awesome.so")
lib.Add.argtypes = [c_longlong, c_longlong]
print "awesome.Add(12,99) = %d" % lib.Add(12,99)

lib.Cosine.argtypes = [c_double]
lib.Cosine.restype = c_double 
cos = lib.Cosine(1)
print "awesome.Cosine(1) = %f" % cos

class GoSlice(Structure):
    _fields_ = [("data", POINTER(c_void_p)), 
                ("len", c_longlong), ("cap", c_longlong)]

nums = GoSlice((c_void_p * 5)(74, 4, 122, 9, 12), 5, 5)
lib.Sort.argtypes = [GoSlice]
lib.Sort.restype = None
lib.Sort(nums)

class GoString(Structure):
    _fields_ = [("p", c_char_p), ("n", c_longlong)]

lib.Log.argtypes = [GoString]
msg = GoString(b"Hello Python!", 13)
lib.Log(msg)

Обратите внимание, что переменная lib представляет загруженные символы из файла разделяемого объекта. Объявим классы Python GoString и GoSlice, чтобы сопоставить их с соответствующими структурными типами С (struct types). При выполнении кода Python вызываются функции Go из общего объекта:


$> python client.py
awesome.Add(12,99) = 111
awesome.Cosine(1) = 0.540302
awesome.Sort(74,4,122,9,12) = [ 4 9 12 74 122 ]
Hello Python!

Из Ruby


Здесь всё делается по тому же принципу, что и выше. Используем FFI gem для динамической загрузки и вызова экспортированных функций из awesome.so.


Файл client.rb


require 'ffi'

module Awesome
  extend FFI::Library

  ffi_lib './awesome.so'

  class GoSlice < FFI::Struct
    layout :data,  :pointer,
           :len,   :long_long,
           :cap,   :long_long
  end

  class GoString < FFI::Struct
    layout :p,     :pointer,
           :len,   :long_long
  end

  attach_function :Add, [:long_long, :long_long], :long_long
  attach_function :Cosine, [:double], :double
  attach_function :Sort, [GoSlice.by_value], :void
  attach_function :Log, [GoString.by_value], :int
end

print "awesome.Add(12, 99) = ",  Awesome.Add(12, 99), "\n"
print "awesome.Cosine(1) = ", Awesome.Cosine(1), "\n"

nums = [92,101,3,44,7]
ptr = FFI::MemoryPointer.new :long_long, nums.size
ptr.write_array_of_long_long  nums
slice = Awesome::GoSlice.new
slice[:data] = ptr
slice[:len] = nums.size
slice[:cap] = nums.size
Awesome.Sort(slice)

msg = "Hello Ruby!"
gostr = Awesome::GoString.new
gostr[:p] = FFI::MemoryPointer.from_string(msg)
gostr[:len] = msg.size
Awesome.Log(gostr)

В Ruby нам нужно расширить модуль FFI, чтобы объявить символы загружаемыми из общей библиотеки. Объявим классы Ruby GoSlice и GoString, чтобы сопоставить их с соответствующими С-структурами. При выполнении кода он вызывает экспортированные функции Go:


$> ruby client.rb
awesome.Add(12, 99) = 111
awesome.Cosine(1) = 0.5403023058681398
awesome.Sort([92, 101, 3, 44, 7]) = [3, 7, 44, 92, 101]
Hello Ruby!

Из Node


Мы воспользуемся библиотекой внешних функций node-ffi (и парочкой зависимых пакетов) для динамической загрузки и вызова экспортированных функций Go из awesome.so:


Файл client.js


var ref = require("ref");
var ffi = require("ffi");
var Struct = require("ref-struct");
var ArrayType = require("ref-array");

var LongArray = ArrayType(ref.types.longlong);

var GoSlice = Struct({
  data: LongArray,
  len:  "longlong",
  cap: "longlong"
});

var GoString = Struct({
  p: "string",
  n: "longlong"
});

var awesome = ffi.Library("./awesome.so", {
  Add: ["longlong", ["longlong", "longlong"]],
  Cosine: ["double", ["double"]],
  Sort: ["void", [GoSlice]],
  Log: ["longlong", [GoString]]
});

console.log("awesome.Add(12, 99) = ", awesome.Add(12, 99));
console.log("awesome.Cosine(1) = ", awesome.Cosine(1));

nums = LongArray([12,54,0,423,9]);
var slice = new GoSlice();
slice["data"] = nums;
slice["len"] = 5;
slice["cap"] = 5;
awesome.Sort(slice);

str = new GoString();
str["p"] = "Hello Node!";
str["n"] = 11;
awesome.Log(str);

Для объявления и загрузки символов из разделяемой библиотеки Node использует объект ffi. Также объявим структурные объекты Node GoSlice и GoString, чтобы сопоставить их с соответствующими С-структурами. При выполнении кода вызываются экспортированные функции:


awesome.Add(12, 99) =  111
awesome.Cosine(1) =  0.5403023058681398
awesome.Sort([12,54,0,423,9] =  [ 0, 9, 12, 54, 423 ]
Hello Node!

Из Java


Для вызова экспортированных функций воспользуемся библиотекой Java Native Access (JNA) (некоторые выражения опущены или даны аббревиатурами):


Файл Client.java


import com.sun.jna.*;

public class Client {
  public interface Awesome extends Library {
    public class GoSlice extends Structure {
      ...
      public Pointer data;
      public long len;
      public long cap;
    }

    public class GoString extends Structure {
      ...
      public String p;
      public long n;
    }

    public long Add(long a, long b);
    public double Cosine(double val);
    public void Sort(GoSlice.ByValue vals);
    public long Log(GoString.ByValue str);
  }

  static public void main(String argv[]) {
    Awesome awesome = (Awesome) Native.loadLibrary(
      "./awesome.so", Awesome.class);

    System.out.printf(... awesome.Add(12, 99));
    System.out.printf(... awesome.Cosine(1.0));

    long[] nums = new long[]{53,11,5,2,88};
    Memory arr = new Memory(... Native.getNativeSize(Long.TYPE));
    Awesome.GoSlice.ByValue slice = new Awesome.GoSlice.ByValue();
    slice.data = arr;
    slice.len = nums.length;
    slice.cap = nums.length;
    awesome.Sort(slice);

    Awesome.GoString.ByValue str = new Awesome.GoString.ByValue();
    str.p = "Hello Java!";
    str.n = str.p.length();
    awesome.Log(str);
  }
}

Для использования JNA определим Java-интерфейс Awesome, который будет представлять загруженные из awesome.so символы. Также объявим классы GoSlice и GoString, чтобы сопоставить их с соответствующими С-структурами. Компилируем и запускаем код, вызываются экспортированные функции:


$> javac -cp jna.jar Client.java
$> java -cp .:jna.jar Client
awesome.Add(12, 99) = 111
awesome.Cosine(1.0) = 0.5403023058681398
awesome.Sort(53,11,5,2,88) = [2 5 11 53 88 ]
Hello Java!

Заключение


Мы рассмотрели, как создавать библиотеку Go для её использования другими языками. Компилируя пакеты Go в библиотеки в стиле Си, вы с помощью внутрипроцессной (in-process) интеграции бинарных файлов объектов можете легко обращаться к своим Go-проектам совместно с Cи, Python, Ruby, Node, Java и т. д. Поэтому в следующий раз, когда вы сделаете супер-API на Go, не забудьте поделиться им с разработчиками на других языках.

Mail.Ru Group 708,76
Строим Интернет
Поделиться публикацией
Похожие публикации
Комментарии 23
  • НЛО прилетело и опубликовало эту надпись здесь
      +2

      Спасибо за статью, еще бы пункт "Из PHP" — цены бы не было))

        +1
        pecl php ffi
          0
          Последний релиз модуля был 12 (двенадцать!) лет назад.
        0
        а в качестве эксперимента не пробовали вызывать функции Go из Rust?
          +1

          А смысл? Go не создает своей calling convention, как взаимодействовать из Rust с C API пост уже есть.

            0
            если исходить из этого, то тогда теряется весь смысл этой статьи
              0

              Мне кажется смысл был в том что бы показать как собрать .so-шку, все остальное не относится к Go напрямую.

                0
                в статье же показывалось как потом из других языков вызывать, поэтому можно и показать, как вызывать из Rust
          0

          Поддерживаю php, но подразумеваю все будет не так просто, нужно будет минимум модуль написать и в нем прилинковать все как в примере на С

            –4
            Вообще go крутой язык
              0

              КДПВ супер. А мне вот интересно, можно ли таки образом сделать библиотеку для С++ с легковесными горутинами внутри и скажем вызовом через cgo переданных std::function

                0
                Но зачем?
                0
                Вызов функции через cgo с ненулевой вероятностью создаст новый полноценный thread операционной системы, что убьёт всю лёгкость горутин.
                  0

                  Проще написать транспайлер подмножества C++ в Go, библиотеку для горутин на C++ или писать сразу на Go.

                0
                По опыту экспериментов с этим на Ruby, можно легко создавать в go коде gorutines, но надо дожидаться когда они завершатся, иначе будет segfault в конце. При этом прокинуть туда callback нельзя, видимо GIL и всякая другая обвязка над Ruby блоками не позволяет вызвать их. Вот на toster задавал еще тогда вопрос.
                  0
                  какое то «щиворот на выворот», обычно из go вызывают C/C++ методы
                    +2
                    По мне в Ruby лучше написать нативное расширение, без динамической загрузки и поинтеров в ruby коде.
                    Минус FFI в том, что если выскакивает Exception в C, то все сразу падает, а в расширении хоть можно код обернуть и поймать ошибку и ничего не упадает.
                      0
                      Надо отметить, что я аналогичную задачу делал для Python, и при этом функция из библиотеки вызывалась как родная функция Python, без всяких cffi и с обработкой Python исключений. Но в целом статья хорошая.
                        +2
                        Вызов Go методов из других языков разжеван уже донельзя. Вы бы лучше рассказали как там дела обстоят с возвращаемыми значениями (а здесь и начинаются настоящие приключения). Все работает очень гладко до тех пор пока мы не попробуем вернуть что-то посложнее строк или int.

                        Например вызывать метод Go из С++ и возвращать сложную структуру в теории нужно в такой последовательности:

                        1. В С++ аллоцировать структуру
                        2. Передать в Go поинтер
                        3. В Go заполнить значения структуры через C.types и unsafe.Pointer
                        4. В С++ проверить заполненность

                        И при этом очень легко нарваться на segfault.

                        А теперь представим что вместо вызова С -> Go, нам нужно вызвать Go -> С. Все становится еще веселее:

                        1. В Go (через CGo) нужно аллоцировать структуру (через написание отдельной функции в отдельном файле) и вернуть поинтер на нее.
                        2. В Go заполнить структуру через C.types и unsafe.Pointer
                        3. Передать unsafe.Pointer в C++
                        4. Скомпилировать эту матрешку (Go -> CGo -> Go -> C)

                        При этом шанс получить segfault возрастает экспоненциально.

                        А вся проблема в том что Go runtime любит очень быстро подчищать память. И если мы передали структуру собранную в Go напрямую, примерно на 2й инструкции в С она уже будет подчищена.
                          0
                          Вызывать то можно, но производительность при это не очень.

                          Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

                          Самое читаемое