node

type BaseNode ¶

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

BaseNode implements the common logic for all nodes. Specific node types should embed BaseNode and implement NodeHandler.

func NewBaseNode(id int, handler NodeHandler) *BaseNode

func (n *BaseNode) AddCache(c cache.Cache)

func (n *BaseNode) AddDirectory(d directory.Directory)

func (n *BaseNode) AddInputQueue(q InputQueue) error

func (n *BaseNode) AddOutputQueue(q OutputQueue) error

func (n *BaseNode) AdvanceTo(targetCycle int) error

func (n *BaseNode) Caches() []cache.Cache

func (n *BaseNode) CurrentCycle() int

func (n *BaseNode) DeleteData(key string)

func (n *BaseNode) Directories() []directory.Directory

func (n *BaseNode) GetAllData() map[string]interface{}

func (n *BaseNode) GetData(key string) interface{}

func (n *BaseNode) GetOutputQueue(index int) OutputQueue

func (n *BaseNode) HasData(key string) bool

func (n *BaseNode) ID() int

func (n *BaseNode) InjectPacket(pkt packet.Packet) error

func (n *BaseNode) InputQueues() []InputQueue

func (n *BaseNode) OutputQueues() []OutputQueue

func (n *BaseNode) SetData(key string, value interface{})

func (n *BaseNode) Tick(cycle uint64, _ time.Duration) error

func (n *BaseNode) UpdateData(modifier func(map[string]interface{}))

func (n *BaseNode) UpdateKeyData(key string, modifier func(interface{}) interface{})

type BufferlessRingRouterNode ¶

type BufferlessRingRouterNode struct {
	*BaseNode // Embed BaseNode for base functionality
	// contains filtered or unexported fields
}

BufferlessRingRouterNode implements a router for bufferless ring topology.

Architecture: - 4 ports: ringIn, ringOut, localIn, localOut - Internal buffer ONLY for local injection (ring traffic never buffered) - Routing logic: check packet.TargetID to decide ejection vs. forwarding

Key Design Principles: - Ring traffic NEVER buffered in router (always forwarded immediately) - Packets that cannot eject continue on ring (loop around) - Only local injection needs buffering (when ring temporarily busy) - Backpressure only (no packet dropping)

Queue Assignment: - inputs[0]: ringInQueue (from previous router) - inputs[1]: localInQueue (from local worker) - outputs[0]: ringOutQueue (to next router) - outputs[1]: localOutQueue (to local worker)

func NewBufferlessRingRouter(routerID, workerID, bufferCapacity int) *BufferlessRingRouterNode

func (r *BufferlessRingRouterNode) GetBufferCapacity() int

func (r *BufferlessRingRouterNode) GetBufferOccupancy() int

func (r *BufferlessRingRouterNode) GetInjectionBufferOccupancy() int

func (r *BufferlessRingRouterNode) GetVisualState() string

func (r *BufferlessRingRouterNode) GetWorkerID() int

func (r *BufferlessRingRouterNode) Process(cycle uint64, inputs [][]queue.PacketRef) error

type InputQueue ¶

type InputQueue interface {
	Pick() []packet.Packet
	PeekPickTo(out []queue.PacketRef) int
	Tick(cycle int) error
	Length() int
	Capacity() int
	IsFull() bool
}

InputQueue describes the behaviors Node needs from an input buffer.

type Node ¶

type Node interface {
	ID() int
	Tick(cycle uint64, duration time.Duration) error
	AddInputQueue(q InputQueue) error
	AddOutputQueue(q OutputQueue) error
	InputQueues() []InputQueue
	OutputQueues() []OutputQueue

	AddCache(c cache.Cache)
	Caches() []cache.Cache
	AddDirectory(d directory.Directory)
	Directories() []directory.Directory

	InjectPacket(pkt packet.Packet) error
	AdvanceTo(targetCycle int) error
	CurrentCycle() int

	SetData(key string, value interface{})
	GetData(key string) interface{}
	HasData(key string) bool
	DeleteData(key string)
	UpdateData(modifier func(map[string]interface{}))
	UpdateKeyData(key string, modifier func(interface{}) interface{})
}

Node defines the public interface for all simulation nodes. Node defines the public interface for all simulation nodes.

type NodeHandler ¶

type NodeHandler interface {
	// Process handles data for the current cycle.
	// It receives packets from all input queues, indexed by queue ID.
	// Returns an error if processing fails.
	// Implementations should use BaseNode.GetOutputQueue(i).InjectPackets() to send data.
	//
	// Parameters:
	//   cycle: current simulation cycle
	//   inputs: packets received in this cycle from each input queue (inputs[i] comes from InputQueue i)
	Process(cycle uint64, inputs [][]queue.PacketRef) error
}

NodeHandler defines the interface that specific node implementations must satisfy.

type OutputQueue ¶

type OutputQueue interface {
	Tick(cycle int) error
	Length() int
	Capacity() int
	IsFull() bool
	InjectPackets(cycle int, packets []packet.Packet) error
	OutBandwidth() int
}

OutputQueue describes the behaviors Node needs from an output buffer.

type Tickable ¶

type Tickable interface {
	Tick(cycle uint64, duration time.Duration) error
}

Tickable is an interface for components that can be ticked.

type WorkerNode ¶

type WorkerNode struct {
	*BaseNode
	// contains filtered or unexported fields
}

WorkerNode is a concrete node type for general purpose use (e.g. in simulator). It allows injecting custom behavior via hooks.

func NewWorkerNode(id int) *WorkerNode

func (w *WorkerNode) GetProcessBuffer() []packet.Packet

func (w *WorkerNode) Process(cycle uint64, inputs [][]queue.PacketRef) error

func (w *WorkerNode) SetProcessHook(hook func(cycle uint64, inputs [][]queue.PacketRef) error)