bench_test.go

package sphinx

import (
	"bytes"
	"testing"

	"github.com/decred/dcrd/dcrec/secp256k1/v4"
)

var (
	s *OnionPacket
	p *ProcessedPacket
)

func BenchmarkPathPacketConstruction(b *testing.B) {
	b.StopTimer()

	var (
		err          error
		sphinxPacket *OnionPacket
		route        PaymentPath
	)

	for i := 0; i < NumMaxHops; i++ {
		privKey, err := secp256k1.GeneratePrivateKey()
		if err != nil {
			b.Fatalf("unable to generate key: %v", privKey)
		}

		hopData := HopData{
			ForwardAmount: uint64(i),
			OutgoingCltv:  uint32(i),
		}
		copy(hopData.NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))

		hopPayload, err := NewHopPayload(&hopData, nil)
		if err != nil {
			b.Fatalf("unable to create new hop payload: %v", err)
		}

		route[i] = OnionHop{
			NodePub:    *privKey.PubKey(),
			HopPayload: hopPayload,
		}
	}

	d := secp256k1.PrivKeyFromBytes(bytes.Repeat([]byte{'A'}, 32))
	b.ReportAllocs()

	b.StartTimer()

	for i := 0; i < b.N; i++ {
		sphinxPacket, err = NewOnionPacket(
			&route, d, nil, BlankPacketFiller,
		)
		if err != nil {
			b.Fatalf("unable to create packet: %v", err)
		}
	}

	s = sphinxPacket
}

func BenchmarkProcessPacket(b *testing.B) {
	b.StopTimer()
	path, _, _, sphinxPacket, err := newTestRoute(1)
	if err != nil {
		b.Fatalf("unable to create test route: %v", err)
	}
	b.ReportAllocs()
	requireNoErr(b, path[0].log.Start())
	b.Cleanup(func() { requireNoErr(b, path[0].log.Stop()) })
	b.StartTimer()

	var (
		pkt *ProcessedPacket
	)
	for i := 0; i < b.N; i++ {
		pkt, err = path[0].ProcessOnionPacket(sphinxPacket, nil, uint32(i))
		if err != nil {
			b.Fatalf("unable to process packet %d: %v", i, err)
		}

		b.StopTimer()
		router := path[0]
		requireNoErr(b, router.log.Stop())
		path[0] = &Router{
			nodeID:   router.nodeID,
			nodeAddr: router.nodeAddr,
			onionKey: router.onionKey,
			log:      NewMemoryReplayLog(),
		}
		requireNoErr(b, path[0].log.Start())
		b.StartTimer()
	}

	p = pkt
}