feat(perf): add (automation, provision, build, run) tooling

[mxinden]

Description

libp2p performance benchmarking

This project includes the following components:

• terraform/: a Terraform scripts to provision infrastructure
• impl/: implementations of the libp2p perf protocol running on top of e.g. go-libp2p, rust-libp2p or Go's std-library https stack
• runner/: a set of scripts building and running the above implementations on the above infrastructure, reporting the results in benchmark-results.json

Benchmark results can be visualized with https://observablehq.com/@mxinden-workspace/libp2p-performance-dashboard.

See perf/README.md and overarching tracking issue #63.

Continuation of #163.

Outstanding work in this pull request:

• Remove libp2p specific concepts (e.g. multiaddr) e.g. to no longer require the https example to parse a multiaddr.
• Rename public ssh key
• Remove --n-times flag from binaries. Potentially introduce --n-parallel-requests flag in the future. Multiple sequential runs are now done in the runner implementation.
• Transfer and run binaries instead of docker images / containers. Or build on the machines.
• Configurable Server port. See feat(perf): add (provision, build, run) tooling  #163.
• Consider adding benchmark parameters to output json file. See feat(perf): add (provision, build, run) tooling  #163 (review).
• Move to TLS only (for now). Easier to compare with HTTPs and no additional security protocol negotiation.
• Remove the need for static peer IDs, i.e. remove --secret-key-seed.

### Outstanding work for future pull requests:
Outstanding / follow-up work tracked in #63.

[MarcoPolo]

This isn't correct. You're assuming the input slice is always at least 8 bytes.

Use io.MultiReader to combine a bytes.NewReader(<buf-with-u64-download-bytes>) and a zeroReader.

The zeroReader could look something like:

type zeroReader struct {
    n int64
}

func (z *zeroReader) Read(p []byte) (int, error) {
    if z.n <= 0 {
        return 0, io.EOF
    }

    for i := range p {
        if z.n <= 0 {
            return i, nil
        }

        p[i] = 0
        z.n--
    }

    return len(p), nil
}

[mxinden]

Wasn't aware of io.MultiReader. That simplifies things. Thanks!

Fixed with 2296d8c. Note that I am still using copy instead of zeroing every byte individually in the (maybe premature) hope that Go can optimize some of it. Let me know in case you prefer individual zeroing for each byte instead @MarcoPolo.

Edit:

Slight change of plan, instead of 2296d8c I merged @marten-seemann's suggestion through #201.

[MarcoPolo]

Looks good mod last comment about the reader.

[marten-seemann]

LGTM, let's ship it!
There's a few follow-up items to this PR, but what we have here is an excellent basis to start iterating on.

Thank you for this clean setup @mxinden, I'm really happy how this turned out