Merge pull request #41 from elecbug/elecbug/master

Update v0.12.2

Author: elecbug

.github/workflows/go.yml

@@ -19,10 +19,7 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v4
       with:
-        go-version: '1.21.5'
+        go-version: '1.25.0'
 
     - name: Build
       run: go build -v ./...
-
-    - name: Test
-      run: go test ./...

.vscode/settings.json

@@ -8,18 +8,20 @@ import (
 
 // Analyzer represents a graph analyzer that can be computed based on a given graph.
 type Analyzer struct {
-	baseGraph        *graph.Graph                                   // baseGraph is the original graph provided to the analyzer, used for reference and hashing.
-	graphHash        string                                         // graphHash stores the hash of the base graph to detect changes and manage cache validity.
-	allShortestPaths map[graph.NodeID]map[graph.NodeID][]graph.Path // allShortestPaths caches the results of shortest path computations between node pairs.
-	mu               sync.RWMutex                                   // mu protects access to the allShortestPaths cache to ensure thread safety during concurrent reads/writes.
+	baseGraph         *graph.Graph                                   // baseGraph is the original graph provided to the analyzer, used for reference and hashing.
+	graphHash         string                                         // graphHash stores the hash of the base graph to detect changes and manage cache validity.
+	allShortestPaths  map[graph.NodeID]map[graph.NodeID][]graph.Path // allShortestPaths caches the results of shortest path computations between node pairs.
+	mu                sync.RWMutex                                   // mu protects access to the allShortestPaths cache to ensure thread safety during concurrent reads/writes.
+	parallelCoreCount int                                            // parallelCoreCount determines how many CPU cores to utilize for parallel computations, if applicable.
 }
 
 // NewAnalyzer creates a new Analyzer instance based on the provided graph.
-func NewAnalyzer(g *graph.Graph) *Analyzer {
+func NewAnalyzer(g *graph.Graph, parallelCoreCount int) *Analyzer {
 	return &Analyzer{
-		baseGraph:        g,
-		graphHash:        "",
-		allShortestPaths: make(map[graph.NodeID]map[graph.NodeID][]graph.Path),
+		baseGraph:         g,
+		graphHash:         "",
+		allShortestPaths:  make(map[graph.NodeID]map[graph.NodeID][]graph.Path),
+		parallelCoreCount: parallelCoreCount,
 	}
 }
 

v2/graph/analyzer/analyzer.go

@@ -1,14 +1,28 @@
 package analyzer_test
 
 import (
+	"fmt"
+	"math/rand"
 	"testing"
+	"time"
 
 	"github.com/elecbug/netkit/v2/graph"
 	"github.com/elecbug/netkit/v2/graph/analyzer"
+	"github.com/elecbug/netkit/v2/graph/standard"
 )
 
 // TestShortestPaths tests the ShortestPaths method of the Analyzer to ensure it correctly finds the shortest path between two nodes in a graph.
 func TestShortestPaths(t *testing.T) {
+	fmt.Println("Test Shortest Paths")
+	testComputeShortestPath(t)
+	testPerformance(t)
+}
+
+// testComputeShortestPath sets up a simple graph and tests the ComputeAllShortestPaths and ShortestPaths
+// methods of the Analyzer to verify that it correctly computes and caches shortest paths, and that
+// it updates the cache when the graph changes. It checks for correct path results and proper error handling when paths are removed.
+func testComputeShortestPath(t *testing.T) {
+	fmt.Println("- Test Compute Shortest Paths")
 	g := graph.New(true, true)
 	g.AddNode("A")
 	g.AddNode("B")
@@ -19,7 +33,7 @@ func TestShortestPaths(t *testing.T) {
 	g.AddEdge("A", "C", graph.NewWeight(2))
 	g.AddEdge("C", "D", graph.NewWeight(1))
 
-	a := analyzer.NewAnalyzer(g)
+	a := analyzer.NewAnalyzer(g, 1)
 
 	paths, err := a.ShortestPaths("A", "D")
 	if err != nil {
@@ -72,6 +86,69 @@ func TestShortestPaths(t *testing.T) {
 	}
 }
 
+func testPerformance(t *testing.T) {
+	fmt.Println("- Test Performance")
+
+	g, err := standard.ErdosRenyiGraph(
+		42,
+		false,
+		func(from, to graph.NodeID) *graph.Weight { return graph.NewWeight(rand.Float64() * 100) },
+		1000,
+		0.01,
+	)
+	if err != nil {
+		t.Fatalf("failed to create graph: %v", err)
+	}
+
+	a := analyzer.NewAnalyzer(g, 1)
+
+	startTime := time.Now()
+	_, err = a.ShortestPaths("0", "999")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	duration := time.Since(startTime)
+	fmt.Printf("  - Time taken to compute shortest paths: %v\n", duration)
+
+	a = analyzer.NewAnalyzer(g, 4)
+
+	startTime = time.Now()
+	_, err = a.ShortestPaths("0", "999")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	duration = time.Since(startTime)
+	fmt.Printf("  - Time taken to compute shortest paths with 4 cores: %v\n", duration)
+
+	a = analyzer.NewAnalyzer(g, 16)
+
+	startTime = time.Now()
+	_, err = a.ShortestPaths("0", "999")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	duration = time.Since(startTime)
+	fmt.Printf("  - Time taken to compute shortest paths with 16 cores: %v\n", duration)
+
+	a = analyzer.NewAnalyzer(g, 32)
+
+	startTime = time.Now()
+	_, err = a.ShortestPaths("0", "999")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	duration = time.Since(startTime)
+	fmt.Printf("  - Time taken to compute shortest paths with 32 cores: %v\n", duration)
+
+	startTime = time.Now()
+	_, err = a.ShortestPaths("0", "999")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	duration = time.Since(startTime)
+	fmt.Printf("  - Time taken to retrieve cached shortest paths: %v\n", duration)
+}
+
 // equalPathSlices compares two graph.Path values by node sequence and total distance.
 func equalPathSlices(a, b graph.Path) bool {
 	nodesA := a.Nodes()

v2/graph/analyzer/analyzer_test.go

@@ -2,8 +2,10 @@ package analyzer
 
 import (
 	"container/heap"
+	"context"
 	"fmt"
 	"math"
+	"sync"
 
 	"github.com/elecbug/netkit/v2/graph"
 )
@@ -19,7 +21,7 @@ func (a *Analyzer) ComputeAllShortestPaths() error {
 		return nil
 	}
 
-	paths, err := allShortestPaths(a.baseGraph)
+	paths, err := allShortestPaths(a.baseGraph, a.parallelCoreCount)
 	if err != nil {
 		return err
 	}
@@ -57,29 +59,86 @@ func (a *Analyzer) ShortestPaths(start, end graph.NodeID) ([]graph.Path, error)
 }
 
 // allShortestPaths computes all shortest paths between reachable node pairs in the graph.
-func allShortestPaths(g *graph.Graph) (map[graph.NodeID]map[graph.NodeID][]graph.Path, error) {
+func allShortestPaths(
+	g *graph.Graph, parallelCoreCount int,
+) (map[graph.NodeID]map[graph.NodeID][]graph.Path, error) {
+	if parallelCoreCount <= 0 {
+		parallelCoreCount = 1
+	}
+
 	result := make(map[graph.NodeID]map[graph.NodeID][]graph.Path)
 
-	if !g.Weighted {
-		for _, start := range g.Nodes() {
-			pathsFromStart, err := allShortestPathsFromStart(g, start)
-			if err != nil {
-				return nil, err
-			}
+	nodes := g.Nodes()
 
-			result[start] = pathsFromStart
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	core := make(chan struct{}, parallelCoreCount)
+
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+
+	var firstErr error
+	var errOnce sync.Once
+
+	setErr := func(err error) {
+		if err == nil {
+			return
 		}
 
-		return result, nil
+		errOnce.Do(func() {
+			firstErr = err
+			cancel()
+		})
 	}
 
-	for _, start := range g.Nodes() {
-		pathsFromStart, err := allWeightedShortestPathsFromStart(g, start)
-		if err != nil {
-			return nil, err
+Loop:
+	for _, start := range nodes {
+		select {
+		case <-ctx.Done():
+			break Loop
+		default:
 		}
 
-		result[start] = pathsFromStart
+		core <- struct{}{}
+		wg.Add(1)
+
+		go func(start graph.NodeID) {
+			defer wg.Done()
+			defer func() {
+				<-core
+			}()
+
+			select {
+			case <-ctx.Done():
+				return
+			default:
+			}
+
+			var pathsFromStart map[graph.NodeID][]graph.Path
+			var err error
+
+			if !g.Weighted {
+				pathsFromStart, err = allShortestPathsFromStart(g, start)
+			} else {
+				pathsFromStart, err = allWeightedShortestPathsFromStart(g, start)
+			}
+
+			if err != nil {
+				setErr(fmt.Errorf("failed to compute shortest paths from %s: %w", start, err))
+				return
+			}
+
+			mu.Lock()
+			result[start] = pathsFromStart
+			mu.Unlock()
+		}(start)
+	}
+
+	wg.Wait()
+
+	if firstErr != nil {
+		return nil, firstErr
 	}
 
 	return result, nil