Merge pull request #29 from SpecterOps/reach

feat: Reach, Cache and Bitmap Structure Work - BED-7379

Author: zinic

algo/reach.go

@@ -136,6 +136,7 @@ func (s ComponentGraph) HasMember(memberID uint64) bool {
 	_, hasMember := s.memberComponentLookup[memberID]
 	return hasMember
 }
+
 func (s ComponentGraph) KnownMembers() cardinality.Duplex[uint64] {
 	members := cardinality.NewBitmap64()
 
@@ -155,6 +156,10 @@ func (s ComponentGraph) ContainingComponent(memberID uint64) (uint64, bool) {
 	return component, inComponentDigraph
 }
 
+func (s ComponentGraph) ComponentMembers(componentID uint64) cardinality.Duplex[uint64] {
+	return s.componentMembers[componentID]
+}
+
 func (s ComponentGraph) CollectComponentMembers(componentID uint64, members cardinality.Duplex[uint64]) {
 	members.Or(s.componentMembers[componentID])
 }

algo/scc.go

@@ -0,0 +1,79 @@
+package cache
+
+import "sync/atomic"
+
+type Stats struct {
+	hits     *atomic.Int64
+	misses   *atomic.Int64
+	size     *atomic.Int64
+	Capacity int
+}
+
+func (s Stats) Combined(other Stats) Stats {
+	var (
+		hits     = &atomic.Int64{}
+		misses   = &atomic.Int64{}
+		size     = &atomic.Int64{}
+		capacity = s.Capacity + other.Capacity
+	)
+
+	hits.Add(s.Hits())
+	hits.Add(other.Hits())
+
+	misses.Add(s.Misses())
+	misses.Add(other.Misses())
+
+	size.Add(s.Size())
+	size.Add(other.Size())
+
+	return Stats{
+		hits:     hits,
+		misses:   misses,
+		size:     size,
+		Capacity: capacity,
+	}
+}
+
+func (s Stats) Miss() {
+	s.misses.Add(1)
+}
+
+func (s Stats) Misses() int64 {
+	return s.misses.Load()
+}
+
+func (s Stats) Hit() {
+	s.hits.Add(1)
+}
+
+func (s Stats) Hits() int64 {
+	return s.hits.Load()
+}
+
+func (s Stats) Size() int64 {
+	return s.size.Load()
+}
+
+func (s Stats) Put() {
+	s.size.Add(1)
+}
+
+func (s Stats) Delete() {
+	s.size.Add(-1)
+}
+
+func NewStats(capacity int) Stats {
+	return Stats{
+		hits:     &atomic.Int64{},
+		misses:   &atomic.Int64{},
+		size:     &atomic.Int64{},
+		Capacity: capacity,
+	}
+}
+
+type Cache[K comparable, V any] interface {
+	Put(key K, value V)
+	Get(key K) (V, bool)
+	Delete(key K)
+	Stats() Stats
+}

cache/cache.go

@@ -0,0 +1,62 @@
+package cache
+
+import (
+	"sync"
+)
+
+// NonExpiringMapCache
+type NonExpiringMapCache[K comparable, V any] struct {
+	store  map[K]V
+	stats  Stats
+	rwLock sync.RWMutex
+}
+
+func NewNonExpiringMapCache[K comparable, V any](capacity int) Cache[K, V] {
+	return &NonExpiringMapCache[K, V]{
+		store: make(map[K]V, capacity),
+		stats: NewStats(capacity),
+	}
+}
+
+func (s *NonExpiringMapCache[K, V]) Put(key K, value V) {
+	s.rwLock.Lock()
+	defer s.rwLock.Unlock()
+
+	if _, exists := s.store[key]; exists {
+		s.store[key] = value
+	} else if int(s.stats.Size()) < s.stats.Capacity {
+		s.store[key] = value
+		s.stats.Put()
+	}
+}
+
+func (s *NonExpiringMapCache[K, V]) Get(key K) (V, bool) {
+	s.rwLock.RLock()
+	defer s.rwLock.RUnlock()
+
+	value, hasValue := s.store[key]
+
+	if hasValue {
+		s.stats.Hit()
+	} else {
+		s.stats.Miss()
+	}
+
+	return value, hasValue
+}
+
+func (s *NonExpiringMapCache[K, V]) Delete(key K) {
+	s.rwLock.Lock()
+	defer s.rwLock.Unlock()
+
+	_, exists := s.store[key]
+
+	if exists {
+		delete(s.store, key)
+		s.stats.Delete()
+	}
+}
+
+func (s *NonExpiringMapCache[K, V]) Stats() Stats {
+	return s.stats
+}

cache/nemap.go

@@ -0,0 +1,38 @@
+package cache_test
+
+import (
+	"testing"
+
+	"github.com/specterops/dawgs/cache"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNonExpiringMapCache_PutGet(t *testing.T) {
+	type testValue struct {
+		id   int
+		data string
+	}
+
+	var (
+		nemap    = cache.NewNonExpiringMapCache[int, testValue](10)
+		expected = testValue{id: 1, data: "one"}
+	)
+
+	nemap.Put(1, expected)
+	fetched, exists := nemap.Get(1)
+
+	require.True(t, exists)
+	require.Equal(t, expected, fetched)
+}
+
+func TestNonExpiringMapCache_UpdateExistingKey(t *testing.T) {
+	nemap := cache.NewNonExpiringMapCache[string, int](5)
+
+	nemap.Put("k", 10)
+	nemap.Put("k", 20)
+
+	fetched, exists := nemap.Get("k")
+
+	require.True(t, exists)
+	require.Equal(t, 20, fetched)
+}