cache

package
v1.7.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 31, 2026 License: MIT Imports: 8 Imported by: 0

Documentation

Overview

Package cache provides DNS caching functionality for SDNS.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// ErrCacheNotFound error.
	ErrCacheNotFound = errors.New("cache not found")
	// ErrCacheExpired error.
	ErrCacheExpired = errors.New("cache expired")
)

Functions

func Key 

func Key(q dns.Question, cd ...bool) uint64

Key generates a cache key for DNS queries. This implementation uses object pooling and stack allocation to achieve zero heap allocations. The optional cd parameter indicates if the CD (Checking Disabled) bit should be included.

func KeySimple 

func KeySimple(q dns.Question, cd ...bool) uint64

KeySimple generates a cache key without pooling for comparison. This is exported for benchmarking purposes only.

func KeyString 

func KeyString(qname string, qtype, qclass uint16, cd bool) uint64

KeyString is an optimized version for string-based keys. It uses unsafe conversion to avoid allocation when converting string to []byte.

func KeyWithPrefix added in v1.7.0 

func KeyWithPrefix(q dns.Question, cd bool, prefix netip.Prefix) uint64

KeyWithPrefix is an ECS-aware variant of Key. An invalid prefix (the canonical "no scope" value) collapses to Key(q, cd) so cache entries written before this function existed still resolve on lookup — no flush needed on upgrade.

When prefix is valid, family + bit-length + the address bytes rounded up to a byte are folded into the hash preimage. The distinct family byte means an IPv4 /24 of [a, b, c] cannot collide with an IPv6 /24 whose first three bytes happen to be [a, b, c]. The distinct bit-length byte means /22 and /24 of 203.0.112.0 hash differently even though their byte-rounded addresses are both [203, 0, 112] — the earlier scope-bytes-only encoding aliased here and would serve a wider supernet's answer to a narrower-subnet query.

Types

type Cache 

type Cache struct {
	// contains filtered or unexported fields
}

Cache uses SyncUInt64Map with radical eviction strategy Instead of evicting one by one, we evict entire segments at once!

func New 

func New(size int) *Cache

NewCache creates a cache with radical eviction

func (*Cache) Add 

func (c *Cache) Add(key uint64, value any)

Add adds an item with radical eviction if needed

func (*Cache) ForEach 

func (c *Cache) ForEach(f func(key uint64, value any) bool)

ForEach iterates over all cache entries. Iteration is not atomic with concurrent updates.

func (*Cache) Get 

func (c *Cache) Get(key uint64) (any, bool)

Get retrieves a value - uses SyncUInt64Map's excellent performance

func (*Cache) Len 

func (c *Cache) Len() int

Len returns current size

func (*Cache) Remove 

func (c *Cache) Remove(key uint64)

Remove removes an item

func (*Cache) Stop 

func (c *Cache) Stop()

Stop cleanup

type Pair 

type Pair[V any] struct {
	Key   uint64
	Value V
}

Pair contains a key-value pair

type SegmentUInt64Map 

type SegmentUInt64Map[V any] struct {
	// contains filtered or unexported fields
}

SegmentUInt64Map is a fast, thread-safe map for int64 keys that uses sharding (segmentation) to reduce lock contention while maintaining the performance benefits of UInt64Map

func NewSegmentUInt64Map 

func NewSegmentUInt64Map[V any](segmentPower uint8, initialCapacity int) *SegmentUInt64Map[V]

NewSegmentUInt64Map creates a new segmented map for int64 keys segmentPower controls the number of segments (2^segmentPower) initialCapacity is the initial capacity per segment

func (*SegmentUInt64Map[V]) All 

func (m *SegmentUInt64Map[V]) All() iter.Seq2[uint64, V]

All returns an iterator over all key-value pairs

func (*SegmentUInt64Map[V]) Clear 

func (m *SegmentUInt64Map[V]) Clear()

Clear removes all entries from the map

func (*SegmentUInt64Map[V]) ClearSegment 

func (m *SegmentUInt64Map[V]) ClearSegment(index int)

ClearSegment clears a specific segment - for radical eviction

func (*SegmentUInt64Map[V]) Del 

func (m *SegmentUInt64Map[V]) Del(key uint64) bool

Del removes a key from the map

func (*SegmentUInt64Map[V]) ForEach 

func (m *SegmentUInt64Map[V]) ForEach(f func(uint64, V) bool)

ForEach iterates through all key-value pairs Note: The iteration is not atomic and may miss concurrent updates

func (*SegmentUInt64Map[V]) Get 

func (m *SegmentUInt64Map[V]) Get(key uint64) (V, bool)

Get retrieves a value by key

func (*SegmentUInt64Map[V]) Has 

func (m *SegmentUInt64Map[V]) Has(key uint64) bool

Has checks if a key exists in the map

func (*SegmentUInt64Map[V]) Keys 

func (m *SegmentUInt64Map[V]) Keys() iter.Seq[uint64]

Keys returns an iterator over all keys

func (*SegmentUInt64Map[V]) Len 

func (m *SegmentUInt64Map[V]) Len() int64

Len returns the number of elements in the map

func (*SegmentUInt64Map[V]) PutIfNotExists 

func (m *SegmentUInt64Map[V]) PutIfNotExists(key uint64, value V) (V, bool)

PutIfNotExists adds the key-value pair only if the key doesn't already exist Returns the value and true if inserted, or existing value and false if not inserted

func (*SegmentUInt64Map[V]) SegmentCount 

func (m *SegmentUInt64Map[V]) SegmentCount() int

SegmentCount returns the number of segments

func (*SegmentUInt64Map[V]) Set 

func (m *SegmentUInt64Map[V]) Set(key uint64, value V)

Set adds or updates a key-value pair

func (*SegmentUInt64Map[V]) Stop 

func (m *SegmentUInt64Map[V]) Stop()

Stop is a no-op for compatibility

func (*SegmentUInt64Map[V]) Values 

func (m *SegmentUInt64Map[V]) Values() iter.Seq[V]

Values returns an iterator over all values

type SyncUInt64Map 

type SyncUInt64Map[V any] struct {
	// contains filtered or unexported fields
}

SyncUInt64Map wraps SegmentUInt64Map to provide the expected interface

func NewSyncUInt64Map 

func NewSyncUInt64Map[V any](sizePower uint) *SyncUInt64Map[V]

NewSyncUInt64Map creates a new map

func (*SyncUInt64Map[V]) All 

func (m *SyncUInt64Map[V]) All() iter.Seq2[uint64, V]

All returns an iterator

func (*SyncUInt64Map[V]) Clear 

func (m *SyncUInt64Map[V]) Clear()

Clear removes all entries - FAST!

func (*SyncUInt64Map[V]) ClearSegment 

func (m *SyncUInt64Map[V]) ClearSegment(index int)

ClearSegment clears a specific segment - for radical eviction

func (*SyncUInt64Map[V]) Compact 

func (m *SyncUInt64Map[V]) Compact() int

Compact is a no-op for this implementation as it handles memory efficiently

func (*SyncUInt64Map[V]) Del 

func (m *SyncUInt64Map[V]) Del(key uint64) bool

Del removes a key from the map

func (*SyncUInt64Map[V]) ForEach 

func (m *SyncUInt64Map[V]) ForEach(f func(uint64, V) bool)

ForEach iterates over all entries

func (*SyncUInt64Map[V]) Get 

func (m *SyncUInt64Map[V]) Get(key uint64) (V, bool)

Get retrieves a value by key

func (*SyncUInt64Map[V]) Has 

func (m *SyncUInt64Map[V]) Has(key uint64) bool

Has checks if a key exists

func (*SyncUInt64Map[V]) Len 

func (m *SyncUInt64Map[V]) Len() int64

Len returns the number of entries

func (*SyncUInt64Map[V]) RandomSample 

func (m *SyncUInt64Map[V]) RandomSample(maxSample int) []uint64

RandomSample returns a random sample of keys

func (*SyncUInt64Map[V]) SegmentCount 

func (m *SyncUInt64Map[V]) SegmentCount() int

SegmentCount returns the number of segments

func (*SyncUInt64Map[V]) Set 

func (m *SyncUInt64Map[V]) Set(key uint64, value V)

Set adds or updates a key-value pair

func (*SyncUInt64Map[V]) Stop 

func (m *SyncUInt64Map[V]) Stop()

Stop is a no-op for compatibility

type UInt64Map 

type UInt64Map[V any] struct {
	// contains filtered or unexported fields
}

UInt64Map is a specialized map for uint64 keys. It is specifically optimized for clustered keys, where keys are likely to be close to each other (e.g., sequential IDs, timestamp ranges).

func NewUInt64Map 

func NewUInt64Map[V any](capacity int) *UInt64Map[V]

NewUInt64Map creates a new UInt64Map with given capacity

func (*UInt64Map[V]) All 

func (m *UInt64Map[V]) All() iter.Seq2[uint64, V]

All returns an iterator over key-value pairs

func (*UInt64Map[V]) Clear 

func (m *UInt64Map[V]) Clear()

Clear removes all items from the map

func (*UInt64Map[V]) Del 

func (m *UInt64Map[V]) Del(key uint64) bool

Del deletes a key and its value

func (*UInt64Map[V]) ForEach 

func (m *UInt64Map[V]) ForEach(f func(uint64, V) bool)

ForEach iterates through all key-value pairs

func (*UInt64Map[V]) Get 

func (m *UInt64Map[V]) Get(key uint64) (V, bool)

Get retrieves a value by key

func (*UInt64Map[V]) Has 

func (m *UInt64Map[V]) Has(key uint64) bool

Has checks if key exists in the map

func (*UInt64Map[V]) Keys 

func (m *UInt64Map[V]) Keys() iter.Seq[uint64]

Keys returns an iterator over keys

func (*UInt64Map[V]) Len 

func (m *UInt64Map[V]) Len() int

Len returns the number of elements in the map

func (*UInt64Map[V]) Put 

func (m *UInt64Map[V]) Put(key uint64, val V)

Put adds or updates key with value

func (*UInt64Map[V]) PutIfNotExists 

func (m *UInt64Map[V]) PutIfNotExists(key uint64, val V) (V, bool)

PutIfNotExists adds key-value pair only if key doesn't exist

func (*UInt64Map[V]) Values 

func (m *UInt64Map[V]) Values() iter.Seq[V]

Values returns an iterator over values

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.