CN115934374A - High-performance CGO cross-language calling method - Google Patents

Abstract

The invention relates to the technical field of cross-language calling, and discloses a high-performance CGO (CGO) cross-language calling method.A unbinding logic processor P and a system thread M are cancelled from the whole cross-language calling flow, and are called only when a Go language is operated to try to seize a Go co-program in the HCGO calling process, so that the cross-language calling under most conditions does not need to execute the operation; the cross-language call chain is optimized by canceling stack switching, and the call overhead is reduced.

Description

High-performance CGO cross-language calling method

Technical Field

The invention relates to the technical field of cross-language calling, in particular to a high-performance CGO (CGO) cross-language calling method.

Background

The Go language is also called Golang. The Go language has simple grammar and easy development, has high-level language characteristics of garbage collection, multiple return values, concurrent programming and the like, and is popular with developers.

The Go language provides a cross-language intermodulation mechanism named CGO, which can enable codes of the Go language and the C language to be mutually called, thereby conveniently reusing a historical legacy or high-performance C code library. However, the performance of the CGO call is always a problem for users, the call chain is long, and the call overhead is high. By performing experiments on calling an empty function in the C language for the Go language and repeatedly calling the empty function in the Go language n (n = 1M) times for the C language, the average cost of a single CGO call is respectively counted to obtain the results shown in table 1. It can be seen that the expenses of the Go language for calling the C language and the C language for calling the Go language are much higher than the expenses of the Go language for calling the Go language, and specifically can reach 48 times to 2707 times.

TABLE 1 call overhead for CGO

Calling mode	Time
		Invoking Go language by Go language	1.442ns
Invoking C language by Go language	69.90ns
		C language call Go language (Go language as host language)	119.749ns
Calling Go language by C language (C language is host language)	3904.44ns

This situation is mainly caused by the running-time scheduling model GMP in Go language, G in the running-time scheduling model GMP represents Goroutine, i.e., go coroutine, M represents Machine or worker thread, i.e., system thread in the conventional sense, and P represents Processor, i.e., user-level code logic Processor. As shown in fig. 1, the scheduling unit in Go language is a Go coroutine, and the Go coroutine in the LRQ of a logical processor P queue cannot be executed only when a system thread M is associated with the logical processor P unless the system thread M is blocked or has no associated logical processor P for too long a system call.

Under the GMP model, if the running time of the function of the Go language is too long, the Go coroutines are preempted, and the Garbage Collection (GC) executes, so that all the Go coroutines are suspended; and when the function of the Go language calls the function of the C language, the execution of the function of the C language can limit the scheduling behavior of the Go language runtime, and at the moment, the system thread M running the C language is marked and removed from the scheduling range of the Go language runtime.

In addition, the stack space size of the Go coroutine is dynamically changed, and is initially 2KB, and the execution of the function of the C language may require a statically unknown larger stack space, so that the function of the C language is not suitable for being directly executed on the stack space of the Go coroutine. The Go language running has a special Go coroutine g0 which is responsible for scheduling and managing each Go coroutine running on the system thread M; the special Go coroutine g0 may be allocated a system stack that is fixed in size and exceeds the conventional Go coroutine stack upon initialization of the system thread M. As shown in fig. 2, when a function in the Go language calls a function in the C language, the function is switched to the system stack of the special Go coroutine g0 to be executed, and when the function in the C language calls a function in the Go language, the function needs to be switched back; this switching is the main reason for the high CGO call overhead.

Disclosure of Invention

In order to solve the technical problem, the invention provides a high-performance CGO cross-language calling method.

In order to solve the technical problems, the invention adopts the following technical scheme:

a high-performance CGO cross-language calling method is used for performing inertia unbinding on a logic processor P and a system thread M in Go language cross-language inter-modulation: in the mutual calling process of Go language and C language, if Go co-program receives the preemption signal sent by Go language, the following steps are carried out:

a) Jumping to a signal processing function of Go language;

b) Unbinding a logic processor P and a system thread M where the current Go coroutine is positioned, and marking to enter a system call state;

c) Turning to the function execution of the C language, wherein the system thread M is divided out of the runtime scheduling range of the Go language;

d) When the execution of the function in the C language is finished or the function in the C language is called back to the function in the Go language, whether the logic processor P and the system thread M are unbound before the execution of the function in the C language is judged, if so, the logic processor P and the system thread M are bound again and then the function in the Go language is executed.

Further, the method comprises the steps of canceling stack switching in cross-language inter-modulation of Go language and C language:

at the time of compiling the Go language program, the stack Space of the function of the C language is acquired by using the upper bound Space _c : user designation, static analysis of function execution in C language, default size;

when the function of Go language calls the function of C language, according to Space _c The value of (1) indicates the size of stack space for executing the Go coroutine of the C language function, so that the C language function and the Go language function can run in the same block stack space of the Go coroutine.

Compared with the prior art, the invention has the beneficial technical effects that:

the invention cancels the operation of the unbinding logic processor P and the system thread M from the whole cross-language calling flow, and is called only when the Go language is operated to try to seize the Go co-program in the HCGO calling process, thereby ensuring that the cross-language calling does not need to execute the operation under most conditions; the cross-language call chain is optimized by canceling stack switching, and the call overhead is reduced.

Drawings

Fig. 1 is a schematic diagram of a runtime scheduling model GMP in Go language;

fig. 2 is a prior art calling schematic diagram of a cross-language intermodulation mechanism CGO;

FIG. 3 (a) is a flowchart of executing a function of the Go language in the high performance cross-language call mechanism HCGO to normally call a function of the C language;

FIG. 3 (b) is a flowchart illustrating the execution of the C language function in the high performance cross-language call mechanism HCGO with preemption;

FIGS. 4 (a) and 4 (b) are schematic diagrams of a backtracking mechanism based on stack camouflage in the high-performance cross-language call mechanism HCGO of the invention;

fig. 5 (a) and 5 (b) are a schematic diagram of a Go language function calling a C language function and a schematic diagram of a C language function calling a Go language function in the high-performance cross-language calling mechanism HCGO according to the present invention, respectively.

Detailed Description

A preferred embodiment of the present invention will be described in detail below with reference to the accompanying drawings.

CGO is a mechanism provided by Go language that allows Go language and C language to call each other. Aiming at the defects of long CGO call chain and high call overhead, the invention provides a high-performance cross-language call mechanism HCGO, which optimizes the CGO call chain by two optimization ideas of 'inertia unbinding of a logic processor P and a system thread M' and 'stack switching cancellation', improves the performance of CGO call on the premise of keeping the safety and the function unchanged, and reduces the call overhead of CGO. Experiments show that compared with a native CGO calling mechanism, the high-performance CGO cross-language calling method can achieve about 7 times of performance improvement under the scene that the Go language calls the C language.

The high-performance CGO cross-language calling method mainly comprises three parts: and (3) adapting a Go language program compiling flow, a CGO calling flow during running and other mechanisms during running.

The Go language program compiling process is mainly characterized in that a Go compiler is modified, and on the premise of being compatible with a native CGO calling mechanism, recognition and adaptation of a new high-performance cross-language calling mechanism HCGO are added; the CGO call flow during the operation mainly optimizes the cross-language call chain by inertia unbinding the logic processor P and the system thread M and canceling stack switching, thereby reducing the call overhead; the adaptation of the rest mechanisms in the runtime is to ensure the Go language runtime security and functional integrity under the high-performance cross-language call mechanism HCGO by implementing a traceback (trace) mechanism based on stack masquerading and modifying part of runtime functions.

Go language program compiling process

The high performance cross-language invocation mechanism HCGO supports starting from different granularities using three different approaches:

(1) The high-performance cross-language calling mechanism HCGO is started through an [ import 'HC' ] mark in the Go language code, and [ HC.xxx ] is used for indicating xxx functions to execute cross-language calling by using the high-performance cross-language calling mechanism HCGO.

(2) A parameter-HCGO is added into a compiling command of Go language, and all compiled files use a high-performance cross-language calling mechanism HCGO at the moment.

(3) Setting "HCGO = true" in the environment variable, all Go programs will use the high performance cross language call mechanism HCGO at this time.

2. Runtime CGO call flow

In the calling process of the native CGO, three steps are required before and after calling a function in C language:

(1) Unbinding logical processor P and system thread M and marking entry into the system call state (or binding logical processor P and system thread M and marking exit from the system call state);

(2) Switching the Go coroutine, namely switching from the ordinary Go coroutine to the special Go coroutine g0, so that the execution of the function of the C language is switched to the system stack of the special Go coroutine g 0;

(3) The conversion of the ABI calling convention is performed.

In the calling process of the high-performance cross-language calling mechanism HCGO, unnecessary unbinding operation is removed through the inertia unbinding logic processor P and the system thread M, the switching operation of the Go corollary is cancelled through cancelling stack switching, and only the conversion of ABI calling convention needs to be executed before and after function calling of C language.

2.1 lazy unbinding of logical processor P and System thread M

In the design of the high-performance cross-language calling mechanism HCGO, the Go coroutine does not execute the unbinding operation of the logical processor P and the system thread M before the function of the C language is called every time, but cancels the operation of unbinding the logical processor P and the system thread M from the whole calling flow, and is called only when the Go language runtime tries to preempt the Go coroutine in the calling process of the high-performance cross-language calling mechanism HCGO, so that the cross-language calling in most cases does not need to execute the operation.

As shown in fig. 3 (a), in general, the call flow of the high-performance cross-language call mechanism HCGO does not perform the unbinding operation; as shown in fig. 3 (b), when a Go coroutine in the high performance cross-language calling mechanism HCGO calling process receives a preemption signal sent by a Go language runtime, the following process is performed:

(1) Jumping to a signal processing function of Go language;

(2) Unbinding a logic processor P and a system thread M where the current Go coroutine is positioned, and marking to enter a system call state;

(3) The function of the C language is normally executed; at the moment, the system thread M is already divided out of the running scheduling range of the Go language, and the preemption of the Go language cannot be blocked any more;

(4) When the execution of the C language function is finished or the C language function calls back the Go language function, the judgment on the current states of the logic processor P and the system thread M is added, and if the unbinding operation is found to be executed in the C language function execution process, the function is bound again and then the Go language function is executed.

2.2 cancelling Stack switching

In the Go language, since the size of the Go protocol stack space may be difficult to support the invocation of any C language function, the native CGO invocation mechanism needs to switch the stack space where the C language function runs onto the system stack of the special Go protocol g0 first when executing the cross-language invocation. This operation violates memory locality, which results in higher cache misses.

In the design of the high-performance cross-language call mechanism HCGO, firstly, at the Go program compiling stage, by modifying the CGO compiling flow, the use upper bound of the function stack space of the C language can be obtained by one of the following three ways: (1) user designation; (2) performing a static analysis on the function of the C language; (3) default to 8MB; thus, at runtime, the Go coroutine, which can indicate that a C language function call is about to be made, needs at least much stack space. Secondly, modifying a cross-language calling chain of the CGO at a runtime calling stage, and expanding the stack space of the Go coroutine to a specified size through a stack expansion mechanism provided by the Go language runtime before executing the function of the C language so as to support the calling of the function of the C language; in the next call flow, the operation of stack switching is cancelled, and the function in the C language and the function in the Go language run in the same block stack space.

3. Adaptation of remaining mechanisms at runtime

Because the operations of unbinding and stack switching of the logical processor P and the system thread M are cancelled in the high-performance cross-language call mechanism HCGO and some assumptions of the Go language runtime on a CGO call mechanism are broken, the other mechanisms in the runtime need to be adapted in order to maintain the safety and the functional integrity of the Go language runtime.

3.1 traceback mechanism based on Stack camouflage

The backtracking mechanism in Go language is used in many scenarios: such as stack scanning during garbage collection, stack copying during stack expansion/contraction, error message printing during program crash, etc. Under these scenes, the backtracking mechanism scans the stack frames of each function from the current stack frame of the Go protocol to the bottom of the stack in sequence, thereby implementing the above functions.

In the high-performance cross-language calling mechanism HCGO, a function of a C language called by a function of a Go language and a function of the Go language run in the same stack space, and a trace-back mechanism of the Go language cannot or should not scan a stack frame of the function of the C language, so that a set of trace-back mechanism based on stack camouflage is further realized in the high-performance cross-language calling mechanism HCGO, as shown in fig. 4 (a) and 4 (b).

In order to conveniently locate the stack frame record of the last Go language function before the call of the C language function, the high-performance cross-language call mechanism HCGO introduces a field hcgopc for storing a current program counter called by the Go language function and a field hcgosp for storing a stack top pointer of a stack frame. For the case that the function in the Go language calls the function in the C language through the high-performance cross-language call mechanism HCGO, and then calls back the Go language function, when the function in the C language calls back the function in the first Go language, the value of the current hcgosp is pushed (i.e. the top pointer of the last Go language function of the Go language function is saved) so as to be used for backtracking. After the backtracking scan is triggered:

(1) If the current Go coroutine is identified to be in the C language function calling process of the high-performance cross-language calling mechanism HCGO, as shown in fig. 4 (a), a backtracking mechanism skips a stack frame of a current C language function through a domain hcgopc and a domain hcgosp which are recorded in advance, and backtracking is directly executed from the stack frame of the last Go language function before the high-performance cross-language calling mechanism HCGO calls;

(2) If the current Go co-routine is identified to be in the process of calling back the Go language function of the high-performance cross-language call mechanism HCGO, as shown in fig. 4 (b), the C language function is skipped by acquiring the top pointer of the last Go language function in the first Go language function stack frame stored in advance after the C language function calling back the Go language function.

3.2 modification of other runtime mechanisms

In the Go language runtime mechanism, there is a special adaptation for the CGO call mechanism, however, for the high performance cross-language call mechanism HCGO, since the runtime state and the state of the CGO mechanism are not exactly the same, some adaptations performed by function calls in C language at runtime will fail. Therefore, after the differences of the high-performance cross-language calling mechanism HCGO and the native CGO calling mechanism in Go runtime are analyzed, the partial runtime mechanisms are modified according to the differences. This modification involves the crash error reporting mechanism, the signal processing mechanism, and the backtracking mechanism of Go.

(1) Crash error reporting mechanism. Because the Go protocol is not switched in the execution process of the high-performance cross-language calling mechanism HCGO, the HCGO enters a pancic error reporting flow during crash processing, and the crash error reporting executed by an external code enters a final error reporting flow, the Go-language crash error reporting mechanism is modified, so that the crash processing in the high-performance cross-language calling mechanism HCGO can enter the final error reporting flow.

(2) A signal processing mechanism. For the high-performance cross-language calling mechanism HCGO which does not execute the operation of the unbundling logic processor P and the system thread M, the Go language runtime cannot sense that external codes are executed, so that the signal processing flow of a normal Go coroutine can be regarded during signal processing. Therefore, the signal processing mechanism of Go is modified, so that the signal processing flow under the CGO calling mechanism is executed in the calling process of the high-performance cross-language calling mechanism HCGO; when some specific signals are received, the runtime forwards the signals to a function of the C language which is currently executed on the Go protocol; when the signal stack position of the Go language is adjusted, the signal stack position is adjusted to be a Go coroutine for executing high-performance cross-language calling mechanism HCGO calling.

(3) A backtracking mechanism. And modifying a backtracking mechanism, so that the high-performance cross-language calling mechanism HCGO supports setting of a CGO callback function (used for supporting custom scanning of a function stack frame of the C language) in a custom backtracking process.

4. Advantages and positive effects

TABLE 1 overhead comparison table for high performance cross-language call mechanism HCGO and CGO

Calling mode	HCGO overhead	CGO overhead	Acceleration ratio
				Invoking C language by Go language	9.488ns	69.90ns	7.367
C language call Go language (Go language is host language)	72.274ns	119.749ns	1.657
				Calling Go language by C language (host language is C language)	3852.35ns	3904.44ns	1.014

Table 2 shows the comparison of the call overheads of the HCGO and CGO call mechanisms in several different call modes. The experimental setup for the test call overhead is as follows: the cross-language call to the empty function is repeatedly executed N times (N is a million level constant), the total time T spent is recorded, and the single average call time is recorded in the table, i.e. T = T/N. As can be seen from the table, under the scene that the C language is called by using the Go language most, the high-performance cross-language calling mechanism HCGO can achieve the acceleration ratio more than 7 times; under the scene that Go language is used as host language and C language calls Go language, the high-performance cross-language calling mechanism HCGO can also reach about 1.6 times of speed-up ratio; under the scenario that the C language is used as the host language and the C language calls the Go language, the runtime initialization operation of the Go needs to be started before entering the call chain, and the runtime initialization operation occupies higher overhead, which results in that the acceleration of the high-performance cross-language call mechanism HCGO is not obvious compared with the acceleration of the CGO call mechanism.

Meanwhile, under the condition that the high-performance cross-language calling mechanism HCGO is used, the safety test related to CGO in the Go language community can be passed in a full amount, and the high-performance cross-language calling mechanism HCGO has certain safety.

In the high-performance cross-language calling mechanism HCGO, the flow of the Go language function calling the C language function is as shown in fig. 5 (a), and when the Go language function calls the C language function by means of [ c.xxx ] or [ hc.xxx ], the following three steps are executed:

(1) Entering the runtime function runtime. Hcgocall, the function runtime. Hcgocall works in two ways: performing stack expansion before calling the function of the C language; setting related marking bits such as hcgopc and hcgosp of a high-performance cross-language calling mechanism HCGO, and performing state conversion;

(2) Calling a compilation function runtime. Asmhcgocall to perform ABI calling convention conversion between C language and Go language;

(3) And calling a function of the C language.

The flow of calling Go language function by C language function under the high-performance cross-language calling mechanism HCGO is shown in fig. 5 (b), when the function of C language initiates the call to the function of Go language, the high-performance cross-language calling mechanism HCGO will execute the following five steps:

(1) Calling a cross 2 function to execute the conversion of the ABI calling convention;

(2) Executing an assembly function runtime. Cgacallback, judging whether the current calling flow is the calling flow of the high-performance cross-language calling mechanism HCGO, if so, entering a calling chain of the high-performance cross-language calling mechanism HCGO, otherwise, executing the calling chain of the native CGO;

(3) Executing a runtime function runtime. Hcgocallback, and setting and saving related mark bits of a high-performance cross-language call mechanism HCGO (such as saving a pc and an sp to a stack);

(4) The runtime. Hcgocalcallback function is executed to save the system call state to prevent modification during callback;

(5) The runtime. Hcgocalbackkg1 function is executed to prepare parameters and call a function of the actual Go language.

Examples

The first enabling mode of the high-performance cross-language calling mechanism HCGO is as follows: the high-performance cross-language calling mechanism HCGO can start reference by using [ import "HC" ] in the code and call a C function named sum by [ HC.sum ]; the code is illustrated as follows:

// HCGO enable mode one

//int sum(int a,int b){return a+b；}

import“HC”

func main(){

HC.sum(1,2)

}。

Since the high-performance cross-language calling mechanism HCGO-enabled mode needs to modify [ import "C" ] in the application code to [ import "HC" ] for use, two modes without modifying the application code are provided as follows: the second enabling mode is realized by adding an [ -HCGO ] parameter in a compiling command, and the third enabling mode is realized by setting a system environment variable [ HCGO = true ]; the code is illustrated as follows:

# HCGO Enabled mode two

$go run sum_cgo.go-hcgo；

# HCGO enablement mode three

$HCGO＝true go run sum_cgo.go。

It will be evident to those skilled in the art that the invention is not limited to the details of the foregoing illustrative embodiments, and that the present invention may be embodied in other specific forms without departing from the spirit or essential attributes thereof. The present embodiments are therefore to be considered in all respects as illustrative and not restrictive, the scope of the invention being indicated by the appended claims rather than by the foregoing description, and all changes which come within the meaning and range of equivalency of the claims are therefore intended to be embraced therein, and any reference signs in the claims are not intended to be construed as limiting the claim concerned.

Furthermore, it should be understood that although the present description refers to embodiments, not every embodiment may contain only a single embodiment, and such description is for clarity only, and those skilled in the art should integrate the description, and the embodiments may be combined as appropriate to form other embodiments understood by those skilled in the art.

Claims (2)

1. A high-performance CGO cross-language calling method is characterized in that inertia unbundling is carried out on a logic processor P and a system thread M in Go language cross-language calling: in the mutual calling process of Go language and C language, if Go co-program receives the preemption signal sent by Go language, the following steps are carried out:

a) Jumping to a signal processing function of Go language;

b) Unbinding a logic processor P where the current Go coroutine is located and a system thread M, and marking to enter a system calling state;

c) Turning to the function execution of the C language, wherein the system thread M is divided out of the runtime scheduling range of the Go language;

d) When the execution of the function in the C language is finished or the function in the C language is called back to the function in the Go language, whether the logic processor P and the system thread M are unbound before the execution of the function in the C language is judged, if so, the logic processor P and the system thread M are bound again and then the function in the Go language is executed.

2. The method of claim 1, comprising canceling stack switching in Go and C cross-language intercrossing:

at the time of the Go language program compilation, the upper bound Space is used for acquiring the stack Space of the function of the C language in the following way _c : user designation, static analysis of function execution in C language, default size;

when the function of Go language calls the function of C language, according to Space _c The value of (1) indicates the size of stack space for executing the Go coroutine of the C language function, so that the C language function and the Go language function can run in the same block stack space of the Go coroutine.

Images