Accelsim/ticking

accelsim_tracing/.gitignore

@@ -1,3 +1,5 @@
 accelsim_tracing
-output/
-example/
+data/*
+*.log
+
+!data/simple-trace-example/

accelsim_tracing/accelsim_tracing.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"github.com/sarchlab/akita/v3/sim"
+	"github.com/sarchlab/mgpusim/v3/accelsim_tracing/benchmark"
+	"github.com/sarchlab/mgpusim/v3/accelsim_tracing/platform"
+	"github.com/sarchlab/mgpusim/v3/accelsim_tracing/runner"
+	"github.com/tebeka/atexit"
+)
+
+func main() {
+	benchmark := new(benchmark.BenchmarkBuilder).
+		// WithTraceDirectory("data/bfs-rodinia-2.0-ft").
+		WithTraceDirectory("data/simple-trace-example").
+		Build()
+
+	platform := new(platform.A100PlatformBuilder).
+		WithFreq(1 * sim.Hz).
+		Build()
+
+	runner := new(runner.RunnerBuilder).
+		WithPlatform(platform).
+		Build()
+	runner.AddBenchmark(benchmark)
+
+	runner.Run()
+
+	atexit.Exit(0)
+}

accelsim_tracing/benchmark/benchmark.go

@@ -0,0 +1,48 @@
+package benchmark
+
+import (
+	"github.com/sarchlab/mgpusim/v3/accelsim_tracing/driver"
+	"github.com/sarchlab/mgpusim/v3/accelsim_tracing/nvidia"
+)
+
+type TraceExec interface {
+	ExecType() nvidia.ExecType
+	Run(*driver.Driver)
+}
+
+type Benchmark struct {
+	TraceExecs []TraceExec
+}
+
+type ExecMemcpy struct {
+	direction nvidia.ExecMemcpyDirection
+	address   uint64
+	length    uint64
+}
+
+type ExecKernel struct {
+	kernel nvidia.Kernel
+}
+
+func (e *ExecMemcpy) ExecType() nvidia.ExecType {
+	return nvidia.ExecMemcpy
+}
+
+func (e *ExecKernel) ExecType() nvidia.ExecType {
+	return nvidia.ExecKernel
+}
+
+func (e *ExecMemcpy) Run(d *driver.Driver) {
+}
+
+func (e *ExecKernel) Run(d *driver.Driver) {
+	d.RunKernel(&e.kernel)
+}
+
+func (e *ExecKernel) SetKernel(kernel nvidia.Kernel) {
+	e.kernel = kernel
+}
+
+func (e *ExecKernel) GetKernel() *nvidia.Kernel {
+	return &e.kernel
+}

accelsim_tracing/benchmark/benchmark_test.go

@@ -0,0 +1,42 @@
+package benchmark_test
+
+import (
+	"testing"
+
+	"github.com/sarchlab/mgpusim/v3/accelsim_tracing/benchmark"
+	"github.com/sarchlab/mgpusim/v3/accelsim_tracing/nvidia"
+)
+
+func TestBenchmarkBuild(t *testing.T) {
+	benchmark := new(benchmark.BenchmarkBuilder).
+		// WithTraceDirectory("../data/bfs-rodinia-2.0-ft").
+		WithTraceDirectory("../data/simple-trace-example").
+		Build()
+
+	kernelCount := 0
+	memcpyCount := 0
+
+	for _, exec := range benchmark.TraceExecs {
+		if exec.ExecType() == nvidia.ExecKernel {
+			kernelCount++
+		} else if exec.ExecType() == nvidia.ExecMemcpy {
+			memcpyCount++
+		} else {
+			t.Errorf("Unknown exec type")
+		}
+	}
+
+	// if kernelCount != 16 {
+	// 	t.Errorf("Expected 16 kernel, got %d", kernelCount)
+	// }
+	// if memcpyCount != 14 {
+	// 	t.Errorf("Expected 14 memcpy, got %d", memcpyCount)
+	// }
+
+	if kernelCount != 3 {
+		t.Errorf("Expected 3 kernel, got %d", kernelCount)
+	}
+	if memcpyCount != 3 {
+		t.Errorf("Expected 3 memcpy, got %d", memcpyCount)
+	}
+}

accelsim_tracing/benchmark/builder.go

@@ -0,0 +1,77 @@
+package benchmark
+
+import (
+	"github.com/sarchlab/mgpusim/v3/accelsim_tracing/nvidia"
+	"github.com/sarchlab/mgpusim/v3/accelsim_tracing/tracereader"
+)
+
+type BenchmarkBuilder struct {
+	traceDirectory string
+}
+
+func (b *BenchmarkBuilder) WithTraceDirectory(traceDirectory string) *BenchmarkBuilder {
+	b.traceDirectory = traceDirectory
+	return b
+}
+
+func (b *BenchmarkBuilder) Build() *Benchmark {
+	b.traceDirectoryMustBeSet()
+
+	reader := new(tracereader.TraceReaderBuilder).
+		WithTraceDirectory(b.traceDirectory).
+		Build()
+	execMetas := reader.GetExecMetas()
+
+	traceExecs := make([]TraceExec, 0)
+
+	execCount := len(execMetas)
+	for i := 0; i < execCount; i++ {
+		meta := execMetas[i]
+		if meta.ExecType() == nvidia.ExecKernel {
+			kernel := b.generateKernelTrace(meta)
+			traceExecs = append(traceExecs, kernel)
+		} else if meta.ExecType() == nvidia.ExecMemcpy {
+			memcpy := b.generateMemcpyTrace(meta)
+			traceExecs = append(traceExecs, memcpy)
+		}
+	}
+
+	return &Benchmark{
+		TraceExecs: traceExecs,
+	}
+}
+
+func (b *BenchmarkBuilder) generateKernelTrace(meta tracereader.TraceExecMeta) *ExecKernel {
+	kernelTrace := tracereader.ReadTrace(meta)
+	kernel := nvidia.Kernel{}
+
+	kernel.ThreadblocksCount = kernelTrace.ThreadblocksCount()
+	for i := int64(0); i < kernel.ThreadblocksCount; i++ {
+		tb := nvidia.Threadblock{}
+		tb.WarpsCount = kernelTrace.Threadblock(i).WarpsCount()
+		for j := int64(0); j < tb.WarpsCount; j++ {
+			warp := nvidia.Warp{}
+			warp.InstructionsCount = kernelTrace.Threadblock(i).Warp(j).InstructionsCount()
+			tb.Warps = append(tb.Warps, warp)
+		}
+		kernel.Threadblocks = append(kernel.Threadblocks, tb)
+	}
+
+	return &ExecKernel{
+		kernel: kernel,
+	}
+}
+
+func (b *BenchmarkBuilder) generateMemcpyTrace(meta tracereader.TraceExecMeta) *ExecMemcpy {
+	return &ExecMemcpy{
+		direction: meta.Direction,
+		address:   meta.Address,
+		length:    meta.Length,
+	}
+}
+
+func (b *BenchmarkBuilder) traceDirectoryMustBeSet() {
+	if b.traceDirectory == "" {
+		panic("Trace directory must be set")
+	}
+}

accelsim_tracing/benchmark/doc.go

@@ -1,2 +1,2 @@
-// Package benchmark contains the driver which links traces and the simulator
+// Package benchmark can load trace information and run simulation.
 package benchmark