chandy_lamport

type EndSnapshot ¶

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

A message that signifies the end of the snapshot process on a particular server. This is used only for debugging that is not sent between servers.

func (m EndSnapshot) String() string

type Link ¶

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

A unidirectional communication channel between two servers Each link contains an event queue (as opposed to a packet queue)

type LogEvent ¶

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

func (event LogEvent) String() string

type Logger ¶

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

func NewLogger() *Logger

func (log *Logger) NewEpoch()

func (log *Logger) PrettyPrint()

func (logger *Logger) RecordEvent(server *Server, event interface{})

type MarkerMessage ¶

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

A message sent from one server to another during the chandy-lamport algorithm. This is expected to be encapsulated within a `sendMessageEvent`.

func (m MarkerMessage) String() string

type PassTokenEvent ¶

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

An event parsed from the .event files that represent the passing of tokens from one server to another

type Queue ¶

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

Define a queue -- simple implementation over List

func NewQueue() *Queue

func (q *Queue) Empty() bool

func (q *Queue) Peek() interface{}

func (q *Queue) Pop() interface{}

func (q *Queue) Push(v interface{})

type ReceivedMessageEvent ¶

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

A message that signifies receiving of a message on a particular server This is used only for debugging that is not sent between servers

func (m ReceivedMessageEvent) String() string

type SendMessageEvent ¶

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

An event that represents the sending of a message. This is expected to be queued in `link.events`.

type SentMessageEvent ¶

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

A message that signifies sending of a message on a particular server This is used only for debugging that is not sent between servers

func (m SentMessageEvent) String() string

type Server ¶

type Server struct {
	Id     string
	Tokens int
	// contains filtered or unexported fields
}

The main participant of the distributed snapshot protocol. Servers exchange token messages and marker messages among each other. Token messages represent the transfer of tokens from one server to another. Marker messages represent the progress of the snapshot process. The bulk of the distributed protocol is implemented in `HandlePacket` and `StartSnapshot`.

func NewServer(id string, tokens int, sim *Simulator) *Server

func (server *Server) AddOutboundLink(dest *Server)

func (server *Server) HandlePacket(src string, message interface{})

func (server *Server) SendToNeighbors(message interface{})

func (server *Server) SendTokens(numTokens int, dest string)

func (server *Server) StartSnapshot(snapshotId int)

type Simulator ¶

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

Simulator is the entry point to the distributed snapshot application.

It is a discrete time simulator, i.e. events that happen at time t + 1 come strictly after events that happen at time t. At each time step, the simulator examines messages queued up across all the links in the system and decides which ones to deliver to the destination.

The simulator is responsible for starting the snapshot process, inducing servers to pass tokens to each other, and collecting the snapshot state after the process has terminated.

func NewSimulator() *Simulator

func (sim *Simulator) AddForwardLink(src string, dest string)

func (sim *Simulator) AddServer(id string, tokens int)

func (sim *Simulator) CollectSnapshot(snapshotId int) *SnapshotState

func (sim *Simulator) GetReceiveTime() int

func (sim *Simulator) InjectEvent(event interface{})

func (sim *Simulator) NotifySnapshotComplete(serverId string, snapshotId int)

func (sim *Simulator) StartSnapshot(serverId string)

func (sim *Simulator) Tick()

type SnapshotEvent ¶

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

An event parsed from the .event files that represent the initiation of the chandy-lamport snapshot algorithm

type SnapshotMessage ¶

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

A message recorded during the snapshot process

type SnapshotState ¶

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

State recorded during the snapshot process

type StartSnapshot ¶

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

A message that signifies the beginning of the snapshot process on a particular server. This is used only for debugging that is not sent between servers.

func (m StartSnapshot) String() string

type SyncMap ¶

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

An implementation of a map that synchronizes read and write accesses. Note: This class intentionally adopts the interface of `sync.Map`, which is introduced in Go 1.9+ but not available before that. This provides a simplified version of the same class without requiring the user to upgrade their Go installation.

func NewSyncMap() *SyncMap

func (m *SyncMap) Delete(key interface{})

func (m *SyncMap) Load(key interface{}) (value interface{}, ok bool)

func (m *SyncMap) LoadOrStore(key, value interface{}) (interface{}, bool)

func (m *SyncMap) Range(f func(key, value interface{}) bool)

func (m *SyncMap) Store(key, value interface{})

type TokenMessage ¶

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

A message sent from one server to another for token passing. This is expected to be encapsulated within a `sendMessageEvent`.

func (m TokenMessage) String() string