Warum ist meine Cgo-Funktion so viel langsamer als meine entsprechende Go-Funktion?

Warum die Leistung von Cgo verblüffend langsam ist: Untersuchung eines Testfalls

Bei dem wiederholten Versuch, die Ausführungszeiten von Cgo- und reinen Go-Funktionen zu vergleichen, stieß ein Tester auf unerwartete Ergebnisse . Die Cgo-Funktion dauerte deutlich länger als die Golang-Funktion, was zu Verwirrung und einer Untersuchung des Testcodes führte.

Der fragliche Testcode

Der unten bereitgestellte Testcode vergleicht die Ausführungszeiten für Cgo und reine Go-Funktionen, die jeweils 100 Millionen Mal ausgeführt wurden:

import (
    "fmt"
    "time"
)

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

void show() {

}

*/
// #cgo LDFLAGS: -lstdc++
import "C"

//import "fmt"

func show() {

}

func main() {
    now := time.Now()
    for i := 0; i < 100000000; i = i + 1 {
        C.show()
    }
    end_time := time.Now()

    var dur_time time.Duration = end_time.Sub(now)
    var elapsed_min float64 = dur_time.Minutes()
    var elapsed_sec float64 = dur_time.Seconds()
    var elapsed_nano int64 = dur_time.Nanoseconds()
    fmt.Printf("cgo show function elasped %f minutes or \nelapsed %f seconds or \nelapsed %d nanoseconds\n",
        elapsed_min, elapsed_sec, elapsed_nano)

    now = time.Now()
    for i := 0; i < 100000000; i = i + 1 {
        show()
    }
    end_time = time.Now()

    dur_time = end_time.Sub(now)
    elapsed_min = dur_time.Minutes()
    elapsed_sec = dur_time.Seconds()
    elapsed_nano = dur_time.Nanoseconds()
    fmt.Printf("go show function elasped %f minutes or \nelapsed %f seconds or \nelapsed %d nanoseconds\n",
        elapsed_min, elapsed_sec, elapsed_nano)

    var input string
    fmt.Scanln(&amp;input)
}

Unerwartete Ergebnisse und Suche nach Antworten

Die erhaltenen Ergebnisse Aus dem Testcode ging hervor, dass der Aufruf der C-Funktion deutlich langsamer war als der Aufruf der Go-Funktion. Dies führte zu der Frage, ob im Testcode selbst ein Fehler vorlag.

Eintauchen in die Leistungsherausforderungen von Cgo

Während der bereitgestellte Testcode gültig ist, tragen die inhärenten Leistungseinschränkungen von Cgo dazu bei die langsamere Ausführungszeit, die für die Cgo-Funktion beobachtet wurde.

Das Aufrufen von C/C-Code über Cgo verursacht einen relativ hohen Overhead und die Minimierung dieser CGo Anrufe werden grundsätzlich empfohlen. In diesem speziellen Szenario könnte das Verschieben der Schleife nach C, anstatt wiederholt eine CGo-Funktion von Go aus aufzurufen, möglicherweise die Leistung verbessern.

Zusätzlich verwendet CGo ein separates Thread-Setup für die Ausführung von C-Code, wobei bestimmte Annahmen über den Code getroffen werden Verhalten. Einige dieser Annahmen können zu Leistungseinbußen führen:

• Goroutinen in Go nutzen relativ kleine Stapel und verarbeiten das Stapelwachstum dynamisch.
• Die Thread-Verarbeitung von CGo kann die lokale Thread-Speicherimplementierung von libpthread beeinträchtigen.
• Gos UNIX-Signalhandler kann herkömmliches C oder C stören Code.
• Die Wiederverwendung von Betriebssystem-Threads für mehrere Goroutinen kann negative Folgen haben, wenn C-Code Systemaufrufe blockiert oder den Thread monopolisiert.

Fazit

Die Rolle von CGo sollte es sein soll in erster Linie als Gateway zur Schnittstelle zu vorhandenen Bibliotheken angesehen werden, möglicherweise mit zusätzlichen kleinen C-Wrapper-Funktionen, um die Anzahl der Aufrufe von Go zu reduzieren. Die Erwartung von C-ähnlichen Leistungsoptimierungen durch CGo wird im Allgemeinen nicht erfüllt, da zwischen äquivalentem C- und Go-Code bereits eine geringere Leistungslücke besteht.

Das obige ist der detaillierte Inhalt vonWarum ist meine Cgo-Funktion so viel langsamer als meine entsprechende Go-Funktion?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!