func (s marketStore) record(m emdn.Transaction) { k := m.Item // Demand tree, ok := s.itemDemand[k] if !ok { tree = llrb.New() s.itemDemand[k] = tree } tree.ReplaceOrInsert(demtrans(m)) for tree.Len() > maxItems { tree.DeleteMin() } stationPriceUpdate(s.stationDemand, m.Station, k, m.SellPrice) // Supply tree, ok = s.itemSupply[k] if !ok { tree = llrb.New() s.itemSupply[k] = tree } if m.BuyPrice == 0 { m.BuyPrice = math.MaxInt64 } tree.ReplaceOrInsert(suptrans(m)) for tree.Len() > maxItems { tree.DeleteMax() } stationPriceUpdate(s.stationSupply, m.Station, k, m.BuyPrice) }
func InitCache() *MyError.MyError { once.Do(func() { DomainRRCache = &DomainRRTree{ LLRB: llrb.New(), RWMutex: &sync.RWMutex{}, } DomainSOACache = &DomainSOATree{ LLRB: llrb.New(), RWMutex: &sync.RWMutex{}, } }) return nil }
func newShardedCache(n int, de time.Duration) *shardedCache { max := big.NewInt(0).SetUint64(uint64(math.MaxUint32)) rnd, err := rand.Int(rand.Reader, max) var seed uint32 if err != nil { os.Stderr.Write([]byte("WARNING: go-cache's newShardedCache failed to read from the system CSPRNG (/dev/urandom or equivalent.) Your system's security may be compromised. Continuing with an insecure seed.\n")) seed = insecurerand.Uint32() } else { seed = uint32(rnd.Uint64()) } sc := &shardedCache{ seed: seed, m: uint32(n), cs: make([]*cache, n), } for i := 0; i < n; i++ { c := &cache{ defaultExpiration: de, items: map[string]Item{}, sortedItems: llrb.New(), } sc.cs[i] = c } return sc }
// NewEnvironment constructs an Environment with the given parent to provide a // fallback for finding variables. The parent may be nil. func NewEnvironment(parent Environment) Environment { e := new(environment) e.writable = true e.vars = llrb.New() e.parent = parent return e }
// Returns a new task queue. // The user could submit new task through channel ch. func NewTaskQueue(ch <-chan Task) *TaskQueue { ret := new(TaskQueue) ret.tree = llrb.New(taskBefore) ret.ch = ch ret.waitTime = maxTime return ret }
// Add a term that can be searched on (append or create to an existing term) func (rfs *RootFileSystem) SearchAddTerm(area string, term string, path string, version string) error { searchIndex := rfs.ChangeCache.GetSearchIndex() treeNode, ok := searchIndex.Terms[area] var searchTree *SearchTree = &SearchTree{} var err error if !ok { // Create a node for this tree treeNode = rfs.BlockHandler.GetFreeBlockNode(SEARCHTREE) searchIndex.Terms[area] = treeNode searchTree.Tree = llrb.New() searchTree.Node = treeNode // Need to save the searchTree back rfs.ChangeCache.SaveSearchIndex(searchIndex) } else { searchTree, err = rfs.ChangeCache.GetSearchTree(treeNode) if err != nil { return err } } // Now we have a search tree, add the term var searchItem = SearchEntry{term, nil} existingValue := searchTree.Tree.Get(searchItem) var pointValue SearchEntry if existingValue != nil { pointValue = existingValue.(SearchEntry) } else { pointValue = SearchEntry{term, make([]Entry, 0)} } entry := Entry{path, version} pointValue.Matches = append(pointValue.Matches, entry) searchTree.Tree.ReplaceOrInsert(pointValue) // And save this searchTree back rfs.ChangeCache.SaveSearchTree(searchTree) return nil }
// rebuildIndex does the work of regenerating the index // with the given keys. func rebuild(less llrb.LessFunc, keys <-chan string) *llrb.Tree { tree := llrb.New(less) for key := range keys { tree.ReplaceOrInsert(key) } return tree }
func (tdi *TripleDirectionIndex) GetOrCreate(d graph.Direction, id int64) *llrb.LLRB { directionIndex := tdi.GetForDir(d) if _, ok := directionIndex[id]; !ok { directionIndex[id] = llrb.New() } return directionIndex[id] }
func (this *Trellis) insert(t int, s *Bigram, sa *Bigram, kb int, p float64) { i, ok := this.trl[t].Get(s) if !ok { TRACE(4, " Inserting. Is a new element, init list.", MOD_HMM) m := llrb.New() m.InsertNoReplace(NewElement(sa, kb, p)) this.trl[t].Insert(s, m) } else { TRACE(4, " Inserting. Not a new element, add. List size="+strconv.Itoa(i.(*llrb.LLRB).Len())+"/"+strconv.Itoa(this.kbest), MOD_HMM) j := i.(*llrb.LLRB).Min() if i.(*llrb.LLRB).Len() == this.kbest && p < j.(*Element).prob { TRACE(4, " Not worth inserting", MOD_HMM) return } i.(*llrb.LLRB).InsertNoReplace(NewElement(sa, kb, p)) if i.(*llrb.LLRB).Len() > this.kbest { i.(*llrb.LLRB).Delete(i.(*llrb.LLRB).Min()) TRACE(4, " list too long. Last erased", MOD_HMM) } } i, ok = this.trl[t].Get(s) if ok && i.(*llrb.LLRB).Len() > 0 { TRACE(4, "MAX:"+strconv.FormatFloat(i.(*llrb.LLRB).Max().(*Element).prob, 'f', -1, 64)+" MIN:"+strconv.FormatFloat(i.(*llrb.LLRB).Min().(*Element).prob, 'f', -1, 64), MOD_HMM) } }
// NewRegionCache creates a RegionCache. func NewRegionCache(pdClient pd.Client) *RegionCache { return &RegionCache{ pdClient: pdClient, regions: make(map[RegionVerID]*Region), sorted: llrb.New(), } }
// rebuildIndex does the work of regenerating the index // with the given keys. func rebuild(less LessFunction, keys <-chan string) *llrb.LLRB { tree := llrb.New() for key := range keys { tree.ReplaceOrInsert(llrbString{s: key, l: less}) } return tree }
func NewQTask() *QTask { return &QTask{ tree: llrb.New(), qchan: make(chan Task, 30), waitTime: maxTime, mTask: make(map[string]Task), } }
// NewRegionCache creates a RegionCache. func NewRegionCache(pdClient pd.Client) *RegionCache { c := &RegionCache{ pdClient: pdClient, } c.mu.regions = make(map[RegionVerID]*Region) c.mu.sorted = llrb.New() return c }
func BenchmarkSortedInsert_InsertNoReplace(b *testing.B) { for i := 0; i < b.N; i++ { tree := llrb.New() for i := 0; i < len(fixture.SortedTestData); i++ { tree.InsertNoReplace(llrbItem(fixture.SortedTestData[i])) } } }
func BenchmarkInsert(b *testing.B) { for i := 0; i < b.N; i++ { tree := llrb.New() for i := 0; i < len(fixture.TestData); i++ { tree.ReplaceOrInsert(llrbItem(fixture.TestData[i])) } } }
func newTreeBasedConnMap(maxNrConn, maxNrUsers, maxNrConnsPerUser int) connMap { ret := new(treeBasedConnMap) ret.tree = llrb.New() ret.maxNrConn = maxNrConn ret.maxNrUsers = maxNrUsers ret.maxNrConnsPerUser = maxNrConnsPerUser return ret }
func main() { tree := llrb.New() tree.ReplaceOrInsert(llrb.Int(1)) tree.ReplaceOrInsert(llrb.Int(2)) tree.ReplaceOrInsert(llrb.Int(3)) tree.ReplaceOrInsert(llrb.Int(4)) tree.DeleteMin() tree.Delete(llrb.Int(4)) tree.AscendGreaterOrEqual(tree.Min(), Print) }
func (this *Set) Insert(item interface{}) { bin := this.bins[this.hasher(item)] if bin == nil { bin = llrb.New(llrb.LessFunc(this.lesser)) this.bins[this.hasher(item)] = bin } if bin.ReplaceOrInsert(item) == nil { this.count++ } }
// NewRestrictedEnvironment constructs an Environment with the given set of // mappings. The environment cannot be modified. func NewRestrictedEnvironment(parent Environment, mapping map[Symbol]interface{}) Environment { e := new(environment) e.writable = false e.vars = llrb.New() for sym, val := range mapping { item := newEnvItem(sym, val) e.vars.ReplaceOrInsert(item) } e.parent = parent return e }
// There's no way back! func (self *treeBasedConnMap) CloseAll() { self.lock.Lock() var nilcs *connSet self.tree.AscendGreaterOrEqual(nilcs, func(i llrb.Item) bool { if cs, ok := i.(*connSet); ok { cs.CloseAll() } return true }) self.tree = llrb.New() }
// newMemoryTable constructs a MemoryTable instance. func newMemoryTable(tableID int64, tableName string, cols []*table.Column, alloc autoid.Allocator) *MemoryTable { name := model.NewCIStr(tableName) t := &MemoryTable{ ID: tableID, Name: name, alloc: alloc, Columns: cols, recordPrefix: tablecodec.GenTableRecordPrefix(tableID), tree: llrb.New(), } return t }
func NewManager(helper MHelper) *IManager { m := &IManager{} m.sortedItems = llrb.New() m.itemsByTid = make(map[string]*Item) m.itemsById = make(map[int64]*Item) m.itemsByTitle = make(map[string]*Item) m.mutex = &sync.RWMutex{} m.max_items = 120 m.max_show = 100 m.max_on_top = 5 m.max_comments = 20 m.h = helper return m }
func newCache(de time.Duration, m map[string]Item) *cache { if de == 0 { de = -1 } c := &cache{ defaultExpiration: de, items: m, } c.sortedItems = llrb.New() for k, item := range m { c.sortedItems.InsertNoReplace(Node{Key: k, Expiration: item.Expiration}) } return c }
// rebuildIndex does the work of regenerating the index // according to the comparison function in the store. func (s *OrderedStore) rebuildIndex() { s.index = llrb.New(s.lf) keyChan := s.Keys() count, began := 0, time.Now() for { key, ok := <-keyChan if !ok { break // closed } s.index.ReplaceOrInsert(key) count = count + 1 } if count > 0 { log.Printf("index rebuilt (%d keys) in %s", count, time.Since(began)) } }
func BenchmarkIterate(b *testing.B) { tree := llrb.New() for i := 0; i < len(fixture.TestData); i++ { tree.ReplaceOrInsert(llrbItem(fixture.TestData[i])) } b.ResetTimer() for i := 0; i < b.N; i++ { min := tree.Min() tree.AscendGreaterOrEqual(min, func(i llrb.Item) bool { _ = i.(llrbItem).Key _ = i.(llrbItem).Value return true }) } }
func main() { tree := llrb.New(lessInt) tree.ReplaceOrInsert(1) tree.ReplaceOrInsert(2) tree.ReplaceOrInsert(3) tree.ReplaceOrInsert(4) tree.DeleteMin() tree.Delete(4) c := tree.IterAscend() for { u := <-c if u == nil { break } fmt.Printf("%d\n", int(u.(int))) } }
func TestQueryGets(t *testing.T) { for i, test := range veraxDevices { var err error var vresults *llrb.Tree if vresults, err = ReadVeraxResults(test.path); err != nil { t.Errorf("#%d, %s: ReadVeraxResults error: %s", i, test.path, err) } var counter int var uri, oids string gresults := llrb.New(LessOID) ch := vresults.IterAscend() for { r := <-ch if r == nil { break } counter += 1 if counter <= 3 { // TODO random number of oids, not hardcoded n oid := r.(QueryResult) oids += "," + oid.Oid } else { uri = `snmp://[email protected]:` + strconv.Itoa(test.port) + "//(" + oids[1:] + ")" counter = 0 // reset oids = "" // reset params := &QueryParams{ Uri: uri, Version: GNET_SNMP_V2C, Timeout: 200, Retries: 5, Tree: gresults, } if _, err := Query(params); err != nil { t.Errorf("Query error: %s. Uri: %s", err, uri) } } } CompareVerax(t, gresults, vresults) } }
func main() { tree := llrb.New() tree.ReplaceOrInsert(llrb.Int(1)) tree.InsertNoReplace(llrb.Int(1)) tree.ReplaceOrInsert(llrb.Int(2)) tree.ReplaceOrInsert(llrb.Int(3)) tree.InsertNoReplace(llrb.Int(3)) tree.InsertNoReplace(llrb.Int(2)) tree.ReplaceOrInsert(llrb.Int(4)) tree.DeleteMin() tree.Delete(llrb.Int(4)) tree.AscendGreaterOrEqual(tree.Min(), func(item llrb.Item) bool { i, ok := item.(llrb.Int) if !ok { return false } fmt.Println(int(i)) return true }) }
func main() { flag.Parse() vals := rand.Perm(*size) var t, v interface{} v = vals var stats runtime.MemStats for i := 0; i < 10; i++ { runtime.GC() } fmt.Println("-------- BEFORE ----------") runtime.ReadMemStats(&stats) fmt.Printf("%+v\n", stats) start := time.Now() if *gollrb { tr := llrb.New() for _, v := range vals { tr.ReplaceOrInsert(llrb.Int(v)) } t = tr // keep it around } else { tr := btree.New(*degree) for _, v := range vals { tr.ReplaceOrInsert(btree.Int(v)) } t = tr // keep it around } fmt.Printf("%v inserts in %v\n", *size, time.Since(start)) fmt.Println("-------- AFTER ----------") runtime.ReadMemStats(&stats) fmt.Printf("%+v\n", stats) for i := 0; i < 10; i++ { runtime.GC() } fmt.Println("-------- AFTER GC ----------") runtime.ReadMemStats(&stats) fmt.Printf("%+v\n", stats) if t == v { fmt.Println("to make sure vals and tree aren't GC'd") } }
func IoRoutine(request <-chan *IoArgs, responce chan<- interface{}) { log.Println("start IoRoutine") sortPieces := llrb.New(ioLessFun) for arg := range request { //todo: sort by offset and batch process io cnt := len(request) //batch get request, then sort by offset sortPieces.InsertNoReplace(arg) for i := 0; i < cnt; i++ { a := <-request sortPieces.InsertNoReplace(a) if a.ioMode == MODE_WRITE { break } } //batch process if cnt > cap(request)/2 { log.Println("io is busy, batch io count", cnt) } for { min := sortPieces.DeleteMin() if min == nil { break } //log.Println("io offset", min.(*IoArgs).offset) HandleIo(min.(*IoArgs)) responce <- min.(*IoArgs).context } } log.Println("exit IoRoutine") }