Tests et analyse de référence du cache de fonctions Golang

Oui, l'utilisation du cache de fonctions peut améliorer considérablement les performances des fonctions coûteuses, car après le premier appel, le résultat de la fonction sera mis en cache et les appels suivants pourront être obtenus directement à partir du cache. Écrivez des scénarios de test pour vérifier que le cache fonctionne comme prévu, notamment en vérifiant les taux de réussite du cache. Quantifiez les gains de performances liés à la mise en cache à l'aide de tests comparant la vitesse d'exécution des versions mises en cache et non mises en cache.

Test et analyse comparative du cache de fonctions Go

Introduction

L'utilisation du cache de fonctions dans Go est une technique efficace pour améliorer les performances, en particulier lorsque l'exécution de fonctions est coûteuse. Lors de l'utilisation du cache de fonctions, le premier appel à la fonction effectuera le calcul réel et les appels suivants obtiendront les résultats directement à partir du cache.

Vérification du cache basée sur les tests

Il est crucial d'écrire des cas de test pour vérifier que le cache fonctionne comme prévu. Voici un exemple de test d'un cache de fonctions de base :

import (
    "testing"
    "time"
)

// fibonacci 计算斐波那契数
func fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return fibonacci(n-1) + fibonacci(n-2)
}

// fibonacciWithCache 使用缓存的斐波那契函数
var fibonacciWithCache = cache.Memoize(fibonacci)

func TestFibonacciCache(t *testing.T) {
    tests := []struct {
        input, expected int
    }{
        {1, 1},
        {2, 1},
        {5, 5},
        {10, 55},
    }

    for _, test := range tests {
        start := time.Now()
        actual := fibonacciWithCache(test.input)
        elapsed := time.Since(start)

        if actual != test.expected {
            t.Errorf("Expected %d but got %d", test.expected, actual)
        }

        // 检查缓存命中率
        if elapsed > 50*time.Microsecond {
            t.Errorf("Expected cache hit but got cache miss")
        }
    }
}

Benchmarks

Les benchmarks aident à quantifier les gains de performances liés à la mise en cache des fonctions. Voici comment comparer les versions non mises en cache et mises en cache de la fonction Fibonacci :

func BenchmarkFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fibonacci(20)
    }
}

func BenchmarkFibonacciWithCache(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fibonacciWithCache(20)
    }
}

Dans le résultat du benchmark, vous pouvez voir que la version mise en cache de la fonction s'exécute beaucoup plus rapidement que la version non mise en cache :

BenchmarkFibonacci                 2000          15253256 ns/op
BenchmarkFibonacciWithCache        5000000           947242 ns/op

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!