benchmark

package
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 29, 2026 License: MIT Imports: 7 Imported by: 0

Documentation

Overview

Package benchmark holds the deterministic session workloads shared by every backend's storage and repository benchmarks.

Index

Constants

This section is empty.

Variables

View Source
var SessionRepoCatalogBenchmarkDatasets = []SessionRepoCatalogBenchmarkDataset{
	createCatalogDataset("100", 100),
	createCatalogDataset("1k", 1_000),
	createCatalogDataset("10k", 10_000),
}

SessionRepoCatalogBenchmarkDatasets are the deterministic closed-session catalogs shared by repository measurements.

View Source
var SessionRepoCatalogReadBenchmarkScenarios = []SessionRepoCatalogReadBenchmarkScenario{
	{
		Name:           "list sessions",
		ExpectedResult: func(dataset SessionRepoCatalogBenchmarkDataset) int { return dataset.SessionCount },
		Run: func(ctx context.Context, repo conformance.RepoAdapter) (int, error) {
			listed, err := repo.List(ctx)
			return len(listed), err
		},
	},
}

SessionRepoCatalogReadBenchmarkScenarios are the shared catalog reads.

View Source
var SessionRepoCatalogWriteBenchmarkScenarios = []SessionRepoCatalogWriteBenchmarkScenario{
	{
		Name: "create empty session", ExpectedResult: 1,
		Prepare: func(ctx context.Context, repo conformance.RepoAdapter) (func() (int, error), error) {
			return func() (int, error) {
				created, err := repo.Create(ctx, session.SessionCreateOptions{ID: benchmarkSessionID})
				if err != nil {
					return 0, err
				}
				return matched(created.Metadata().ID == benchmarkSessionID), nil
			}, nil
		},
	},
	{
		Name: "open closed empty session", ExpectedResult: 1,
		Prepare: func(ctx context.Context, repo conformance.RepoAdapter) (func() (int, error), error) {
			metadata, err := createClosedSession(ctx, repo)
			return func() (int, error) {
				reopened, err := repo.Open(ctx, metadata)
				if err != nil {
					return 0, err
				}
				return matched(reopened.Metadata().ID == metadata.ID), nil
			}, err
		},
	},
	{
		Name: "delete closed empty session", ExpectedResult: 1,
		Prepare: func(ctx context.Context, repo conformance.RepoAdapter) (func() (int, error), error) {
			metadata, err := createClosedSession(ctx, repo)
			return func() (int, error) {
				return 1, repo.Delete(ctx, metadata)
			}, err
		},
	},
}

SessionRepoCatalogWriteBenchmarkScenarios are the shared catalog writes.

SessionRepoForkBenchmarkDatasets bound initial fork timing because each iteration owns an equivalent seeded repository.

View Source
var SessionRepoForkWriteBenchmarkScenarios = []SessionRepoForkWriteBenchmarkScenario{
	{
		Name:           "fork open current branch",
		ExpectedResult: func(dataset StorageBenchmarkDataset) int { return dataset.EntryCount },
		Run: func(ctx context.Context, repo conformance.RepoAdapter, source session.SessionMetadata, dataset StorageBenchmarkDataset) (int, error) {
			fork, err := repo.Fork(ctx, source, session.ForkOptions{ID: forkDestinationSessionID, Scope: session.ForkScopeBranch, Branch: "main"})
			if err != nil {
				return 0, err
			}
			metadata := fork.Metadata()
			if metadata.ID == forkDestinationSessionID && metadata.ParentSessionID == source.ID {
				return dataset.EntryCount, nil
			}
			return 0, nil
		},
	},
}

SessionRepoForkWriteBenchmarkScenarios are the shared fork writes.

View Source
var StorageBenchmarkDatasets = []StorageBenchmarkDataset{
	createDataset("1k entries", 1_000),
	createDataset("10k entries", 10_000),
	createDataset("100k entries", 100_000),
}

StorageBenchmarkDatasets are the deterministic synthetic linear branches shared by all storage measurements.

View Source
var StorageReadBenchmarkScenarios = []StorageReadBenchmarkScenario{
	{
		Name:           "get 100 distributed entries",
		ExpectedResult: func(dataset StorageBenchmarkDataset) int { return len(dataset.LookupIDs) },
		Run: func(ctx context.Context, storage session.Storage, dataset StorageBenchmarkDataset) (int, error) {
			entries, err := storage.GetEntries(ctx, dataset.LookupIDs)
			return len(entries), err
		},
	},
	{
		Name:           "scan latest 50 entries",
		ExpectedResult: func(dataset StorageBenchmarkDataset) int { return min(50, dataset.EntryCount) },
		Run: func(ctx context.Context, storage session.Storage, _ StorageBenchmarkDataset) (int, error) {
			entries, err := storage.ScanEntries(ctx, session.EntryScan{Order: session.OrderDesc, Limit: new(50)})
			return len(entries), err
		},
	},
	{
		Name:           "scan full branch structure",
		ExpectedResult: func(dataset StorageBenchmarkDataset) int { return dataset.EntryCount },
		Run: func(ctx context.Context, storage session.Storage, dataset StorageBenchmarkDataset) (int, error) {
			entries, err := storage.ScanBranchStructure(ctx, session.StorageBranchScan{Start: dataset.TipID, Order: session.OrderNewestFirst})
			return len(entries), err
		},
	},
}

StorageReadBenchmarkScenarios are the shared read scenarios.

View Source
var StorageWriteBenchmarkScenarios = []StorageWriteBenchmarkScenario{
	{
		Name: "commit one message entry", WriteCount: 1,
		Run: func(ctx context.Context, storage session.Storage) (int, error) {
			return commitCount(ctx, storage, createStorageBenchmarkTransaction(0, 1, 256))
		},
	},
	{
		Name: "commit 100 message entries", WriteCount: 100,
		Run: func(ctx context.Context, storage session.Storage) (int, error) {
			return commitCount(ctx, storage, createStorageBenchmarkTransaction(0, 100, 256))
		},
	},
	{
		Name: "commit mixed append (" + writeBaselineDataset.Name + ")", WriteCount: 3,
		Prepare: func(ctx context.Context, storage session.Storage) error {
			return SeedStorageBenchmark(ctx, storage, writeBaselineDataset)
		},
		Run: func(ctx context.Context, storage session.Storage) (int, error) {
			return commitCount(ctx, storage, mixedAppendTransaction())
		},
	},
}

StorageWriteBenchmarkScenarios are the shared writes; every invocation receives equivalent pre-benchmark state.

Functions

func GenerateStorageBenchmarkSeedTransactions

func GenerateStorageBenchmarkSeedTransactions(dataset StorageBenchmarkDataset) [][]session.Write

GenerateStorageBenchmarkSeedTransactions returns the deterministic seed transactions of a dataset; it claims no production data distribution.

func SeedSessionRepoCatalogBenchmark

func SeedSessionRepoCatalogBenchmark(ctx context.Context, repo conformance.RepoAdapter, dataset SessionRepoCatalogBenchmarkDataset) ([]session.SessionMetadata, error)

SeedSessionRepoCatalogBenchmark seeds one catalog and returns its metadata in creation order.

func SeedSessionRepoForkBenchmark

func SeedSessionRepoForkBenchmark(ctx context.Context, repo conformance.RepoAdapter, dataset StorageBenchmarkDataset) (session.SessionMetadata, error)

SeedSessionRepoForkBenchmark seeds one open source session with a linear configured main branch.

func SeedStorageBenchmark

func SeedStorageBenchmark(ctx context.Context, storage session.Storage, dataset StorageBenchmarkDataset) error

SeedStorageBenchmark seeds one deterministic synthetic linear branch.

func SessionRepoBenchmarkSessionID

func SessionRepoBenchmarkSessionID(index int) string

SessionRepoBenchmarkSessionID is the deterministic session id shared by repository benchmark workloads.

func StorageBenchmarkEntryID

func StorageBenchmarkEntryID(index int) string

StorageBenchmarkEntryID is the deterministic id shared by dataset and transaction generation.

Types

type SessionRepoCatalogBenchmarkDataset

type SessionRepoCatalogBenchmarkDataset struct {
	Name         string
	SessionCount int
}

SessionRepoCatalogBenchmarkDataset is one closed-session catalog size.

type SessionRepoCatalogReadBenchmarkScenario

type SessionRepoCatalogReadBenchmarkScenario struct {
	Name           string
	ExpectedResult func(dataset SessionRepoCatalogBenchmarkDataset) int
	Run            func(ctx context.Context, repo conformance.RepoAdapter) (int, error)
}

SessionRepoCatalogReadBenchmarkScenario is a catalog read; Run returns a count so each result is consumed.

type SessionRepoCatalogWriteBenchmarkScenario

type SessionRepoCatalogWriteBenchmarkScenario struct {
	Name           string
	ExpectedResult int
	Prepare        func(ctx context.Context, repo conformance.RepoAdapter) (run func() (int, error), err error)
}

SessionRepoCatalogWriteBenchmarkScenario prepares an operation against an independently prepared repository.

type SessionRepoForkWriteBenchmarkScenario

type SessionRepoForkWriteBenchmarkScenario struct {
	Name           string
	ExpectedResult func(dataset StorageBenchmarkDataset) int
	Run            func(ctx context.Context, repo conformance.RepoAdapter, source session.SessionMetadata, dataset StorageBenchmarkDataset) (int, error)
}

SessionRepoForkWriteBenchmarkScenario forks a seeded source session.

type StorageBenchmarkDataset

type StorageBenchmarkDataset struct {
	Name         string
	EntryCount   int
	PayloadBytes int
	LookupIDs    []string
	TipID        string
}

StorageBenchmarkDataset is one synthetic linear branch.

type StorageReadBenchmarkScenario

type StorageReadBenchmarkScenario struct {
	Name           string
	ExpectedResult func(dataset StorageBenchmarkDataset) int
	Run            func(ctx context.Context, storage session.Storage, dataset StorageBenchmarkDataset) (int, error)
}

StorageReadBenchmarkScenario is a steady-state read against a seeded fixture; Run returns a count so each result is consumed.

type StorageWriteBenchmarkScenario

type StorageWriteBenchmarkScenario struct {
	Name       string
	WriteCount int
	// Prepare seeds the fixture before timing; nil means no preparation.
	Prepare func(ctx context.Context, storage session.Storage) error
	Run     func(ctx context.Context, storage session.Storage) (int, error)
}

StorageWriteBenchmarkScenario is a write run once against each independently prepared fixture.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL