Cgo on chai2010 的博客

Go 语言 CGO 用户深度定制 SQLite 代码

Wed, 26 Oct 2022 00:00:00 +0000

本文是 BRUNO CALZA 记录的关于如何改变SQLite源代码，使记录行更新时可用于 Go 的更新钩子函数的过程。原文通过深度定制 C 语言的 API 函数达成目的，这几乎是所有 CGO 深度用户必然经历的过程（关于 CGO 的基本用法可以参考译者的《Go高级编程》第2章），是一个非常有借鉴意义的技术文章。

作者：BRUNO CALZA
译者：柴树杉，凹语言作者、Go语言贡献者、多本Go语言图书作者，目前在蚂蚁从事 KusionStack 和 KCL 开发。
原文：https://brunocalza.me/making-a-change-to-sqlite-source-code/

1. 背景

有一天，我正在考虑如何在 SQLite 中获取最近插入或更新的行记录的数据。这样做的动机是我想创建该行的 hash，本质上是为了在插入或更新行时能够构建相应表的 Merkle 树。

SQLite 提供的最符合的 API 可能是 sqlite3_update_hook:

sqlite3_update_hook() 函数为数据库连接注册一个回调函数，该数据库连接由第一个参数标识，在 rowwid 表中更新、插入或删除行时调用。

这个 API 的问题是它只返回行的 rowid。这意味着还需要为列内的行获取所有列。即使使用这种方法，我仍然无法获得行记录的原始数据。只能得到那一行的驱动信息。

关于如何构建这样的树可能有很多方法，但就我而言 SQLite API 并没有提供真正想要的东西。因此，我决定趁此机会更深入地挖掘下源代码，同时看看内部实现的细节。不仅如此，我希望可以对它进行一些修改和测试，看看能否满足需求。

因为对 C 语言的畏惧，开始我只是想假装看下几个源文件就跑路。没想到这次真的有惊喜。

2. 看看 SQLite 的代码结构

首先使用 fossil 工具克隆了 SQLite源代码，下面是文件。

如果你对数据库比较熟悉，或许可以猜测出一些文件对应的操作。因此，我决定直接跳到 insert.c 文件，看看能不能找到一些有趣的东西。

遍历函数名列表，路过 sqlite3Insert 函数，看到以下注释：

** This routine is called to handle SQL of the following forms:
**
**    insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),...
**    insert into TABLE (IDLIST) select
**    insert into TABLE (IDLIST) default values
**

也许在这个函数中有一些可鼓捣的地方。我能够对其中发生的情况进行一些猜测，但引起我注意的是对名称类似于 sqlite3vdbeXXX 的函数的函数调用的数量。

这让我想起 SQLite 底层使用了一个名为 vdbe 的虚拟机。这意味着所有SQL语句都首先被翻译成该虚拟机的语言。然后，执行引擎执行虚拟机代码。让我们看一个简单的 INSERT 语句如何被翻译成字节码:

sqlite> create table a (a int, b text);
sqlite> explain INSERT INTO a VALUES (1, 'Hello');
addr  opcode         p1    p2    p3    p4             p5  comment      
----  -------------  ----  ----  ----  -------------  --  -------------
0     Init           0     8     0                    0   Start at 8
1     OpenWrite      0     2     0     2              0   root=2 iDb=0; a
2     Integer        1     2     0                    0   r[2]=1
3     String8        0     3     0     Hello          0   r[3]='Hello'
4     NewRowid       0     1     0                    0   r[1]=rowid
5     MakeRecord     2     2     4     DB             0   r[4]=mkrec(r[2..3])
6     Insert         0     4     1     a              57  intkey=r[1] data=r[4]
7     Halt           0     0     0                    0   
8     Transaction    0     1     1     0              1   usesStmtJournal=0
9     Goto           0     1     0                    0

我得出的结论是 sqlite3Insert 实际上是根据SQLite插入规则，将解析后的 INSERT 语句转换为一系列虚拟机字节码指令。

因此这并不是我要找的地方。我真正需要的是在插入之前创建记录的位置。我猜测那只能是执行虚拟机代码的地方，可能是执行 Insert (OP_INSERT) 操作码的地方。

根据上图我直接找到了 vdbe.c 文件的位置，直奔主题。

我发现有一个有 8000行代码的 switch( pOp->opcode ) 语句，通过 OP_INSERT 关键字找到插入操作对应的代码位置。

在对应分支的第一行中，总算找到了相关的线索:

 Mem *pData;       /* MEM cell holding data for the record to be inserted */

所以 pData 指向要插入的记录数据。您可以在 L5402 中看到pData = &aMem[pOp->p2];，它是如何将 pData 值设置为虚拟机内存 aMem 地址的，该地址位于虚拟机寄存器 p2 所指向的位置。

快速回顾一下: 首先在 insert.c 文件我们了解到 INSERT 语句被翻译成一堆虚拟机指令。然后通过 INSERT 的数据通过这些sqlite3vdbeXXX 调用到达虚拟机。我假设将 OP_INSERT 操作码和数据注册到虚拟机是在第2593行:

sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, aRegIdx[i], regNewData);

下面 regNewData 的一个更详细的说明:

** The regNewData parameter is the first register in a range that contains
** the data to be inserted or the data after the update.  There will be
** pTab->nCol+1 registers in this range.  The first register (the one
** that regNewData points to) will contain the new rowid, or NULL in the
** case of a WITHOUT ROWID table.  The second register in the range will
** contain the content of the first table column.  The third register will
** contain the content of the second table column.  And so forth.
**
** The regOldData parameter is similar to regNewData except that it contains
** the data prior to an UPDATE rather than afterwards.  regOldData is zero
** for an INSERT.  This routine can distinguish between UPDATE and INSERT by
** checking regOldData for zero.

所以，在这一点上，我们正在用数据执行机器代码。代码向下滚动一点，让我们看看如何使用 pData。在 L5448-L5449 处可以看到:

  x.pData = pData->z;
  x.nData = pData->n;

x 的定义如下：

 BtreePayload x;   /* Payload to be inserted */

完美。再向下滚动一点，我们看到:

  rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
      (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)), 
      seekResult
  );

我们终于找到了插入原始数据的位置。但是，我们怎么知道它的格式和这里记录的一样呢? 如果仔细查看示例 INSERT 中的虚拟机代码，在INSERT 操作码之前有一个 MakeRecord 操作码，它负责构建记录。

你可以在 vdb.c 文件中查看 OP_MakeRecord 实现，并看到以下注释:

You can check the OP_MakeRecord implementation at vdbe.c file and see the following comment:

将 P1 开头的 P2 寄存器转换为记录格式，用作数据库表中的数据记录或索引中的键。

在 case 语句的最后几行看到了关键部分:

  /* Invoke the update-hook if required. */
  if( rc ) goto abort_due_to_error;
  if( pTab ){
    assert( db->xUpdateCallback!=0 );
    assert( pTab->aCol!=0 );
    db->xUpdateCallback(db->pUpdateArg,
           (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT,
           zDb, pTab->zName, x.nKey);
  }
  break;

看来我需要的东西都在这里了。更新钩子钩子和原始数据。只需要更新时传递给回调函数即可。

3. 开始定制 SQLite

这就是我期望的 API：

db->xUpdateCallback(db->pUpdateArg,
	(pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT,
	zDb, pTab->zName, x.nKey, pData->z, pData->n);

传递的是数据（pData->z）和其大小(pData->n)。

为了解释函数签名的变化，还需要在多个地方进行相应的修改。

以下是 fossil 工具提示的变化的源文件：

EDITED     src/main.c
EDITED     src/sqlite.h.in
EDITED     src/sqlite3ext.h
EDITED     src/sqliteInt.h
EDITED     src/tclsqlite.c
EDITED     src/vdbe.c

还有一些针对编译提示的修改。

4. 克隆一份 Go SQLite 驱动

现在是时候在一个 Go 程序中创建一个简单的测试了。我比较熟悉与 SQLite 交互的 mattn/go-sqlite3 驱动程序。该项目通过导入SQLite合并文件并通过CGO绑定工作。

因此还需要再克隆下 Go SQLite 驱动，更新被我修改的文件。并在Go API中进行了必要的更新以访问新值。

主要是对 updateHookTrampoline 的更改，现在接收记录为 *C.Char 和 int 类型的数据大小，转型为字节 Slice 并将其传递给回调函数:

func updateHookTrampoline(handle unsafe.Pointer, op int, db *C.char, table *C.char, rowid int64, data *C.char, size int) {
	callback := lookupHandle(handle).(func(int, string, string, int64, []byte))
	callback(op, C.GoString(db), C.GoString(table), rowid, C.GoBytes(unsafe.Pointer(data), C.int(size)))
}

RegisterUpdateHook 函数也需要做同样的调整。

5. 改动后的效果

现在已经准备好了测试的所有东西。让我们运行一个简单的例子，灵感来自 SQLite Internals: Pages & B-trees 博客文章。

package main

import (
	"database/sql"
	"fmt"
	"log"
	"os"

	"github.com/mattn/go-sqlite3"
)

func main() {
	sqlite3conn := []*sqlite3.SQLiteConn{}
	sql.Register("sqlite3_with_hook_example",
		&sqlite3.SQLiteDriver{
			ConnectHook: func(conn *sqlite3.SQLiteConn) error {
				sqlite3conn = append(sqlite3conn, conn)
				conn.RegisterUpdateHook(func(op int, db string, table string, rowid int64, data []byte) {
					switch op {
					case sqlite3.SQLITE_INSERT:
						fmt.Printf("%x\n", data)
					}
				})
				return nil
			},
		})
	os.Remove("./foo.db")

	srcDb, err := sql.Open("sqlite3_with_hook_example", "./foo.db")
	if err != nil {
		log.Fatal(err)
	}
	defer srcDb.Close()
	srcDb.Ping()

	_, err = srcDb.Exec(`CREATE TABLE sandwiches (
		id INTEGER PRIMARY KEY,
		name TEXT,
		length REAL,
		count INTEGER
	);`)
	if err != nil {
		log.Fatal(err)
	}
	_, err = srcDb.Exec("INSERT INTO sandwiches (name, length, count) VALUES ('Italian', 7.5, 2);")
	if err != nil {
		log.Fatal(err)
	}
}

不要忘记添加更新 go.mod 文件 replace github.com/mattn/go-sqlite3 => github.com/brunocalza/go-sqlite3 v0.0.0-20220926005737-36475033d841，重新定向驱动。

运行后应该得到以下的结果：

05001b07014974616c69616e401e00000000000002

这正是 ('Italian', 7.5, 2) 数据的 Efficient Sandwich 编码的结果，不包含主键和记录的长度(前两个字节)。

看到输出结果我才发现能够理解SQLite源代码的部分内容真的很有趣，尽管我不理解它的大部分。但是我做了一些更改并看到这些更改，并通过 Go 的驱动程序看到结果的变化。

老实说这种更改数据库源代码的方法风险太大。与新版本保持同步也是一个太大的问题，但这是一个值得记录的有趣经历。

使用Go语言开发iOS应用(Swift版)

Wed, 25 May 2016 00:00:00 +0000

使用Go语言开发iOS应用(Swift版)

本文加上读者对Go语言和Swift语言都有一定了解, 但是对二者混合使用不了解的同学.

本教程是基于一个真实上架的iOS应用做的简单的总结。

我们先看看运行效果：

背景

Go语言是Google公司于2010年开源的一个面向网络服务和多并发环境的编程语言，特点是简单。但是因为简单，也就只能实现90%的性能，这是Go语言的最大优点，因为少即是多的道理不是每个人都能领悟的。

Swift是Apple公司于2014年发布的用来替代ObjectiveC的语言，主要面向iOS和OS X上的界面程序开发。当然用swift来开发服务器也是大家关注的一个领域，作者看好在不远的将来Swift将逐步替代C++和Rust语言。

Go语言和Swift语言本来是风马牛不相及的两个语言，为何非一定要整到一起呢？原因很简单，因为作者是一个Go粉，同时也算是半个Swift粉；想试水iOS开发，但是实在是受不了ObjectiveC的裹脚布语法。

补充下：本人虽然不喜欢ObjectiveC的语法，但是觉得ObjectiveC的runtime还是很强悍的。理论上，基于ObjectiveC的runtime，可以用任何流行的编程语言来开发iOS应用，RubyMotion就是一个例子。

其实，现在流行的绝大部分语言都有一个交集，就是c语言兼容的二进制接口。所以说，C++流行并不是C++多厉害，而是它选择几本无缝兼容了C语言的规范。

但是，完全兼容C语言的规范也有缺点，就是语言本身无法自由地发展，因为很多地方会受到C语言编程模型的限制。 C++和ObjectiveC是两个比较有代表的例子。

所以说，Swift一出世就兼容C语言的二进制接口规范，同时抱紧了ObjectiveC的runtime大腿，而去自己确实有很大优秀的特性。

但是，我们这里暂时不关心Swift和ObjectiveC的混合编程，我们只关注作为ObjectiveC子集的C语言如何与Swift混合编程。

Swift调用C函数

Swift调用C函数的方法有多种：通过ObjectiveC桥接调用和直接调用。其实两者的原理是一样的，我个人跟喜欢选择最直接也最暴力的直接调用C函数的方式。

比如有一个C函数:

#include <stdio.h>

void getInput(int *output) {
    scanf("%i", output);
}

生成一个桥接的头文件xxx-Bridging-Header.h，里面包含c函数规格说明：

void getInput(int *output);

swift就可以直接使用了:

import Foundation

var output: CInt = 0
getInput(&output)

println(output)

如果不用桥接文件，可以在swift中声明一个Swift函数，对应C函数:

@_silgen_name("getInput") func getInput_swift(query:UnsafePointer<CInt>)

为了明确区分C函数和swift函数，我们将getInput重新声明为getInput_swift，使用方法和前面一样：

import Foundation

var output: CInt = 0
getInput_swift(&output)

println(output)

Swift中如何管理c返回的内存

Swift语言本身是自带ARC的，用户很少直接关注内存问题。但是C函数如果返回内存到Swift空间， Swift的ARC是无效的，需要手工释放C内存。

假设我们自己用C语言实现了一个字符串克隆的函数:

char* MyStrDup(char* s) {
    return strdup(s);
}

在swift中可以这样使用：

@_silgen_name("MyStrDup")
func MyStrDup_swift(query:UnsafePointer<CChar>) -> UnsafeMutablePointer<CChar>

let p = MyStrDup_swift("hello swift-c!")
let s = String.fromCString(p)!
p.dealloc(1)

使用String.fromCString(p)!从C字符串构建一个swift字符串，然后手工调用p.dealloc(1)释放c字符串内存空间。

函数调用和内存管理是跨语言编程中最重要的两个基础问题，目前已久初步可以工作了。

Go语言导出C静态库

Go语言提供了一个cgo的工具，用于Go语言和C语言交互。这是Go语言使用C语言的一个例子:

package main

//#include <stdio.h>
import "C"

func main() {
    C.puts(C.CString("abc"))
}

既然要交互，自然会涉及到C语言回调Go语言函数的情形。为此，cgo提供了一个export注释命令，用于生成Go语言函数对应的C语言函数:

//export MyStrDup
func MyStrDup(s *C.char) *C.char {
    return C.strdup(s)
}

MyStrDup指定的名字必须和Go函数名字一致，函数的参数最后是C语言支持的类型。

现在，我们就得到了用Go语言实现的MyStrDup函数，使用方法和前面的C语言实现的MyStrDup是一样的。

和引用C语言函数库遇到的问题一样，我们如何在工程中引用这些C代码或Go代码实现的函数呢？

答案还是来自C语言：将代码构建为C静态库或者C动态库，然后将静态库或动态库导入Swift工程。

但是，对于iOS来说，构建C静态库或者C动态库的过程要麻烦（使用xcode也只是隐藏了构建的具体步骤）。

因为，iOS涉及到多种CPU架构：模拟器的x86、4s的32位arm、5s以后的64位arm，64位arm中还有不同当版本…

这是C静态库或者C动态库构建始终都要面对的问题。

交叉构建的参数

Go1.6之后增加了构建C静态库的支持，交叉编译也非常简单，只需要设置好GOARCH和GOOS就行。

因为，iOS的GOOS只有Darwin一种类型，我们只需要设置GOARCH就可以了。

要构建C静态库，我们需要将上面的MyStrDup实现放到一个main包中:

package main

//#include <string.h>
import "C"

func main() {
    //
}

//export MyStrDup
func MyStrDup(s *C.char) *C.char {
    return C.strdup(s)
}

main包中的main函数不会被执行，但是init函数依然有效。

使用下面的命令就可以构建当前系统的c静态库：

go build -buildmode=c-archive

要交叉编译iOS可用的c静态库，我们需要先设置GOARCH，同时打开cgo特性（交叉编译时，cgo默认是关闭的）。

下面是构建针对模拟器的x86/amd64类型的C静态库：

export CGO_ENABLED=1
export GOARCH=amd64

go build -buildmode=c-archive -o libmystrdup_amd64.a

我们使用-o参数指定了输出的静态库文件名。构建命令同时还会生成一个头文件（可能叫libmystrdup_386.h），我们没有用到这个头文件，直接删除掉就可以。

下面是构建针对模拟器的x86/386类型的C静态库：

export CGO_ENABLED=1
export GOARCH=386

go build -buildmode=c-archive -o libmystrdup_386.a

在构建x86/386类型的C静态库时可能会有一些link错误，我们暂时先用以下方法回避。

创建一个patch_386.go文件：

// Copyright 2016 <chaishushan{AT}gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// 针对iOS模拟器link时缺少的函数
// 属于临时解决方案

package main

/*
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

size_t fwrite$UNIX2003(const void* a, size_t b, size_t c, FILE* d) {
    return fwrite(a, b, c, d);
}

char* strerror$UNIX2003(int errnum) {
    return strerror(errnum);
}

time_t mktime$UNIX2003(struct tm * a) {
    return mktime(a);
}
double strtod$UNIX2003(const char * a, char ** b) {
    return strtod(a, b);
}

int setenv$UNIX2003(const char* envname, const char* envval, int overwrite) {
    return setenv(envname, envval, overwrite);
}
int unsetenv$UNIX2003(const char* name) {
    return unsetenv(name);
}

*/
import "C"

当然，还是会有一些警告出现，暂时忽略它们。

构建多cpu类型的静态库

然后，将C静态库加入到ios的xcode工程文件就可以了。

x86构建是比较简单的，因为我们可以默认使用本地的构建命令。但是，如果要构建arm的静态库，则需要先配置好构建环境。

我从Go代码中扣出了一个clangwrap.sh脚本（好像是在$GOROOT/misci/ios目录）:

#!/bin/sh
# This uses the latest available iOS SDK, which is recommended.
# To select a specific SDK, run 'xcodebuild -showsdks'
# to see the available SDKs and replace iphoneos with one of them.
SDK=iphoneos
SDK_PATH=`xcrun --sdk $SDK --show-sdk-path`
export IPHONEOS_DEPLOYMENT_TARGET=7.0
# cmd/cgo doesn't support llvm-gcc-4.2, so we have to use clang.
CLANG=`xcrun --sdk $SDK --find clang`

if [ "$GOARCH" == "arm" ]; then
    CLANGARCH="armv7"
elif [ "$GOARCH" == "arm64" ]; then
    CLANGARCH="arm64"
else
    echo "unknown GOARCH=$GOARCH" >&2
    exit 1
fi

exec $CLANG -arch $CLANGARCH -isysroot $SDK_PATH "$@"

里面比较重要的是IPHONEOS_DEPLOYMENT_TARGET环境变量，这里意思是目标最低支持ios7.0系统。

构建arm64环境的静态库：

export CGO_ENABLED=1
export GOARCH=arm64
export CC=$PWD/clangwrap.sh
export CXX=$PWD/clangwrap.sh

go build -buildmode=c-archive -o libmystrdup_arm64.a

构建armv7环境的静态库：

export CGO_ENABLED=1
export GOARCH=arm
export GOARM=7
export CC=$PWD/clangwrap.sh
export CXX=$PWD/clangwrap.sh

go build -buildmode=c-archive -o libmystrdup_armv7.a

然后我们用lipo命令将以上这些不同的静态库打包到一个静态库中：

lipo libmystrdup_386.a libmystrdup_adm64.a libmystrdup_arm64.a libmystrdup_armv7.a -create -output libmystrdup.a

这样的话，只要引入一个静态库就可以支持不同cpu类型的目标了。

总结

毛主席教导我们：要在战争中学习战争。

野鸡医院 这个app是作者第一个iOS应用，这篇教程也是在iOS开发过程逐步学习总结的结果。

完整的例子：

AppStore安装: https://appsto.re/cn/QH8ocb.i
Swift工程: https://github.com/chai2010/ptyy/tree/master/ios-app/yjyy-swift
Go静态库工程: https://github.com/chai2010/ptyy/tree/master/cmd/yjyy
静态库构建脚本: https://github.com/chai2010/ptyy/tree/master/ios-app/yjyy-swift/vendor/gopkg

所有的代码均可以免费获取(BSD协议): https://github.com/chai2010/ptyy

Go和C如何共享内存资源

Sun, 13 Oct 2013 00:00:00 +0000

Go语言作为一个现代化的编程语言以及支持垃圾内存的自动回收特性(GC). 我们现在关注的是C语言返回的内存资源的自动回收技术.

CGO初步

Go语言的cgo技术允许在Go代码中方便的使用C语言代码. 基本的用法如下:

package rand

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

func Random() int {
    return int(C.random())
}

func Seed(i int) {
    C.srandom(C.uint(i))
}

其中"C"是导入一个虚拟的包, 用于引用C语言的符号.

Go语言和C语言通讯交互主要是通过传递参数和返回值. 其中参数和返回值除了基本的数据类型外, 最重要的是如何相互传递/共享二进制的内存块.

Go向C语言传递内存块

这个最简单, 有很多现成的例子:

package print

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

func Print(s string) {
    cs := C.CString(s)
    C.fputs(cs, (*C.FILE)(C.stdout))
    C.free(unsafe.Pointer(cs))
}

因为C语言的字符串结尾有\0, Go语言字符串没有\0, 因此需要重新构造一个C字符串. 其中 C.CString(s) 是构造一个C的字符串, 然后复制字符串并传入 C.fputs. 用完之后不要忘记调用C.free释放新创建的C字符串(可以用defer释放).

如果是普通的内存块, 可以直接传递给C函数:

package main

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

func Copy(dst, src []byte, size int) {
    C.memcpy(unsafe.Pointer(&dst[0]), unsafe.Pointer(&src[0]), C.size_t(size)
}

这个代码并没有涉及内存的创建/复制/删除等额外的操作, 是比较理想的集成方式.

注意: 在C语言使用该资源期间要防止Go语言的GC提前释放被C语言使用的Go内存!

C向Go语言返回内存块

如果是C语言向Go返回内存块, 一般是先创建一个对应的Go的切片. 有现成的函数C.GoBytes()可以基于C的内存块构造切片.

比如获取C返回的内存块数据:

package main

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

func GetData() []byte {
    p := C.malloc(1024)
    defer C.free(p)
    return C.GoBytes(p, 1024)
}

代码并不复杂. 但是效率并不理想: 其中需要新创建一个Go的切片, 并进行一次冗余的复制操作.

如果想去掉冗余的复制操作, 就需要基于C的内存块构造切片. 这个需要依赖Go语言的反射技术.

package main

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

func GetData() []byte {
    p := C.malloc(1024)
    var s []byte
    h := (*reflect.SliceHeader)((unsafe.Pointer(&s)))
    h.Cap = 1024
    h.Len = 1024
    h.Data = uintptr(p)
    return s
}

返回的s是基于C语言内存块构造的切片. 没有冗余的内存复制操作.

但是, 上面的代码却有内存泄漏的问题. Go语言的GC并不会自动释放C.malloc释放的内存.

如果需要Go语言的GC自动管理C语言返回的内存, 需要基于之前讲过的 “Go语言资源自动回收技术[OSC源创会主题补充3]” .

简而言之, 就是要将C语言的内存块绑定到一个Go语言的内存资源, 然后依靠runtime.SetFinalizer的技术管理C语言的内存块.

核心代码如下:

type Slice struct {
    Data []byte
    data *c_slice_t
}

type c_slice_t struct {
    p unsafe.Pointer
    n int
}

func newSlice(p unsafe.Pointer, n int) *Slice {
    data := &c_slice_t{p, n}
    runtime.SetFinalizer(data, func(data *c_slice_t) {
        C.free(data.p)
    })
    s := &Slice{data: data}
    h := (*reflect.SliceHeader)((unsafe.Pointer(&s.Data)))
    h.Cap = n
    h.Len = n
    h.Data = uintptr(p)
    return s
}

其中 newSlice 基于C语言的内存块构造 Slice 结构体. 如果 Slice.data 资源没有被引用, 则会自动触发C语言的内存释放函数.

完整的测试代码

package main

/*
#include <stdio.h>
#include <stdlib.h>

void print(char* s) {
    printf("print: %s\n", s);
}
*/
import "C"
import (
    "fmt"
    "reflect"
    "runtime"
    "time"
    "unsafe"
)

type Slice struct {
    Data []byte
    data *c_slice_t
}

type c_slice_t struct {
    p unsafe.Pointer
    n int
}

func newSlice(p unsafe.Pointer, n int) *Slice {
    data := &c_slice_t{p, n}
    runtime.SetFinalizer(data, func(data *c_slice_t) {
        println("gc:", data.p)
        C.free(data.p)
    })
    s := &Slice{data: data}
    h := (*reflect.SliceHeader)((unsafe.Pointer(&s.Data)))
    h.Cap = n
    h.Len = n
    h.Data = uintptr(p)
    return s
}

func testSlice() {
    msg := "hello world!"
    p := C.calloc((C.size_t)(len(msg) + 1), 1)
    println("malloc:", p)

    s := newSlice(p, len(msg)+1)
    copy(s.Data, []byte(msg))

    fmt.Printf("fmt.Printf: %s\n", string(s.Data))
    C.print((*C.char)(p))
}

func main() {
    testSlice()

    runtime.GC()
    runtime.Gosched()
    time.Sleep(1e9)
}

测试程序的输出:

D:>go run hello.go
malloc: 0x6f7f50
fmt.Printf: hello world!
print: hello world!
gc: 0x6f7f50

注: Go1.3之前有效, Go1.4之后改了移动栈.

C？Go？Cgo！[翻译]

Tue, 02 Apr 2013 00:00:00 +0000

原文： http://golang.org/doc/articles/c_go_cgo.html
中文： http://zh-golang.appsp0t.com/doc/articles/c_go_cgo.html

Cgo允许在Go包中调用C代码。如果Go代码含有特殊的cgo语法，可以通过cgo生成相应的Go和C文件，它们可以被编译到一个Go包中。

以一个例子开始，下面的Go包提供了 Random 和 Seed 两个函数，它们是基于C语言的 random 和 srandom 函数的实现。

package rand

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

func Random() int {
    return int(C.random())
}

func Seed(i int) {
    C.srandom(C.uint(i))
}

我们从 import 语句开始，讲解相关的代码。

rand 包导入了一个 "C" 包，但是这个包并不是由Go标准库提供。因为 C 包是Cgo工具生成的一个虚拟包，它映射到C语言的名字空间。

rand 包中有几个地方使用了 C 包： C.random、C.srandom、C.uint(i) 和 import 语句。

Random 函数调用C语言标准库中的 random 函数，然后返回结果。在C语言中，random 返回的结果为 long 类型，对应cgo生成的 C.long。在函数返回前我们必须将C类型转换为Go类型。

func Random() int {
    return int(C.random())
}

下面是一个等价的实现，为了更好说明类型转换的使用，这里使用了一个临时变量。

func Random() int {
    var r C.long = C.random()
    return int(r)
}

Seed 函数进行相反的类型转换。它将传入的Go的 int 类型变量转换为C语言的 unsigned int，然后传入C语言的 srandom 函数。

func Seed(i int) {
    C.srandom(C.uint(i))
}

Cgo能够知道 unsigned int 对应 C.uint 类型。关于数值类型的详细说明可以参考Cgo文档。

到此为止，只有 import 语句的注释还没有解释。

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

Cgo可以识别这个注释。注释中，任意以 #cgo 开头的行会被忽略，它们是cgo的扩展命令。剩余的行在编译包的C代码时时，将被当作头文件处理。在这个例子中，虽然只有一个 #include 语句，但是可以包含任意的C语言代码。在构建包中C代码时，#cgo 规则可以指定用于编译和连接的选项。

有一点要注意：如果使用了 //export 规则，那么注释中的C代码将只能包含对应函数的声明（extern int f();），而不能是对应函数的定义（int f() { return 1; }）。使用 //export 规则，可以使Go函数被C语言函数调用。

关于 #cgo 和 //export 的用法在 cgo文档中有详细说明。

字符串相关

和Go语言不同，C语言没有明确的字符串类型。在C语言中，字符串表现为以 NULL 结尾的 char数组。

Go语言和C语言字符串之间的转换由以下函数完成：C.CString、C.GoString 和 C.GoStringN。这些函数函数在转换时均构造了一个字符串的副本。

这里是 Print 函数的另一个实现，它通过C语言的 stdio 标准库函数 fputs 将字符串写到标准输出：

package print

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

func Print(s string) {
    cs := C.CString(s)
    C.fputs(cs, (*C.FILE)(C.stdout))
    C.free(unsafe.Pointer(cs))
}

Go语言的GC并不能管理C语言函数分配的内存。当使用 C.CString（使用C函数分配了内存）返回C字符串时，必须要记得在完成后用 C.free 释放对应的内存。

C.CString 返回C语言字符串起始地址，因此在函数返回时将它转换为 unsafe.Pointer 类型，然后用 C.free释放对应内存空间。cgo中的一个常用习惯是在创建新内存后使用 defer 释放对应的内存（特别是在后面代码很复杂时），下面是重写的 Print 函数：

func Print(s string) {
    cs := C.CString(s)
    defer C.free(unsafe.Pointer(cs))
    C.fputs(cs, (*C.FILE)(C.stdout))
}

构建cgo包

要构建cgo包，只要直接简单执行 “go build” 或 “go install” 命令。 go命令可以识别 "C" 虚拟包的语法，并且可以自动调用cgo生成相应的中间代码文件。

Cgo on chai2010 的博客

Go 语言 CGO 用户深度定制 SQLite 代码

1. 背景

2. 看看 SQLite 的代码结构

3. 开始定制 SQLite

4. 克隆一份 Go SQLite 驱动

5. 改动后的效果

使用Go语言开发iOS应用(Swift版)

使用Go语言开发iOS应用(Swift版)

背景

Swift调用C函数

Swift中如何管理c返回的内存

Go语言导出C静态库

交叉构建的参数

构建多cpu类型的静态库

总结

Go和C如何共享内存资源

CGO初步

Go向C语言传递内存块

C向Go语言返回内存块

完整的测试代码

C？Go？Cgo！[翻译]

字符串相关

构建cgo包

更多的Cgo资源