Comment améliorer la vitesse de lecture d'un gros fichier ligne par ligne dans Go

Vous pouvez essayer d'utiliser des goroutines pour traiter plusieurs lignes en parallèle:

lines := make(chan string, numWorkers * 2) // give the channel enough room to put lots of things in so the reader isn't blocked

go func(scanner *bufio.Scanner, out <-chan string) {
  for scanner.Scan() {
    out <- scanner.Text()
  }
  close(out)
}(scanner, lines)

var wg sync.WaitGroup
wg.Add(numWorkers)

for i := 0; i < numWorkers; i++ {
  go func(in chan<- string) {
    defer wg.Done()
    for text := range in {
      if strings.Contains(text, "Iforgotmypassword") {
        fmt.Println(scanner.Text())
      }
    }
  }(lines)
}

wg.Wait()

Je ne sais pas dans quelle mesure cela accélérera vraiment les choses car cela dépend du type de matériel dont vous disposez ; il semble que vous recherchiez une amélioration de la vitesse supérieure à 5x, vous remarquerez peut-être si vous exécutez quelque chose qui peut prendre en charge 8 threads de travail parallèles. N'hésitez pas à utiliser beaucoup d'ouvriers-goroutines. Bonne chance.

DERNIÈRE MODIFICATION

Il s'agit d'une solution "ligne par ligne" au problème qui prend un temps insignifiant, elle imprime toute la ligne correspondante.

dat, _ := ioutil.ReadFile("./jumble.txt")
sdat := bytes.Split(dat, []byte{'\n'})
for _, l := range sdat {
    if bytes.Equal([]byte("Iforgotmypassword"), l) {
        fmt.Println("Yes")
    }
}

En utilisant mon propre fichier de test de 700 Mo avec votre original, le temps était d'un peu plus de 7 secondes

Avec grep, il était de 0,49 seconde

Avec ce programme (qui n'imprime pas la ligne, il dit oui) 0,082 seconde

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
    "os"
)

func check(e error) {
    if e != nil {
        panic(e)
    }
}
func main() {
    find := []byte(os.Args[1])
    dat, err := ioutil.ReadFile("crackstation-human-only.txt")
    check(err)
    if bytes.Contains(dat, find) {
        fmt.Print("yes")
    }
}

H. La réponse de Ross est géniale, mais elle lit le fichier entier en mémoire, ce qui peut ne pas être faisable si votre fichier est trop gros. Si vous souhaitez toujours numériser ligne par ligne, peut-être si vous recherchez plusieurs éléments, j'ai trouvé que l'utilisation de scanner.Bytes () au lieu de scanner.Text () améliore légèrement la vitesse sur ma machine, à partir de 2,244 s pour le question originale, à 1.608s. La méthode scanner.Bytes () de bufio n'alloue pas de mémoire supplémentaire, tandis que Text () crée une chaîne à partir de son tampon.

package main

import (
    "bufio"
    "fmt"
    "os"
    "bytes"
)

// uses scanner.Bytes to avoid allocation.
func main() {
    f, err := os.Open("./crackstation-human-only.txt")

    scanner := bufio.NewScanner(f)
    if err != nil {
        panic(err)
    }
    defer f.Close()

    toFind := []byte("Iforgotmypassword")

    for scanner.Scan() {
        if bytes.Contains(scanner.Bytes(), toFind) {
            fmt.Println(scanner.Text())
        }
    }
}