Merge pull request #90 from sarchlab/81-integrate-sankey-diagram-in-a…

…kitartm-to-monitor-ports-pressure

81 integrate sankey diagram in akitartm to monitor ports pressure

analysis/buffer_analyzer.go

@@ -86,12 +86,13 @@ func (b *BufferAnalyzer) summarizePeriod(
  }
 
  b.PerfLogger.AddDataEntry(PerfAnalyzerEntry{
- Start: periodStartTime,
- End: periodEndTime,
- Where: b.buf.Name(),
- What: "BufferLevel",
- Value: avgLevel,
- Unit: "",
+ Start: periodStartTime,
+ End: periodEndTime,
+ Where: b.buf.Name(),
+ What: "Level",
+ EntryType: "Buffer",
+ Value: avgLevel,
+ Unit: "",
  })
 }
 

analysis/buffer_analyzer_test.go

@@ -51,12 +51,13 @@ var _ = Describe("BufferAnalyzer", func() {
  timeTeller.EXPECT().CurrentTime().Return(sim.VTimeInSec(1.1)).AnyTimes()
  buffer.EXPECT().Size().Return(2)
  logger.EXPECT().AddDataEntry(PerfAnalyzerEntry{
- Start: 0.0,
- End: 1.0,
- Where: "Buffer",
- What: "BufferLevel",
- Value: 0.9,
- Unit: "",
+ Start: 0.0,
+ End: 1.0,
+ Where: "Buffer",
+ What: "Level",
+ EntryType: "Buffer",
+ Value: 0.9,
+ Unit: "",
  })
 
  bufferAnalyzer.Func(sim.HookCtx{
@@ -81,21 +82,23 @@ var _ = Describe("BufferAnalyzer", func() {
  timeTeller.EXPECT().CurrentTime().Return(sim.VTimeInSec(2.1)).AnyTimes()
  buffer.EXPECT().Size().Return(2)
  logger.EXPECT().AddDataEntry(PerfAnalyzerEntry{
- Start: 0.0,
- End: 1.0,
- Where: "Buffer",
- What: "BufferLevel",
- Value: 0.9,
- Unit: "",
+ Start: 0.0,
+ End: 1.0,
+ Where: "Buffer",
+ What: "Level",
+ EntryType: "Buffer",
+ Value: 0.9,
+ Unit: "",
  })
 
  logger.EXPECT().AddDataEntry(PerfAnalyzerEntry{
- Start: 1.0,
- End: 2.0,
- Where: "Buffer",
- What: "BufferLevel",
- Value: 1,
- Unit: "",
+ Start: 1.0,
+ End: 2.0,
+ Where: "Buffer",
+ What: "Level",
+ EntryType: "Buffer",
+ Value: 1,
+ Unit: "",
  })
 
  bufferAnalyzer.Func(sim.HookCtx{

analysis/perf_analyzer.go

@@ -1,20 +1,26 @@
 package analysis
 
 import (
+ "encoding/json"
+ "fmt"
  "reflect"
+ "strings"
+ "sync"
  "unsafe"
 
  "github.com/sarchlab/akita/v3/sim"
 )
 
 // PerfAnalyzerEntry is a single entry in the performance database.
 type PerfAnalyzerEntry struct {
- Start sim.VTimeInSec
- End sim.VTimeInSec
- Where string
- What string
- Value float64
- Unit string
+ EntryType string
+ Start sim.VTimeInSec
+ End sim.VTimeInSec
+ Where string
+ WhereRemote string
+ What string
+ Value float64
+ Unit string
 }
 
 // PerfLogger is the interface that provide the service that can record
@@ -25,10 +31,13 @@ type PerfLogger interface {
 
 // PerfAnalyzer can report performance metrics during simulation.
 type PerfAnalyzer struct {
- usePeriod bool
- period sim.VTimeInSec
- engine sim.Engine
- backend PerfAnalyzerBackend
+ usePeriod bool
+ period sim.VTimeInSec
+ engine sim.Engine
+ backend PerfAnalyzerBackend
+ portDataTable map[string]PerfAnalyzerEntry
+
+ mu sync.Mutex
 }
 
 // RegisterEngine registers the engine that is used in the simulation.
@@ -80,7 +89,6 @@ func (b *PerfAnalyzer) RegisterBuffer(buf sim.Buffer) {
  }
 
  bufferAnalyzer := bufferAnalyzerBuilder.Build()
-
  buf.AcceptHook(bufferAnalyzer)
 }
 
@@ -112,7 +120,15 @@ func (b *PerfAnalyzer) RegisterPort(port sim.Port) {
 // AddDataEntry adds a data entry to the database. It directly writes into the
 // CSV file.
 func (b *PerfAnalyzer) AddDataEntry(entry PerfAnalyzerEntry) {
- b.backend.AddDataEntry(entry)
+ if b.backend != nil {
+ b.backend.AddDataEntry(entry)
+ }
+
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ key := entry.Where + entry.What + entry.EntryType + entry.Unit
+ b.portDataTable[key] = entry
 }
 
 // PerfAnalyzerBuilder is a builder that can build a PerfAnalyzer.
@@ -167,19 +183,22 @@ func (b PerfAnalyzerBuilder) WithEngine(
 // Build creates a PerfAnalyzer.
 func (b PerfAnalyzerBuilder) Build() *PerfAnalyzer {
  var backend PerfAnalyzerBackend
- if b.backendType == "csv" {
- backend = NewCSVPerfAnalyzerBackend(b.dbFilename)
- } else if b.backendType == "sqlite" {
- backend = NewSQLitePerfAnalyzerBackend(b.dbFilename)
- } else {
- panic("Unknown backend type")
+ if b.dbFilename != "" {
+ if b.backendType == "csv" {
+ backend = NewCSVPerfAnalyzerBackend(b.dbFilename)
+ } else if b.backendType == "sqlite" {
+ backend = NewSQLitePerfAnalyzerBackend(b.dbFilename)
+ } else {
+ panic("Unknown backend type")
+ }
  }
 
  return &PerfAnalyzer{
- period: b.period,
- backend: backend,
- engine: b.engine,
- usePeriod: b.usePeriod,
+ period: b.period,
+ backend: backend,
+ engine: b.engine,
+ usePeriod: b.usePeriod,
+ portDataTable: make(map[string]PerfAnalyzerEntry),
  }
 }
 
@@ -201,3 +220,37 @@ func (b *PerfAnalyzer) registerComponentOrPorts(c any) {
  }
  }
 }
+
+func (b *PerfAnalyzer) GetCurrentTraffic(comp string) string {
+ dataTable := []map[string]string{}
+ time := b.engine.CurrentTime()
+
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ for _, data := range b.portDataTable {
+ if strings.Contains(data.Where, comp) {
+ entry := map[string]string{
+ "start": fmt.Sprintf("%.9f", data.Start),
+ "end": fmt.Sprintf("%.9f", data.End),
+ "localPort": data.Where,
+ "remotePort": data.WhereRemote,
+ "value": fmt.Sprintf("%.0f", data.Value),
+ "unit": data.Unit,
+ }
+
+ if float64(data.End) < float64(time)-float64(b.period) {
+ entry["value"] = "0"
+ }
+
+ dataTable = append(dataTable, entry)
+ }
+ }
+
+ output, err := json.Marshal(dataTable)
+ if err != nil {
+ panic(err)
+ }
+
+ return string(output)
+}

analysis/perf_analyzer_backend.go

@@ -28,6 +28,10 @@ type CSVBackend struct {
 
 // NewCSVPerfAnalyzerBackend creates a new CSVPerfAnalyzerBackend.
 func NewCSVPerfAnalyzerBackend(dbFilename string) *CSVBackend {
+ if dbFilename == "" {
+ return nil
+ }
+
  p := &CSVBackend{}
 
  var err error
@@ -45,7 +49,7 @@ func NewCSVPerfAnalyzerBackend(dbFilename string) *CSVBackend {
 
  p.csvWriter = csv.NewWriter(p.dbFile)
 
- header := []string{"Start", "End", "Where", "What", "Value", "Unit"}
+ header := []string{"Start", "End", "Where", "What", "EntryType", "Value", "Unit"}
  err = p.csvWriter.Write(header)
  if err != nil {
  panic(err)
@@ -61,6 +65,7 @@ func (p *CSVBackend) AddDataEntry(entry PerfAnalyzerEntry) {
  fmt.Sprintf("%.10f", entry.End),
  entry.Where,
  entry.What,
+ entry.EntryType,
  fmt.Sprintf("%.10f", entry.Value),
  entry.Unit,
  })
@@ -136,6 +141,7 @@ func (p *SQLiteBackend) Flush() {
  entry.End,
  entry.Where,
  entry.What,
+ entry.EntryType,
  entry.Value,
  entry.Unit,
  )
@@ -172,8 +178,9 @@ func (p *SQLiteBackend) createTable() {
  id integer not null primary key,
  start real,
  end real,
- where_ text,
+ where text,
  what text,
+ entryType text,
  value real,
  unit text
  );
@@ -189,8 +196,8 @@ func (p *SQLiteBackend) prepareStatement() {
  var err error
 
  sqlStmt := `
- insert into perf(start, end, where_, what, value, unit)
- values(?, ?, ?, ?, ?, ?)
+ insert into perf(start, end, where_, what_, entryType, value, unit)
+ values(?, ?, ?, ?, ?, ?, ?)
  `
 
  p.statement, err = p.Prepare(sqlStmt)