Quel est le moyen le plus rapide pour générer une longue chaîne de caractères aléatoires dans le jeu de Go?

Ce n'environ 200 mbps sur ma boîte. Il est évident de place pour l'amélioration.

type randomDataMaker struct {
    src rand.Source
}

func (r *randomDataMaker) Read(p []byte) (n int, err error) {
    for i := range p {
        p[i] = byte(r.src.Int63() & 0xff)
    }
    return len(p), nil
}

Vous devriez juste utiliser io.CopyN pour produire de la chaîne que vous souhaitez. Évidemment, vous pouvez ajuster le jeu de caractères sur le chemin, ou que ce soit.

La bonne chose à propos de ce modèle est qu'il est juste un io.Reader de sorte que vous pouvez l'utiliser rien faire.

Test est ci-dessous:

func BenchmarkRandomDataMaker(b *testing.B) {
    randomSrc := randomDataMaker{rand.NewSource(1028890720402726901)}
    for i := 0; i < b.N; i++ {
        b.SetBytes(int64(i))
        _, err := io.CopyN(ioutil.Discard, &randomSrc, int64(i))
        if err != nil {
            b.Fatalf("Error copying at %v: %v", i, err)
        }
    }
}

Sur un cœur de mon 2.2 GHz i7:

BenchmarkRandomDataMaker       50000        246512 ns/op     202.83 MB/s

MODIFIER

Depuis que j'ai écrit l'indice de référence, j'ai pensé que je ferais de l'amélioration évidente de la chose en appellent à l'aléatoire de moins en moins souvent). 1/8 les appels à la rand corporation, il fonctionne environ 4x plus rapide, mais c'est un gros plus laide:

Nouvelle version:

func (r *randomDataMaker) Read(p []byte) (n int, err error) {
    todo := len(p)
    offset := 0
    for {
        val := int64(r.src.Int63())
        for i := 0; i < 8; i++ {
            p[offset] = byte(val & 0xff)
            todo--
            if todo == 0 {
                return len(p), nil
            }
            offset++
            val >>= 8
        }
    }

    panic("unreachable")
}

Nouvelle référence:

BenchmarkRandomDataMaker      200000        251148 ns/op     796.34 MB/s

EDIT 2

Pris le masquage dans la distribution de l'octet, car il est redondant. Obtenu une bonne affaire plus rapide:

BenchmarkRandomDataMaker      200000        231843 ns/op     862.64 MB/s

(c'est tellement plus facile que d'un réel travail soupir)

MODIFIER 3

J'en irc aujourd'hui, j'ai donc sorti une bibliothèque. Aussi, mon outil de référence, tout en étant utile pour la vitesse relative, n'est pas suffisamment précise dans son rapport.

J'ai créé randbo que vous pouvez réutiliser pour produire aléatoire des ruisseaux où vous pourriez en avoir besoin.

OriginalL'auteur Dustin

C'est en fait un peu biaisé vers les 8 premiers caractères dans le jeu (depuis 255 n'est pas un multiple de len(alphanum)), mais cela vous obtiendrez la plupart du chemin.

import (
    "crypto/rand"
)

func randString(n int) string {
    const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
    var bytes = make([]byte, n)
    rand.Read(bytes)
    for i, b := range bytes {
        bytes[i] = alphanum[b % byte(len(alphanum))]
    }
    return string(bytes)
}

OriginalL'auteur Evan Shaw

Si vous voulez générer des cryptographique sécurisé chaîne aléatoire, je vous recommande de jeter un oeil à cette page. Voici une fonction d'assistance qui lit n octets aléatoires à partir de la source de l'aléatoire de votre système d'exploitation, et d'utiliser ensuite ces octets à base64encode. Notez que la longueur de la chaîne serait plus grand que n en raison de base64.

package main

import(
    "crypto/rand"
    "encoding/base64"
    "fmt"
)

func GenerateRandomBytes(n int) ([]byte, error) {
    b := make([]byte, n)
    _, err := rand.Read(b)
    if err != nil {
        return nil, err
    }

    return b, nil
}

func GenerateRandomString(s int) (string, error) {
    b, err := GenerateRandomBytes(s)
    return base64.URLEncoding.EncodeToString(b), err
}

func main() {
    token, _ := GenerateRandomString(32)
    fmt.Println(token)
}

OriginalL'auteur Salvador Dali