Comprendre les opérations du pointeur et l'utilisation du processeur/de la mémoire

l'éditeur php Banana vous présentera les opérations du pointeur et l'utilisation du CPU/mémoire. En programmation, la manipulation du pointeur est un outil puissant qui peut accéder et modifier directement les données en mémoire. En comprenant les opérations des pointeurs, vous pouvez mieux contrôler et optimiser les performances de votre code. De plus, comprendre l’utilisation du processeur et de la mémoire est également très important pour optimiser les programmes. En surveillant et en analysant l'utilisation du processeur et de la mémoire, vous pouvez identifier les problèmes de performances potentiels et prendre les mesures appropriées pour améliorer l'efficacité du fonctionnement du programme. Dans cet article, nous vous présenterons en détail les connaissances pertinentes sur les opérations de pointeur et l’utilisation du processeur/mémoire pour vous aider à mieux les comprendre et les appliquer.

Contenu de la question

Je discutais avec un collègue de travail pour savoir s'il serait plus efficace de passer des pointeurs vers des fonctions et/ou de renvoyer des pointeurs.

J'ai rassemblé quelques fonctions de référence pour tester différentes façons de procéder. Ces fonctions prennent essentiellement une variable, la convertissent et la renvoient. Nous avons 4 méthodes différentes :

1. Transmettez la variable comme d'habitude, créez une nouvelle variable pour le résultat de la conversion et renvoyez-en une copie
2. Passez la variable normalement, créez une nouvelle variable pour le résultat de la conversion et renvoyez l'adresse mémoire
3. Passez un pointeur vers une variable, créez une nouvelle variable pour le résultat de la conversion et renvoyez une copie de la variable
4. Passez un pointeur vers une variable et convertissez la valeur du pointeur sans rien retourner.

package main

import (
    "fmt"
    "testing"
)

type mystruct struct {
    mystring string
}

func acceptparamreturnvariable(s mystruct) mystruct {
    ns := mystruct{
        fmt.sprintf("i'm quoting this: \"%s\"", s.mystring),
    }
    return ns
}

func acceptparamreturnpointer(s mystruct) *mystruct {
    ns := mystruct{
        fmt.sprintf("i'm quoting this: \"%s\"", s.mystring),
    }
    return &ns
}

func acceptpointerparamreturnvariable(s *mystruct) mystruct {
    ns := mystruct{
        fmt.sprintf("i'm quoting this: \"%s\"", s.mystring),
    }
    return ns
}

func acceptpointerparamnoreturn(s *mystruct) {
    s.mystring = fmt.sprintf("i'm quoting this: \"%s\"", s.mystring)
}

func benchmarknormalparamreturnvariable(b *testing.b) {
    s := mystruct{
        mystring: "hello world",
    }
    var ns mystruct
    for i := 0; i < b.n; i++ {
        ns = acceptparamreturnvariable(s)
    }
    _ = ns
}

func benchmarknormalparamreturnpointer(b *testing.b) {
    s := mystruct{
        mystring: "hello world",
    }
    var ns *mystruct
    for i := 0; i < b.n; i++ {
        ns = acceptparamreturnpointer(s)
    }
    _ = ns
}

func benchmarkpointerparamreturnvariable(b *testing.b) {
    s := mystruct{
        mystring: "hello world",
    }
    var ns mystruct
    for i := 0; i < b.n; i++ {
        ns = acceptpointerparamreturnvariable(&s)
    }
    _ = ns
}

func benchmarkpointerparamnoreturn(b *testing.b) {
    s := mystruct{
        mystring: "hello world",
    }
    for i := 0; i < b.n; i++ {
        acceptpointerparamnoreturn(&s)
    }
    _ = s
}

J'ai trouvé les résultats assez surprenants.

$ go test -run=XXXX -bench=. -benchmem
goos: darwin
goarch: amd64
pkg: XXXX
cpu: Intel(R) Core(TM) i9-9980HK CPU @ 2.40GHz
BenchmarkNormalParamReturnVariable-16           10538138               103.3 ns/op            48 B/op          2 allocs/op
BenchmarkNormalParamReturnPointer-16             9526380               201.2 ns/op            64 B/op          3 allocs/op
BenchmarkPointerParamReturnVariable-16           7542066               147.0 ns/op            48 B/op          2 allocs/op
BenchmarkPointerParamNoReturn-16                   45897            119265 ns/op          924351 B/op          5 allocs/op

Avant d'exécuter cela, j'ai pensé que le moyen le plus efficace serait le quatrième test, puisqu'aucune nouvelle variable n'est créée dans le cadre de la fonction appelée et que seule l'adresse mémoire est transmise, cependant, il semble que le quatrième soit le moins efficace, prend le plus de temps et utilise le plus de mémoire.

Quelqu'un peut-il m'expliquer cela ou me fournir de bons liens de lecture qui expliquent cela ?

Solution de contournement

Le benchmark que vous avez effectué ne répond pas à la question que vous avez posée. Il s’avère que le microbenchmarking est extrêmement difficile – pas seulement dans le monde du go, mais en général.

Revenons à la question de l’efficacité. Normalement, le passage de pointeurs vers des fonctions n'est pas échappé au tas. Normalement, les pointeurs renvoyés par les fonctions s'échappent vers le tas. C'est généralement le mot clé ici. Vous ne pouvez pas vraiment savoir quand le compilateur alloue quelque chose sur la pile et quand il alloue quelque chose sur le tas. Ce n’est pas un petit problème. Une très bonne brève explication peut être trouvée ici.

Mais si vous avez besoin de savoir, vous pouvez demander. Vous pouvez commencer par simplement imprimer les décisions d'optimisation prises par le compilateur. Vous pouvez le faire en ajoutant m 标志传递给 go 工具compile.

go build -gcflags -m=1

Si vous transmettez un entier supérieur à 1, vous obtiendrez un résultat plus détaillé. Si cela ne vous donne pas les réponses dont vous avez besoin pour optimiser votre programme, essayez Analyse. Cela va bien au-delà de l’analyse de la mémoire.

En général, ne vous inquiétez pas des décisions d’optimisation naïves dans votre travail quotidien. Ne vous attardez pas trop sur "habituellement..." car dans le monde réel, on ne sait jamais. Visez toujours d’abord l’optimisation de l’exactitude. Ensuite, n’optimisez les performances que si vous en avez vraiment besoin et prouvez que vous en avez besoin. Ne devinez pas, ne croyez pas. Gardez également à l’esprit que go évolue, donc ce que nous prouvons dans une version ne sera pas nécessairement vrai dans une autre.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!