concurrency

package
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Apr 5, 2021 License: GPL-3.0 Imports: 14 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrPrevExists = &errors.Error{
		Code: consts.ErrCodePrevExists,
		Msg:  "prev exists",
	}
)

Functions

This section is empty.

Types

type AdvancedTxnLockManager 

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

func NewAdvancedTxnLockManager 

func NewAdvancedTxnLockManager(partitionNum int) *AdvancedTxnLockManager

func (*AdvancedTxnLockManager) Initialize 

func (lm *AdvancedTxnLockManager) Initialize(partitionNum int) *AdvancedTxnLockManager

func (*AdvancedTxnLockManager) Lock 

func (lm *AdvancedTxnLockManager) Lock(txnId types.TxnId)

func (*AdvancedTxnLockManager) RLock 

func (lm *AdvancedTxnLockManager) RLock(txnId types.TxnId)

func (*AdvancedTxnLockManager) RUnlock 

func (lm *AdvancedTxnLockManager) RUnlock(txnId types.TxnId)

func (*AdvancedTxnLockManager) Unlock 

func (lm *AdvancedTxnLockManager) Unlock(txnId types.TxnId)

type BasicLockManager 

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

Simplest row lock manager

func NewBasicLockManager 

func NewBasicLockManager() *BasicLockManager

func (*BasicLockManager) Initialize 

func (lm *BasicLockManager) Initialize() *BasicLockManager

func (BasicLockManager) Lock 

func (lm BasicLockManager) Lock(key string)

func (BasicLockManager) RLock 

func (lm BasicLockManager) RLock(key string)

func (BasicLockManager) RUnlock 

func (lm BasicLockManager) RUnlock(key string)

func (BasicLockManager) Unlock 

func (lm BasicLockManager) Unlock(key string)

type BasicTaskLockManager 

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

func NewBasicTaskLockManager 

func NewBasicTaskLockManager() *BasicTaskLockManager

func (*BasicTaskLockManager) Initialize 

func (lm *BasicTaskLockManager) Initialize() *BasicTaskLockManager

func (BasicTaskLockManager) Lock 

func (lm BasicTaskLockManager) Lock(id basic.TaskId)

func (BasicTaskLockManager) RLock 

func (lm BasicTaskLockManager) RLock(id basic.TaskId)

func (BasicTaskLockManager) RUnlock 

func (lm BasicTaskLockManager) RUnlock(id basic.TaskId)

func (BasicTaskLockManager) Unlock 

func (lm BasicTaskLockManager) Unlock(id basic.TaskId)

type BasicTxnLockManager 

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

func NewBasicTxnLockManager 

func NewBasicTxnLockManager() *BasicTxnLockManager

func (*BasicTxnLockManager) Initialize 

func (lm *BasicTxnLockManager) Initialize() *BasicTxnLockManager

func (BasicTxnLockManager) Lock 

func (lm BasicTxnLockManager) Lock(txnId types.TxnId)

func (BasicTxnLockManager) RLock 

func (lm BasicTxnLockManager) RLock(txnId types.TxnId)

func (BasicTxnLockManager) RUnlock 

func (lm BasicTxnLockManager) RUnlock(txnId types.TxnId)

func (BasicTxnLockManager) Unlock 

func (lm BasicTxnLockManager) Unlock(txnId types.TxnId)

type ConcurrentList 

type ConcurrentList struct {
	*list.List
	sync.Mutex
}

func NewConcurrentList 

func NewConcurrentList() *ConcurrentList

type ConcurrentListElement 

type ConcurrentListElement struct {
	CList *ConcurrentList
	*list.Element
}

func NewConcurrentListElement 

func NewConcurrentListElement(cl *ConcurrentList, ele *list.Element) *ConcurrentListElement

type ConcurrentMap 

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

func (*ConcurrentMap) Clear 

func (cmp *ConcurrentMap) Clear()

func (*ConcurrentMap) Del 

func (cmp *ConcurrentMap) Del(key string)

func (*ConcurrentMap) ForEachLoosed 

func (cmp *ConcurrentMap) ForEachLoosed(cb func(string, interface{}))

func (*ConcurrentMap) ForEachStrict 

func (cmp *ConcurrentMap) ForEachStrict(cb func(string, interface{}))

func (*ConcurrentMap) Get 

func (cmp *ConcurrentMap) Get(key string) (interface{}, bool)

func (*ConcurrentMap) GetLazy 

func (cmp *ConcurrentMap) GetLazy(key string, constructor func() interface{}) interface{}

func (*ConcurrentMap) Initialize 

func (cmp *ConcurrentMap) Initialize(partitionNum int)

func (*ConcurrentMap) Lock 

func (cmp *ConcurrentMap) Lock()

func (*ConcurrentMap) MustGet 

func (cmp *ConcurrentMap) MustGet(key string) interface{}

func (*ConcurrentMap) RLock 

func (cmp *ConcurrentMap) RLock()

func (*ConcurrentMap) RUnlock 

func (cmp *ConcurrentMap) RUnlock()

func (*ConcurrentMap) Set 

func (cmp *ConcurrentMap) Set(key string, val interface{})

func (*ConcurrentMap) SetIf 

func (cmp *ConcurrentMap) SetIf(key string, val interface{}, pred func(prev interface{}, exist bool) bool) (success bool, valAfterCall interface{})

func (*ConcurrentMap) Size 

func (cmp *ConcurrentMap) Size() (sz int)

func (*ConcurrentMap) Unlock 

func (cmp *ConcurrentMap) Unlock()

type ConcurrentSet 

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

func NewConcurrentSet 

func NewConcurrentSet() *ConcurrentSet

func (*ConcurrentSet) Contains 

func (s *ConcurrentSet) Contains(key string) bool

func (*ConcurrentSet) Initialize 

func (s *ConcurrentSet) Initialize()

func (*ConcurrentSet) Insert 

func (s *ConcurrentSet) Insert(key string) (newLength int)

func (*ConcurrentSet) Len 

func (s *ConcurrentSet) Len() int

func (*ConcurrentSet) Remove 

func (s *ConcurrentSet) Remove(key string)

type ConcurrentStringSlice 

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

func NewConcurrentStringSlice 

func NewConcurrentStringSlice() *ConcurrentStringSlice

func (*ConcurrentStringSlice) Append 

func (s *ConcurrentStringSlice) Append(str string)

func (*ConcurrentStringSlice) Len 

func (s *ConcurrentStringSlice) Len() int

func (*ConcurrentStringSlice) Strings 

func (s *ConcurrentStringSlice) Strings() []string

type ConcurrentTreeMap 

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

func NewConcurrentTreeMap 

func NewConcurrentTreeMap(comparator utils.Comparator) *ConcurrentTreeMap

func (*ConcurrentTreeMap) Ceiling 

func (ctm *ConcurrentTreeMap) Ceiling(key interface{}) (foundKey interface{}, foundValue interface{})

func (*ConcurrentTreeMap) Clear 

func (ctm *ConcurrentTreeMap) Clear()

func (*ConcurrentTreeMap) Find 

func (ctm *ConcurrentTreeMap) Find(f func(key interface{}, value interface{}) bool) (foundKey interface{}, foundValue interface{})

func (*ConcurrentTreeMap) Floor 

func (ctm *ConcurrentTreeMap) Floor(key interface{}) (foundKey interface{}, foundValue interface{})

func (*ConcurrentTreeMap) Get 

func (ctm *ConcurrentTreeMap) Get(key interface{}) (interface{}, bool)

func (*ConcurrentTreeMap) Insert 

func (ctm *ConcurrentTreeMap) Insert(key interface{}, val interface{}) (success bool)

func (*ConcurrentTreeMap) Max 

func (ctm *ConcurrentTreeMap) Max() (key interface{}, value interface{})

func (*ConcurrentTreeMap) MaxIf 

func (ctm *ConcurrentTreeMap) MaxIf(pred func(key interface{}) bool) (key interface{}, value interface{})

func (*ConcurrentTreeMap) Min 

func (ctm *ConcurrentTreeMap) Min() (key interface{}, value interface{})

func (*ConcurrentTreeMap) Put 

func (ctm *ConcurrentTreeMap) Put(key interface{}, val interface{})

func (*ConcurrentTreeMap) Remove 

func (ctm *ConcurrentTreeMap) Remove(key interface{})

func (*ConcurrentTreeMap) RemoveIf 

func (ctm *ConcurrentTreeMap) RemoveIf(key interface{}, pred func(prev interface{}) bool)

func (*ConcurrentTreeMap) Update 

func (ctm *ConcurrentTreeMap) Update(key interface{}, modifier func(old interface{}) (new interface{}, modified bool)) (success bool)

type ConcurrentTxnMap 

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

func (*ConcurrentTxnMap) Close 

func (cmp *ConcurrentTxnMap) Close()

func (*ConcurrentTxnMap) Contains 

func (cmp *ConcurrentTxnMap) Contains(key types.TxnId) bool

func (*ConcurrentTxnMap) Del 

func (cmp *ConcurrentTxnMap) Del(key types.TxnId)

func (*ConcurrentTxnMap) ForEachLoosed 

func (cmp *ConcurrentTxnMap) ForEachLoosed(cb func(types.TxnId, interface{}))

func (*ConcurrentTxnMap) ForEachStrict 

func (cmp *ConcurrentTxnMap) ForEachStrict(cb func(types.TxnId, interface{}))

func (*ConcurrentTxnMap) GCWhen 

func (cmp *ConcurrentTxnMap) GCWhen(txn types.TxnId, scheduleTime time.Time)

func (*ConcurrentTxnMap) Get 

func (cmp *ConcurrentTxnMap) Get(key types.TxnId) (interface{}, bool)

func (*ConcurrentTxnMap) GetLazy 

func (cmp *ConcurrentTxnMap) GetLazy(key types.TxnId, constructor func() interface{}) interface{}

func (*ConcurrentTxnMap) Initialize 

func (cmp *ConcurrentTxnMap) Initialize(partitionNum int)

func (*ConcurrentTxnMap) InitializeWithGCThreads 

func (cmp *ConcurrentTxnMap) InitializeWithGCThreads(partitionNum int, chSizePerPartition int)

func (*ConcurrentTxnMap) Insert 

func (cmp *ConcurrentTxnMap) Insert(key types.TxnId, val interface{}) error

func (*ConcurrentTxnMap) InsertIfNotExists 

func (cmp *ConcurrentTxnMap) InsertIfNotExists(key types.TxnId, constructor func() interface{}) (success bool, newVal interface{})

func (*ConcurrentTxnMap) Lock 

func (cmp *ConcurrentTxnMap) Lock()

func (*ConcurrentTxnMap) MustGet 

func (cmp *ConcurrentTxnMap) MustGet(key types.TxnId) interface{}

func (*ConcurrentTxnMap) RLock 

func (cmp *ConcurrentTxnMap) RLock()

func (*ConcurrentTxnMap) RUnlock 

func (cmp *ConcurrentTxnMap) RUnlock()

func (*ConcurrentTxnMap) Set 

func (cmp *ConcurrentTxnMap) Set(key types.TxnId, val interface{})

func (*ConcurrentTxnMap) SetIf 

func (cmp *ConcurrentTxnMap) SetIf(key types.TxnId, val interface{}, pred func(prev interface{}, exist bool) bool) (success bool, newValue interface{})

func (*ConcurrentTxnMap) Size 

func (cmp *ConcurrentTxnMap) Size() (sz int)

func (*ConcurrentTxnMap) Unlock 

func (cmp *ConcurrentTxnMap) Unlock()

type Future 

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

func NewFuture 

func NewFuture() *Future

func (*Future) AddUnsafe 

func (s *Future) AddUnsafe(key string) (insertedNewKey bool, keyDone bool)

func (*Future) DoneOnceUnsafe 

func (s *Future) DoneOnceUnsafe(key string) (doneOnce bool)

func (*Future) GetAddedKeyCountUnsafe 

func (s *Future) GetAddedKeyCountUnsafe() int

func (*Future) GetKeyCountUnsafe 

func (s *Future) GetKeyCountUnsafe() int

func (*Future) IsDoneUnsafe 

func (s *Future) IsDoneUnsafe() bool

func (*Future) IsKeyDoneUnsafe 

func (s *Future) IsKeyDoneUnsafe(key string) bool

type Graph 

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

func NewGraph 

func NewGraph(graph [][]int) *Graph

func (*Graph) SearchCircle 

func (g *Graph) SearchCircle() []int

type LockManager 

type LockManager interface {
	Lock(key string)
	Unlock(key string)
	RLock(key string)
	RUnlock(key string)
}

type Stack 

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

func NewStack 

func NewStack(capacity int) *Stack

func (*Stack) Pop 

func (s *Stack) Pop()

func (*Stack) Push 

func (s *Stack) Push(i int)

func (*Stack) Top 

func (s *Stack) Top() int

type Stat 

type Stat int
const (
	Unvisited Stat = iota
	Visiting
	Done
)

type TxnLockManager 

type TxnLockManager interface {
	Lock(id types.TxnId)
	Unlock(id types.TxnId)
	RLock(id types.TxnId)
	RUnlock(id types.TxnId)
}

type Visitor 

type Visitor func(*context, int) (kontinue bool)

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.