refactor: rename NewAnalyzer to New and update ClearCache method for improved memory management

Author: elecbug

v2/graph/analyzer/analyzer.go

@@ -1,6 +1,7 @@
 package analyzer
 
 import (
+	"runtime"
 	"sync"
 
 	"github.com/elecbug/netkit/v2/graph"
@@ -16,8 +17,8 @@ type Analyzer struct {
 	cfg               *Config                                        // cfg holds configuration options for the analyzer, such as worker counts and normalization settings.
 }
 
-// NewAnalyzer creates a new Analyzer instance based on the provided graph.
-func NewAnalyzer(g *graph.Graph, parallelCoreCount int, cfg *Config) *Analyzer {
+// New creates a new Analyzer instance based on the provided graph.
+func New(g *graph.Graph, parallelCoreCount int, cfg *Config) *Analyzer {
 	return &Analyzer{
 		baseGraph:         g,
 		graphHash:         "",
@@ -27,6 +28,20 @@ func NewAnalyzer(g *graph.Graph, parallelCoreCount int, cfg *Config) *Analyzer {
 	}
 }
 
+// ClearCache clears the cached shortest paths and resets the graph hash. This should be called when the underlying graph
+// changes to ensure that subsequent shortest path computations are accurate and not based on stale data.
+func (a *Analyzer) ClearCache() string {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	a.allShortestPaths = make(map[graph.NodeID]map[graph.NodeID][]graph.Path)
+	a.graphHash = ""
+
+	runtime.GC() // Trigger garbage collection to free memory used by the old cache
+
+	return a.graphHash
+}
+
 // Graph returns the base graph associated with the analyzer.
 func (a *Analyzer) Graph() *graph.Graph {
 	return a.baseGraph

v2/graph/analyzer/analyzer_test.go

@@ -36,7 +36,7 @@ func testComputeShortestPath(t *testing.T) {
 	g.AddEdge("A", "C", graph.NewWeight(2))
 	g.AddEdge("C", "D", graph.NewWeight(1))
 
-	a := analyzer.NewAnalyzer(g, 1, analyzer.DefaultConfig())
+	a := analyzer.New(g, 1, analyzer.DefaultConfig())
 
 	paths, err := a.ShortestPaths("A", "D")
 	if err != nil {
@@ -106,7 +106,7 @@ func TestPerformance(t *testing.T) {
 		t.Fatalf("failed to create graph: %v", err)
 	}
 
-	a := analyzer.NewAnalyzer(g, 1, analyzer.DefaultConfig())
+	a := analyzer.New(g, 1, analyzer.DefaultConfig())
 
 	startTime := time.Now()
 	paths, err := a.ShortestPaths("0", "999")
@@ -121,7 +121,7 @@ func TestPerformance(t *testing.T) {
 	duration := time.Since(startTime)
 	fmt.Printf("  - Time taken to compute shortest paths: %v\n", duration)
 
-	a = analyzer.NewAnalyzer(g, 4, analyzer.DefaultConfig())
+	a = analyzer.New(g, 4, analyzer.DefaultConfig())
 
 	startTime = time.Now()
 	pathsCompared, err := a.ShortestPaths("0", "999")
@@ -135,7 +135,7 @@ func TestPerformance(t *testing.T) {
 		t.Errorf("expected total distance %v, got %v", paths[0].TotalDistance(), pathsCompared[0].TotalDistance())
 	}
 
-	a = analyzer.NewAnalyzer(g, 16, analyzer.DefaultConfig())
+	a = analyzer.New(g, 16, analyzer.DefaultConfig())
 
 	startTime = time.Now()
 	pathsCompared, err = a.ShortestPaths("0", "999")
@@ -149,7 +149,7 @@ func TestPerformance(t *testing.T) {
 		t.Errorf("expected total distance %v, got %v", paths[0].TotalDistance(), pathsCompared[0].TotalDistance())
 	}
 
-	a = analyzer.NewAnalyzer(g, 32, analyzer.DefaultConfig())
+	a = analyzer.New(g, 32, analyzer.DefaultConfig())
 
 	startTime = time.Now()
 	pathsCompared, err = a.ShortestPaths("0", "999")
@@ -204,7 +204,7 @@ func TestAnaylzer(t *testing.T) {
 	}
 
 	cfg := analyzer.DefaultConfig()
-	a := analyzer.NewAnalyzer(g, 16, cfg)
+	a := analyzer.New(g, 16, cfg)
 
 	t.Run("ShortestPaths", func(t *testing.T) {
 		results["shortest_paths"] = make(map[string]any)