proposalmanager

package
v0.0.0-...-5782b8f Latest Latest
Warning

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

 Go to latest Published: Oct 4, 2022 License: Apache-2.0 Imports: 17 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AcceptorQrmInfo 

type AcceptorQrmInfo interface {
	IsInGroup(inst int32, aid int32) bool
	GetGroup(inst int32) []int32
}

type BackoffInfo 

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

type BackoffManager 

type BackoffManager struct {
	BackoffInfo
	// contains filtered or unexported fields
}

func BackoffManagerNew 

func BackoffManagerNew(minBO, maxInitBO, maxBO int32, signalChan chan RetryInfo, factor float64, softFac bool, constBackoff bool) *BackoffManager

func (*BackoffManager) CheckAndHandleBackoff 

func (bm *BackoffManager) CheckAndHandleBackoff(inst int32, attemptedBal lwcproto.ConfigBal, preempter lwcproto.ConfigBal, prempterPhase stdpaxosproto.Phase) (bool, int32)

func (*BackoffManager) ShouldBackoff 

func (bm *BackoffManager) ShouldBackoff(inst int32, preempter lwcproto.ConfigBal, preempterPhase stdpaxosproto.Phase) bool

func (*BackoffManager) StillRelevant 

func (bm *BackoffManager) StillRelevant(backoff RetryInfo) bool

func (*BackoffManager) StopBackoffs 

func (bm *BackoffManager) StopBackoffs(inst int32)

type Balloter 

type Balloter struct {
	PropID, N, MaxInc          int32
	TimeSinceValueLastSelected time.Time
	DoTimeBasedBallot          bool
}

func (*Balloter) GetAttemptNumber 

func (ballot *Balloter) GetAttemptNumber(rnd int32) int

func (*Balloter) GetNextProposingBal 

func (balloter *Balloter) GetNextProposingBal(config int32, maxPrevRoundNum int32) lwcproto.ConfigBal

func (*Balloter) UpdateProposalChosen 

func (balloter *Balloter) UpdateProposalChosen()

type CrtInstanceOracle 

type CrtInstanceOracle interface {
	GetCrtInstance() int32
}

type DynamicAgentMapper 

type DynamicAgentMapper interface {
	instanceagentmapper.InstanceAgentMapper
	SetGroup(g int32)
}

type DynamicInstanceSetMapper 

type DynamicInstanceSetMapper struct {
	instanceagentmapper.DetRandInstanceSetMapper
}

func (*DynamicInstanceSetMapper) SetGroup 

func (m *DynamicInstanceSetMapper) SetGroup(g int32)

type DynamicMappedGlobalManager 

type DynamicMappedGlobalManager struct {
	*StaticMappedProposalManager

	DynamicAgentMapper
	// contains filtered or unexported fields
}

func DynamicMappedProposerManagerNew 

func DynamicMappedProposerManagerNew(proposalManager *SimpleGlobalManager, iMan SingleInstanceManager, aMapper DynamicAgentMapper, n int32, f int32) *DynamicMappedGlobalManager

func (*DynamicMappedGlobalManager) DecideRetry 

func (decider *DynamicMappedGlobalManager) DecideRetry(pbk *PBK, retry RetryInfo) bool

func (*DynamicMappedGlobalManager) LearnBallotChosen 

func (decider *DynamicMappedGlobalManager) LearnBallotChosen(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal)

func (*DynamicMappedGlobalManager) LearnNoop 

func (decider *DynamicMappedGlobalManager) LearnNoop(inst int32, who int32)

func (*DynamicMappedGlobalManager) LearnOfBallot 

func (decider *DynamicMappedGlobalManager) LearnOfBallot(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) bool

func (*DynamicMappedGlobalManager) StartNextInstance 

func (decider *DynamicMappedGlobalManager) StartNextInstance(instanceSpace *[]*PBK, startFunc func(inst int32)) []int32

type EagerFI 

type EagerFI struct {
	SingleInstanceManager
	*EagerSig
	*BackoffManager

	*genericsmr.Replica

	instanceagentmapper.DetRandInstanceSetMapper
	// contains filtered or unexported fields
}

func EagerForwardInductionProposalManagerNew 

func EagerForwardInductionProposalManagerNew(n int32, id int32, signal *EagerSig, iManager SingleInstanceManager, backoffManager *BackoffManager, replica *genericsmr.Replica, stateRPC uint8) *EagerFI

func (*EagerFI) DecideRetry 

func (manager *EagerFI) DecideRetry(pbk *PBK, retry RetryInfo) bool

func (*EagerFI) GetCrtInstance 

func (manager *EagerFI) GetCrtInstance() int32

func (*EagerFI) GetReservationMsg 

func (manager *EagerFI) GetReservationMsg() *proposerstate.State

func (*EagerFI) HandleNewInstance 

func (manager *EagerFI) HandleNewInstance(iSpace *[]*PBK, inst int32)

func (*EagerFI) LearnBallotChosen 

func (manager *EagerFI) LearnBallotChosen(instanceSpace *[]*PBK, inst int32, at lwcproto.ConfigBal)

func (*EagerFI) LearnOfBallot 

func (manager *EagerFI) LearnOfBallot(iSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) bool

func (*EagerFI) LearnOfBallotAccepted 

func (manager *EagerFI) LearnOfBallotAccepted(iSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, whosecmds int32)

func (*EagerFI) StartNextInstance 

func (manager *EagerFI) StartNextInstance(instanceSpace *[]*PBK, startFunc func(inst int32)) []int32

func (*EagerFI) StartNextProposal 

func (manager *EagerFI) StartNextProposal(pbk *PBK, inst int32)

type EagerSig 

type EagerSig struct {
	*SimpleSig
	MaxOpenInsts int32
}

func EagerSigNew 

func EagerSigNew(simpleSig *SimpleSig, maxOI int32) *EagerSig

func (*EagerSig) CheckChosen 

func (manager *EagerSig) CheckChosen(pbk *PBK, inst int32, ballot lwcproto.ConfigBal)

func (*EagerSig) Close 

func (manager *EagerSig) Close(inst int32)
func (sig *EagerSig) CheckOngoingBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) {
	if pbk.Status == CLOSED {
		return
	}

	_, e := sig.instsStarted[inst]
	if !e {
		return
	}

	if int32(ballot.PropID) == sig.id && pbk.Status != PROPOSING {
		return
	}

	if (pbk.PropCurBal.Equal(ballot) || pbk.PropCurBal.GreaterThan(ballot)) && phase == stdpaxosproto.PROMISE {
		return
	}

	if pbk.Status == PROPOSING && phase == stdpaxosproto.ACCEPTANCE { // we are already proopsing our own value
		return
	}

	//if pbk.PropCurBal.GreaterThan(ballot) && pbk.Status == PROPOSING && phase == stdpaxosproto.ACCEPTANCE {
	//	return
	//}

	dlog.AgentPrintfN(sig.id, "Signalling to open new instance as instance %d %s", inst, "as it is preempted")
	go func() { sig.sigNewInst <- struct{}{} }()
	delete(sig.instsStarted, inst)
}

func (*EagerSig) DoSig 

func (sig *EagerSig) DoSig()

func (*EagerSig) Opened 

func (sig *EagerSig) Opened(o []int32)

type FailureEstimator 

type FailureEstimator struct {
	*genericsmr.Replica
	// contains filtered or unexported fields
}

func FailureEstimatorNew 

func FailureEstimatorNew(replica *genericsmr.Replica) *FailureEstimator

func (*FailureEstimator) GetChan 

func (est *FailureEstimator) GetChan() chan fastrpc.Serializable

func (*FailureEstimator) SendLatencies 

func (est *FailureEstimator) SendLatencies()

type GlobalInstanceManager 

type GlobalInstanceManager interface {
	CrtInstanceOracle
	ProposalManager
}

type HedgedSig 

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

func HedgedSigNew 

func HedgedSigNew(id int32, newInstSig chan struct{}) *HedgedSig

func (*HedgedSig) CheckAcceptedBallot 

func (sig *HedgedSig) CheckAcceptedBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, whosecmds int32)

func (*HedgedSig) CheckChosen 

func (sig *HedgedSig) CheckChosen(pbk *PBK, inst int32, ballot lwcproto.ConfigBal)

func (*HedgedSig) CheckOngoingBallot 

func (sig *HedgedSig) CheckOngoingBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase)

func (*HedgedSig) Opened 

func (sig *HedgedSig) Opened(opened []int32)

type InstanceQuormaliser 

type InstanceQuormaliser interface {
	ProposerInstanceQuorumaliser
	LearnerQuorumaliser
	AcceptorQrmInfo
}

type IntRange 

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

range specification, note that min <= max

func (*IntRange) NextRandom 

func (ir *IntRange) NextRandom(r *rand.Rand) int

get next random value within the interval including min and max

type LatenciesMsg 

type LatenciesMsg struct {
	Aid       int32
	Latencies []time.Duration
}

func (LatenciesMsg) Marshal 

func (l LatenciesMsg) Marshal(writer io.Writer)

func (LatenciesMsg) New 

func (l LatenciesMsg) New() fastrpc.Serializable

func (LatenciesMsg) Unmarshal 

func (l LatenciesMsg) Unmarshal(reader io.Reader) error

type LearnerQuorumaliser 

type LearnerQuorumaliser interface {
	TrackProposalAcceptance(pbk *PBK, inst int32, bal lwcproto.ConfigBal)
}

type Minimal 

type Minimal struct {
	AcceptorMapper instanceagentmapper.InstanceAgentMapper
	MapperCache    map[int32][]int32
	quorumsystem.SynodQuorumSystemConstructor
	MyID int32
}

func (*Minimal) GetGroup 

func (qrmliser *Minimal) GetGroup(inst int32) []int32

func (*Minimal) IsInGroup 

func (qrmliser *Minimal) IsInGroup(inst int32, aid int32) bool

func (*Minimal) StartPromiseQuorumOnCurBal 

func (qrmliser *Minimal) StartPromiseQuorumOnCurBal(pbk *PBK, inst int32)

func (*Minimal) TrackProposalAcceptance 

func (qrmliser *Minimal) TrackProposalAcceptance(pbk *PBK, inst int32, bal lwcproto.ConfigBal)

type MinimalProposersInstanceManager 

type MinimalProposersInstanceManager struct {
	*SimpleInstanceManager
	*MinimalProposersShouldMaker
}

func MinimalProposersInstanceManagerNew 

func MinimalProposersInstanceManagerNew(manager *SimpleInstanceManager, minimalProposer *MinimalProposersShouldMaker) *MinimalProposersInstanceManager

func (*MinimalProposersInstanceManager) HandleProposalChosen 

func (man *MinimalProposersInstanceManager) HandleProposalChosen(pbk *PBK, inst int32, ballot lwcproto.ConfigBal)

func (*MinimalProposersInstanceManager) HandleReceivedBallot 

func (man *MinimalProposersInstanceManager) HandleReceivedBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) bool

func (*MinimalProposersInstanceManager) ShouldRetryInstance 

func (man *MinimalProposersInstanceManager) ShouldRetryInstance(pbk *PBK, retry RetryInfo) bool

func (*MinimalProposersInstanceManager) StartProposal 

func (man *MinimalProposersInstanceManager) StartProposal(pbk *PBK, inst int32)

type MinimalProposersShouldMaker 

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

does not protect against own ballots - user must make sure ballot is not own

func MinimalProposersShouldMakerNew 

func MinimalProposersShouldMakerNew(id int16, f int) *MinimalProposersShouldMaker

func (*MinimalProposersShouldMaker) BallotReceived 

func (p *MinimalProposersShouldMaker) BallotReceived(inst int32, ballot lwcproto.ConfigBal)

func (*MinimalProposersShouldMaker) Cleanup 

func (p *MinimalProposersShouldMaker) Cleanup(inst int32)

func (*MinimalProposersShouldMaker) GetGroup 

func (p *MinimalProposersShouldMaker) GetGroup(inst int32)

func (*MinimalProposersShouldMaker) GetOngoingProposal 

func (p *MinimalProposersShouldMaker) GetOngoingProposal(inst int32, pid int16) lwcproto.ConfigBal

func (*MinimalProposersShouldMaker) GetOngoingProposals 

func (p *MinimalProposersShouldMaker) GetOngoingProposals(inst int32) map[int16]lwcproto.ConfigBal

func (*MinimalProposersShouldMaker) SetOngoingProposals 

func (p *MinimalProposersShouldMaker) SetOngoingProposals(inst int32, ballot lwcproto.ConfigBal)

func (*MinimalProposersShouldMaker) ShouldSkipInstance 

func (p *MinimalProposersShouldMaker) ShouldSkipInstance(inst int32) bool

type NoopLearner 

type NoopLearner interface {
	LearnNoop(inst int32, who int32)
}

type OpenInstSignal 

type OpenInstSignal interface {
	Opened(opened []int32)
	CheckOngoingBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase)
	CheckAcceptedBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, whosecmds int32)
	CheckChosen(pbk *PBK, inst int32, ballot lwcproto.ConfigBal)
}

type PBK 

type PBK struct {
	Status          ProposerStatus
	Qrms            map[lwcproto.ConfigBal]quorumsystem.SynodQuorumSystem
	ProposeValueBal lwcproto.ConfigBal // highest ProposeValueBal at which a command was accepted
	WhoseCmds       int32
	Cmds            []*state.Command   // the accepted command
	PropCurBal      lwcproto.ConfigBal // highest this replica ProposeValueBal tried so far
	ClientProposals batching.ProposalBatch
	MaxKnownBal     lwcproto.ConfigBal
}

func GetEmptyInstance 

func GetEmptyInstance() *PBK

func (*PBK) PutBatch 

func (pbk *PBK) PutBatch(bat batching.ProposalBatch)

func (*PBK) SetNowProposing 

func (pbk *PBK) SetNowProposing()

type ProposalManager 

type ProposalManager interface {
	StartNextInstance(instanceSpace *[]*PBK, startFunc func(inst int32)) []int32
	StartNextProposal(initiator *PBK, inst int32)
	//ProposingValue(instanceSpace *[]*PBK, inst int32, ballot stdpaxosproto.Ballot)
	LearnOfBallot(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) bool // returns if proposer's ballot is preempted
	LearnOfBallotAccepted(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, whosecmds int32)
	LearnBallotChosen(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal)
	DecideRetry(pbk *PBK, retry RetryInfo) bool
}

type ProposerInstanceQuorumaliser 

type ProposerInstanceQuorumaliser interface {
	StartPromiseQuorumOnCurBal(pbk *PBK, inst int32)
}

type ProposerStatus 

type ProposerStatus int
const (
	NOT_BEGUN ProposerStatus = iota
	BACKING_OFF
	PREPARING
	READY_TO_PROPOSE
	PROPOSING
	CLOSED
)

type RetryInfo 

type RetryInfo struct {
	Inst           int32
	AttemptedBal   lwcproto.ConfigBal
	PreempterBal   lwcproto.ConfigBal
	PreempterAt    stdpaxosproto.Phase
	Prev           int32
	TimesPreempted int32
}

type SimpleGlobalManager 

type SimpleGlobalManager struct {
	SingleInstanceManager
	OpenInstSignal
	*BackoffManager
	// contains filtered or unexported fields
}

func SimpleProposalManagerNew 

func SimpleProposalManagerNew(id int32, signal OpenInstSignal, iManager SingleInstanceManager, backoffManager *BackoffManager) *SimpleGlobalManager

func (*SimpleGlobalManager) DecideRetry 

func (manager *SimpleGlobalManager) DecideRetry(pbk *PBK, retry RetryInfo) bool

func (*SimpleGlobalManager) GetCrtInstance 

func (manager *SimpleGlobalManager) GetCrtInstance() int32

func (*SimpleGlobalManager) LearnBallotChosen 

func (manager *SimpleGlobalManager) LearnBallotChosen(instanceSpace *[]*PBK, inst int32, at lwcproto.ConfigBal)

func (*SimpleGlobalManager) LearnOfBallot 

func (manager *SimpleGlobalManager) LearnOfBallot(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) bool

func (*SimpleGlobalManager) LearnOfBallotAccepted 

func (manager *SimpleGlobalManager) LearnOfBallotAccepted(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, whosecmds int32)

func (*SimpleGlobalManager) StartNextInstance 

func (manager *SimpleGlobalManager) StartNextInstance(instanceSpace *[]*PBK, startFunc func(inst int32)) []int32

func (*SimpleGlobalManager) StartNextProposal 

func (manager *SimpleGlobalManager) StartNextProposal(pbk *PBK, inst int32)

func (*SimpleGlobalManager) UpdateCurrentInstance 

func (manager *SimpleGlobalManager) UpdateCurrentInstance(instsanceSpace *[]*PBK, inst int32)

type SimpleHedgedBets 

type SimpleHedgedBets struct {
	*SimpleGlobalManager
	// contains filtered or unexported fields
}

func HedgedBetsProposalManagerNew 

func HedgedBetsProposalManagerNew(id int32, manager *SimpleGlobalManager, n int32, initialHedge int32) *SimpleHedgedBets

func (*SimpleHedgedBets) DecideRetry 

func (manager *SimpleHedgedBets) DecideRetry(pbk *PBK, retry RetryInfo) bool

func (*SimpleHedgedBets) LearnBallotChosen 

func (manager *SimpleHedgedBets) LearnBallotChosen(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal)

func (*SimpleHedgedBets) LearnNoop 

func (manager *SimpleHedgedBets) LearnNoop(inst int32, who int32)

func (*SimpleHedgedBets) LearnOfBallot 

func (manager *SimpleHedgedBets) LearnOfBallot(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) bool

func (*SimpleHedgedBets) LearnOfBallotAccepted 

func (manager *SimpleHedgedBets) LearnOfBallotAccepted(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, whosecmds int32)

func (*SimpleHedgedBets) StartNextInstance 

func (manager *SimpleHedgedBets) StartNextInstance(instanceSpace *[]*PBK, startFunc func(inst int32)) []int32

type SimpleInstanceManager 

type SimpleInstanceManager struct {
	*BackoffManager
	Balloter
	ProposerInstanceQuorumaliser
	*stats.TimeseriesStats
	*stats.ProposalStats
	*stats.InstanceStats
	// contains filtered or unexported fields
}

func SimpleInstanceManagerNew 

func SimpleInstanceManagerNew(id int32, manager *BackoffManager, balloter Balloter, doStats bool, qrm ProposerInstanceQuorumaliser, tsStats *stats.TimeseriesStats, proposalStats *stats.ProposalStats, instanceStats *stats.InstanceStats) *SimpleInstanceManager

func (*SimpleInstanceManager) HandleProposalChosen 

func (man *SimpleInstanceManager) HandleProposalChosen(pbk *PBK, inst int32, ballot lwcproto.ConfigBal)

func (*SimpleInstanceManager) HandleReceivedBallot 

func (man *SimpleInstanceManager) HandleReceivedBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) bool

func (*SimpleInstanceManager) InitInstance 

func (man *SimpleInstanceManager) InitInstance(inst int32) *PBK

func (*SimpleInstanceManager) ShouldRetryInstance 

func (man *SimpleInstanceManager) ShouldRetryInstance(pbk *PBK, retry RetryInfo) bool

func (*SimpleInstanceManager) StartProposal 

func (man *SimpleInstanceManager) StartProposal(pbk *PBK, inst int32)

type SimpleSig 

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

func SimpleSigNew 

func SimpleSigNew(newInstSig chan struct{}, id int32) *SimpleSig

func (*SimpleSig) CheckAcceptedBallot 

func (sig *SimpleSig) CheckAcceptedBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, whosecmds int32)

func (*SimpleSig) CheckChosen 

func (sig *SimpleSig) CheckChosen(pbk *PBK, inst int32, ballot lwcproto.ConfigBal)

func (*SimpleSig) CheckOngoingBallot 

func (sig *SimpleSig) CheckOngoingBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase)

func (*SimpleSig) Opened 

func (sig *SimpleSig) Opened(opened []int32)

type SingleInstanceManager 

type SingleInstanceManager interface {
	InitInstance(inst int32) *PBK
	StartProposal(pbk *PBK, inst int32)
	ShouldRetryInstance(pbk *PBK, retry RetryInfo) bool
	HandleReceivedBallot(pbk *PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) bool
	//HandleAcceptedBallot(pbk *PBK, inst int32, ballot stdpaxosproto.Ballot, cmd []state.Command)
	HandleProposalChosen(pbk *PBK, inst int32, ballot lwcproto.ConfigBal)
}

type Standard 

type Standard struct {
	quorumsystem.SynodQuorumSystemConstructor
	Aids []int32
	MyID int32
}

////////////////////////////// STANDARD /////////////////////////////

func (*Standard) GetGroup 

func (qrmliser *Standard) GetGroup(inst int32) []int32

func (*Standard) IsInGroup 

func (qrmliser *Standard) IsInGroup(inst int32, aid int32) bool

func (*Standard) StartPromiseQuorumOnCurBal 

func (qrmliser *Standard) StartPromiseQuorumOnCurBal(pbk *PBK, inst int32)

func (*Standard) TrackProposalAcceptance 

func (qrmliser *Standard) TrackProposalAcceptance(pbk *PBK, inst int32, bal lwcproto.ConfigBal)

type StaticMapped 

type StaticMapped struct {
	AcceptorMapper instanceagentmapper.FixedInstanceAgentMapping
	//MapperCache    map[int32][]int32
	quorumsystem.SynodQuorumSystemConstructor
	MyID int32
}

func (StaticMapped) GetGroup 

func (qrl StaticMapped) GetGroup(inst int32) []int32

func (StaticMapped) IsInGroup 

func (qrl StaticMapped) IsInGroup(inst int32, aid int32) bool

func (StaticMapped) StartPromiseQuorumOnCurBal 

func (qrl StaticMapped) StartPromiseQuorumOnCurBal(pbk *PBK, inst int32)

func (StaticMapped) TrackProposalAcceptance 

func (qrl StaticMapped) TrackProposalAcceptance(pbk *PBK, inst int32, bal lwcproto.ConfigBal)

type StaticMappedProposalManager 

type StaticMappedProposalManager struct {
	SingleInstanceManager
	*SimpleGlobalManager
	instanceagentmapper.InstanceAgentMapper
}

func MappedProposersProposalManagerNew 

func MappedProposersProposalManagerNew(simpleProposalManager *SimpleGlobalManager, iMan SingleInstanceManager, agentMapper instanceagentmapper.InstanceAgentMapper) *StaticMappedProposalManager

func (*StaticMappedProposalManager) GetProposerInstanceMapper 

func (manager *StaticMappedProposalManager) GetProposerInstanceMapper() instanceagentmapper.InstanceAgentMapper

func (*StaticMappedProposalManager) LearnBallotChosen 

func (manager *StaticMappedProposalManager) LearnBallotChosen(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal)

func (*StaticMappedProposalManager) LearnOfBallot 

func (manager *StaticMappedProposalManager) LearnOfBallot(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, phase stdpaxosproto.Phase) bool

todo should retry only if still in group

func (*StaticMappedProposalManager) LearnOfBallotAccepted 

func (manager *StaticMappedProposalManager) LearnOfBallotAccepted(instanceSpace *[]*PBK, inst int32, ballot lwcproto.ConfigBal, whosecmds int32)

func (*StaticMappedProposalManager) StartNextInstance 

func (manager *StaticMappedProposalManager) StartNextInstance(instanceSpace *[]*PBK, startFunc func(inst int32)) []int32

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.