steam

Correndo atrás do tempo perdido com Go!

RoadRunner 4 3371596983

Estou atualmente trabalhando numa empresa onde uma das visões da empresa é conseguir ter os dados do jogo finalizado disponível na interface de visualização em menos de 1 minuto. Quase todo o código é escrito em typescript e uma pequena parte em rust.

Uma das partes mais pesadas é feita em shell, que é a parte de baixar e descompactar um arquivo da steam. Pra ilustrar o que é feito, fiz esse script em shell que também serve como base de comparação de tempo.


#! /usr/bin/env bash
#

TARGET_URL="http://replay272.valve.net/730/003705744548740202576_0842061407.dem.bz2"
DESTINATION="003705744548740202576_0842061407.dem.bz2"
UNPACKED="003705744548740202576_0842061407.dem"
CURLUNPACKED="curl-003705744548740202576_0842061407.dem"

die() {
  echo "ERROR: $@" &>2
}

rm -f $DESTINATION $UNPACKED $CURLUNPACKED

curl -o $DESTINATION \
  -L \
  $TARGET_URL ||
  die "Failed to download: $TARGET_URL"

bunzip2 $DESTINATION ||
  die "Failed to unzip $DESTINATION"

mv $UNPACKED $CURLUNPACKED

O código então baixa esse link da steam e tem de descompactar o arquivo. Qual é a velocidade dele?


helio@goosfraba ~/t/godownloader> time ./curl-downloader-2.sh
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  216M  100  216M    0     0  60.3M      0  0:00:03  0:00:03 --:--:-- 60.4M

________________________________________________________
Executed in   29.61 secs    fish           external
   usr time   25.24 secs  585.00 micros   25.24 secs
   sys time    0.89 secs   71.00 micros    0.89 secs

Podemos ver que o "curl" baixa o arquivo em mais ou menos 3 segundos, e gasta no total 25s, ou seja, uns 22s pra descompactar. O total termina como 29s, mas vamos focar primeiramente no "usr time".

Então escrevi um código em Go pra tentar fazer isso de forma mais rápida.

package main

import (
        "compress/bzip2"
        "fmt"
        "io"
        "net/http"
        "os"
        "time"
)

const (
        TARGET_URL   = "http://replay272.valve.net/730/003705744548740202576_0842061407.dem.bz2"
        DESTINATION  = "003705744548740202576_0842061407.dem.bz2"
        DECOMPRESSED = "go-003705744548740202576_0842061407.dem"
)

func main() {
        err := download(TARGET_URL, DESTINATION)
        if err != nil {
                panic(err)
        }

        err = bunzip2(DESTINATION, DECOMPRESSED)
        if err != nil {
                panic(err)
        }
}

func download(from, to string) error {
        fmt.Println("Downloading:", from)
        timeStart := time.Now()
        resp, err := http.Get(from)
        if err != nil {
                return err
        }

        defer resp.Body.Close()
        out, err := os.Create(to)
        if err != nil {
                return err
        }
        defer out.Close()

        _, err = io.Copy(out, resp.Body)
        if err != nil {
                return err
        }
        fmt.Println("Finished:", time.Since(timeStart).String())

        return nil
}

func bunzip2(from, to string) error {
        // https://gist.github.com/rickt/7817401
        fmt.Println("Unpacking:", from)
        timeStart := time.Now()
        pr, pw := io.Pipe()

        go func() {
                defer pw.Close()
                var inFile *os.File
                var err error
                inFile, err = os.Open(from)
                defer inFile.Close()
                if err != nil {
                        panic(err)
                }

                _, err = io.Copy(pw, inFile)
                if err != nil {
                        panic(err)
                }
        }()

        defer pr.Close()
        z := bzip2.NewReader(pr)
        var outFile *os.File
        var err error
        outFile, err = os.Create(to)
        defer outFile.Close()
        if err != nil {
                return err
        }

        _, err = io.Copy(outFile, z)
        if err != nil {
                return err
        }
        fmt.Println("Finished:", time.Since(timeStart).String())
        return nil
}

O código baixa o conteúdo num arquivo e depois descompacta. Qual a velocidade?

helio@goosfraba ~/t/godownloader> go build -o go-downloader-2 main-2.go; time ./go-downloader-2 
Downloading: http://replay272.valve.net/730/003705744548740202576_0842061407.dem.bz2
Finished: 3.536812275s
Unpacking: 003705744548740202576_0842061407.dem.bz2
Finished: 30.220663099s

________________________________________________________
Executed in   33.76 secs    fish           external
   usr time   29.90 secs    0.00 micros   29.90 secs
   sys time    0.95 secs  639.00 micros    0.95 secs

Muito lento. Pior do que eu esperava. Ele baixa o arquivo em 3.5s, mas leva 30s pra descompactar. Um dos motivos é com certeza porquê eu salvo em arquivo e depois abro o arquivo pra descompactar. Vamos então pra próxima versão onde eu passo io.Reader de um pro outro.

package main

import (
        "compress/bzip2"
        "fmt"
        "io"
        "net/http"
        "os"
        "time"
)

const (
        TARGET_URL   = "http://replay272.valve.net/730/003705744548740202576_0842061407.dem.bz2"
        DESTINATION  = "003705744548740202576_0842061407.dem.bz2"
        DECOMPRESSED = "go-003705744548740202576_0842061407.dem"
)

func main() {
        data, err := readerDownload(TARGET_URL, DESTINATION)
        if err != nil {
                panic(err)
        }

        err = bunzip2Stream(data, DECOMPRESSED)
        if err != nil {
                panic(err)
        }
}

func readerDownload(from, to string) ([]byte, error) {
        fmt.Println("Downloading:", from)
        timeStart := time.Now()
        resp, err := http.Get(from)
        if err != nil {
                return nil, err
        }

        defer resp.Body.Close()
        content, err := io.ReadAll(resp.Body)
        if err != nil {
                panic(err)
        }
        fmt.Println("Finished:", time.Since(timeStart).String())
        return content, nil

}

func bunzip2Stream(from []byte, to string) error {
        // https://gist.github.com/rickt/7817401
        fmt.Println("Unpacking:", to)
        timeStart := time.Now()
        pr, pw := io.Pipe()

        go func() {
                defer pw.Close()

                //_, err := io.Copy(pw, from)
                pw.Write(from)
                //if err != nil {
                //              panic(err)
                //      }
        }()

        defer pr.Close()
        z := bzip2.NewReader(pr)
        var outFile *os.File
        var err error
        outFile, err = os.Create(to)
        defer outFile.Close()
        if err != nil {
                return err
        }

        _, err = io.Copy(outFile, z)
        if err != nil {
                return err
        }
        fmt.Println("Finished:", time.Since(timeStart).String())
        return nil
}

Qual o desempenho?

helio@goosfraba ~/t/godownloader> go build -o go-downloader-3 main-3.go; time ./go-downloader-3
Downloading: http://replay272.valve.net/730/003705744548740202576_0842061407.dem.bz2
Finished: 3.624793323s
Unpacking: go-003705744548740202576_0842061407.dem
Finished: 29.883794408s

________________________________________________________
Executed in   33.52 secs    fish           external
   usr time   30.03 secs  580.00 micros   30.03 secs
   sys time    0.96 secs   69.00 micros    0.96 secs

Melhorou mas ainda estou longe de fazer melhor que a versão em shell script. O tempo de descompactar baixou irrisóriamente 1s. Mesmo não tendo SSD ou NVME meu disco é rápido o suficiente pra isso não impactar ao todo.

Comecei a pesquisar como poderia melhorar o desempanho do pacote bzip2 do Go! e existe uma discussão sobre isso em aberto.

https://github.com/golang/go/issues/6754

A reclamação é sobre versões mais antigas de Go! e até Robert Pike opinia. Acho que melhorou bastante pros dias de hoje, mas continua lento se comparado com o binário do programa. O que fazer então? Declarar derrota?

Talvez. Mas ao invés disso eu passei a procurar outras libs no GitHub. E encontrei o uso do pbzip2, que diz ser mais rápido queo bzip2 do standard. Então vamos ao código:

package main

import (
        "context"
        "fmt"
        "io"
        "net/http"
        "os"
        "time"

        "github.com/cosnicolaou/pbzip2"
)

const (
        TARGET_URL   = "http://replay272.valve.net/730/003705744548740202576_0842061407.dem.bz2"
        DESTINATION  = "003705744548740202576_0842061407.dem.bz2"
        DECOMPRESSED = "go-003705744548740202576_0842061407.dem"
)

func main() {
        data, err := readerDownload(TARGET_URL, DESTINATION)
        if err != nil {
                panic(err)
        }

        err = pbunzip2Stream(data, DECOMPRESSED)
        if err != nil {
                panic(err)
        }
}

func readerDownload(from, to string) ([]byte, error) {
        fmt.Println("Downloading:", from)
        timeStart := time.Now()
        resp, err := http.Get(from)
        if err != nil {
                return nil, err
        }

        defer resp.Body.Close()
        content, err := io.ReadAll(resp.Body)
        if err != nil {
                panic(err)
        }
        fmt.Println("Finished:", time.Since(timeStart).String())
        return content, nil

}

func pbunzip2Stream(from []byte, to string) error {
        // https://gist.github.com/rickt/7817401
        fmt.Println("Unpacking:", to)
        timeStart := time.Now()
        pr, pw := io.Pipe()

        go func() {
                defer pw.Close()

                //_, err := io.Copy(pw, from)
                pw.Write(from)
                //if err != nil {
                //              panic(err)
                //      }
        }()

        defer pr.Close()
        ctx := context.Background()
        z := pbzip2.NewReader(ctx, pr)
        var outFile *os.File
        var err error
        outFile, err = os.Create(to)
        defer outFile.Close()
        if err != nil {
                return err
        }

        _, err = io.Copy(outFile, z)
        if err != nil {
                return err
        }
        fmt.Println("Finished:", time.Since(timeStart).String())
        return nil
}

E finalmente, a medida de desempenho:

helio@goosfraba ~/t/godownloader> go build -o go-downloader-4 main-4.go; time ./go-downloader-4
Downloading: http://replay272.valve.net/730/003705744548740202576_0842061407.dem.bz2
Finished: 3.74774932s
Unpacking: go-003705744548740202576_0842061407.dem
Finished: 6.108665607s

________________________________________________________
Executed in    9.89 secs    fish           external
   usr time   44.22 secs    0.00 micros   44.22 secs
   sys time    0.78 secs  655.00 micros    0.78 secs

Vitória! O pbzip2 que faz a descompressão em blocos em paralelo levou 6s. Isso sim é performance. O "usr time" mostra 44s por algum motivo bizarro, mas o tempo total foi por volta de 10s. E o resultado?

helio@goosfraba ~/t/godownloader> sha256sum curl-003705744548740202576_0842061407.dem \
  go-003705744548740202576_0842061407.dem
eca9bdd943521251b8704397e40b7f9aada539698561a6c1aca58ebf2602bfc1  curl-003705744548740202576_0842061407.dem
eca9bdd943521251b8704397e40b7f9aada539698561a6c1aca58ebf2602bfc1  go-003705744548740202576_0842061407.dem

Então foi baixado e descompactado bem mais rápido e sem corromper os dados.

Um ponto a ser visto é que talvez exista também um binário pronto com pbzip2 pra descompactar. E pode ser que seja mais rápido que em Go! Mas é pra isso que servem os desafios. Por enquanto vou celebrar minha pequena vitória com uma cerveja.

victory

Os artigos mais lidos de 2022

steam

steam

Correndo atrás do tempo perdido com Go!

Estatísticas

Imagem aleatória