capacity

type CapacityConnector ¶

type CapacityConnector interface {
	interfaces.DataTransport
}

Allow connecting between two nodes via scheduler

func NewCapacityConnector(
	up, down int,
	capacityMap CapacityMap,
) CapacityConnector

type CapacityMap ¶

type CapacityMap interface {
	AddConnector(id string, connector CapacityConnector)
	Connector(id string) CapacityConnector

	RegisterLink(link interfaces.Link)
	Start(simulation *underlay.NetworkSimulation)

	// A simulation Receiver associated with the CapacityMap. Allows
	// registering observers that follow the map.
	Receiver() events.Receiver
}

Allow access the CapacityConnector

func NewScheduledCapacityMap(scheduleInterval int) CapacityMap

type PerfectCapacityConnector ¶

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

func (c *PerfectCapacityConnector) Connect(id string) interfaces.Link

func (c *PerfectCapacityConnector) Down() int

func (c *PerfectCapacityConnector) Up() int

type PerfectLink ¶

type PerfectLink struct {
	*sync.Mutex
	// contains filtered or unexported fields
}

Assumptions:

• equal link share & max capacity
• no latency effects
• end-capacity is the bottleneck

func (p *PerfectLink) Clear()

func (p *PerfectLink) Download() <-chan Data

func (p *PerfectLink) From() NodeCapacity

func (p *PerfectLink) To() NodeCapacity

func (p *PerfectLink) Upload(data Data)

type ScheduledCapacityMap ¶

type ScheduledCapacityMap struct {
	*sync.RWMutex
	// contains filtered or unexported fields
}

A capacity map that uses a capacity scheduler for allowing data transfer between nodes. Note the capacity scheduler is already thread-safe.

func (c *ScheduledCapacityMap) AddConnector(
	id string,
	capacityConnector CapacityConnector,
)

func (c *ScheduledCapacityMap) Connector(id string) CapacityConnector

func (c *ScheduledCapacityMap) Receiver() events.Receiver

func (c *ScheduledCapacityMap) RegisterLink(link interfaces.Link)

func (c *ScheduledCapacityMap) Start(sim *underlay.NetworkSimulation)

type Scheduler ¶

type Scheduler interface {
	Receiver

	RegisterLink(Link)
	Schedule()
}

The simulator is based on a scheduler which computes the transfer speed associated with each link in the topology. The scheduler runs periodically at an established period, by implementing the Receiver interface and stopping the simulation to recalculate the transfer rates. The main assumption under which the simulator calculates the transfer rates are the equal share and maximum capacity utilization.

func NewScheduler(interval int) Scheduler