func (x *TopApps) Mark(ApplicationId string, z time.Time) { t := z.Unix() x.Lock() defer x.Unlock() y := x.m[ApplicationId] if y != nil { z1 := heap.Remove(&x.t, y.ti).(*topAppsEntry) if z1 != y { panic("z1 != y") } z2 := heap.Remove(&x.n, y.ni).(*topAppsEntry) if z2 != y { panic("z2 != y") } } else { // New entry y = &topAppsEntry{ApplicationId: ApplicationId} x.m[ApplicationId] = y } y.Mark(t) heap.Push(&x.t, y) heap.Push(&x.n, y) }
func TestHeapRemove(t *testing.T) { q := pq.NewQueue() q.Push(&message{8}) q.Push(&message{3}) q.Push(&message{9}) q.Push(&message{1}) q.Push(&message{10}) q.Push(&message{2}) q.Push(&message{5}) q.Push(&message{6}) q.Push(&message{7}) q.Push(&message{4}) heap.Init(q) r := heap.Remove(q, 5).(pq.Queueable) fmt.Println("removed:", r) if r.Priority() != 9 { t.Fatalf("Remove() fails, incorrect member removed.", r.Priority()) } mb, _ := q.Member(0) if mb.Priority() != 1 { t.Fatalf("Remove() fails, unexpected value for min member") } }
func (tm *TimerMgr) OnTick() { nowTime := time.Now() for { if tm.tq.Len() > 0 { t := heap.Pop(tm.tq) if te, ok := t.(*TimerEntity); ok { if te.next.Before(nowTime) { if te.times > 0 { te.times-- } //Avoid async stop timer failed if te.times != 0 { te.next = te.next.Add(te.interval) heap.Push(tm.tq, te) } if !SendTimeout(te) { if v, ok := tm.tq.ref[te.h]; ok { heap.Remove(tm.tq, v) } } } else { heap.Push(tm.tq, te) return } } } else { return } } }
func (g *Graph) update(n *Node, lowCost int) { if n.lowCost > lowCost { heap.Remove(g, n.index) n.lowCost = lowCost heap.Push(g, n) } }
func (this *priorityQueue) update(node *HuffmanNode, ch string, weight float64) { heap.Remove(this, node.index) node.ch = ch node.weight = weight heap.Push(this, node) }
func (t *TaskRunner) CancelAlarm(alarm *GoQuicAlarm) { item := t.alarmList[alarm] if item.heapIdx >= 0 { heap.Remove(t.alarmHeap, item.heapIdx) } t.resetTimer() }
func (s *MemStorage) StorePosts(req *http.Request, posts []Activity) { s.mu.Lock() defer s.mu.Unlock() for _, post := range posts { if s.filter != nil && !s.filter(post) { continue } log.Printf("store: %s\n", post.Id) s.m[post.Id] = post updated := false datespec := GetDatespec(post.Published) for i, p := range s.a[datespec] { if p.Id == post.Id { s.a[datespec][i] = post updated = true break } } if !updated { s.a[datespec] = append(s.a[datespec], post) } heap.Push(&s.h, post) if s.h.Len() >= 10 { _ = heap.Remove(&s.h, s.h.Len()-1) } } }
// advanceRoot retrieves the next row for the source at the root of the heap and // updates the heap accordingly. func (s *orderedSynchronizer) advanceRoot() error { if len(s.heap) == 0 { return nil } src := &s.sources[s.heap[0]] if src.row == nil { panic("trying to advance closed source") } oldRow := src.row var err error src.row, err = src.src.NextRow() if err != nil { s.err = err return err } if src.row == nil { heap.Remove(s, 0) } else { heap.Fix(s, 0) // TODO(radu): this check may be costly, we could disable it in production if cmp, err := oldRow.Compare(&s.alloc, s.ordering, src.row); err != nil { return err } else if cmp > 0 { return util.Errorf("incorrectly ordered stream %s after %s", src.row, oldRow) } } // heap operations might set s.err (see Less) return s.err }
func TestRemove(t *testing.T) { var count int if golangcafeheap.Len() <= 0 { // Add時に0件になるので…。 heap.Push(golangcafeheap, GolangCafe{Name: "ttyokoyama", Priority: 1, Count: 13, Index: 2}) heap.Push(golangcafeheap, GolangCafe{Name: "taknb2nch", Priority: 2, Count: 13, Index: 3}) heap.Push(golangcafeheap, GolangCafe{Name: "qt_luigi", Priority: 3, Count: 13, Index: 4}) heap.Push(golangcafeheap, GolangCafe{Name: "tam_x", Priority: 4, Count: 1, Index: 1}) } else { count = golangcafeheap.Len() } heap.Remove(golangcafeheap, 2) if golangcafeheap.Len() != (count - 1) { t.Errorf("golangcafeheap.Len() = %d, %d", golangcafeheap.Len(), count) } n := golangcafeheap.Len() for i := 0; i < n; i++ { item := golangcafeheap.Pop() golangcafe := item.(*GolangCafe) t.Logf("Name: %s Priority: %d Count: %d Index: %d", golangcafe.Name, golangcafe.Priority, golangcafe.Count, golangcafe.Index) } }
func (h *ttlKeyHeap) update(n *node) { index, ok := h.keyMap[n] if ok { heap.Remove(h, index) heap.Push(h, n) } }
func (d *Driver) Dequeue(queue string, eid uid.ID) (e *storage.Envelope, err error) { now := time.Now().UnixNano() d.m.Lock() defer d.m.Unlock() msgs := d.queues.get(queue) for i, n := 0, len(*msgs); i < n; i++ { msg := (*msgs)[i] if msg.availAt > now { break } if !msg.envelope.Retry.IsValid() { event.Emit(event.EventMessageDiscarded, msg.envelope) msg.removed = true } if msg.removed { heap.Remove(msgs, i) i-- n-- continue } e = msg.envelope msg.eid = eid msg.availAt = now + int64(msg.envelope.Timeout) msg.envelope.Retry.Decr() msg.accumlating = false heap.Fix(msgs, i) d.ephemeralIndex[eid] = msg return } err = storage.ErrEmpty return }
/* For snowflake proxies to request a client from the Broker. */ func proxyHandler(w http.ResponseWriter, r *http.Request) { if isPreflight(w, r) { return } id := r.Header.Get("X-Session-ID") body, err := ioutil.ReadAll(r.Body) if nil != err { log.Println("Invalid data.") w.WriteHeader(http.StatusBadRequest) return } if string(body) != id { // Mismatched IDs! w.WriteHeader(http.StatusBadRequest) } // Maybe confirm that X-Session-ID is the same. log.Println("Received snowflake: ", id) snowflake := AddSnowflake(id) // Wait for a client to avail an offer to the snowflake, or timeout // and ask the snowflake to poll later. select { case offer := <-snowflake.offerChannel: log.Println("Passing client offer to snowflake.") w.Write(offer) case <-time.After(time.Second * ProxyTimeout): // This snowflake is no longer available to serve clients. heap.Remove(snowflakes, snowflake.index) delete(snowflakeMap, snowflake.id) w.WriteHeader(http.StatusGatewayTimeout) } }
// Remove a job from the queue. func (jq *JobQueue) Remove(job *Job) { Debug("rm", job) delete(jq.byname, job.file) delete(jq.byidx, job.id) heap.Remove(&(jq.pq), job.index) job.index = -1 }
func (this *priorityQueue) update(node *space, end int, cost int) { heap.Remove(this, node.index) node.end = end node.cost = cost heap.Push(this, node) }
func (g *Graph) update(n *Node, distance int) { if n.distance > distance { heap.Remove(g, n.index) n.distance = distance heap.Push(g, n) } }
// // 获取下一个可用的Worker // func (pq *PriorityQueue) NextWorker() *Worker { now := time.Now() for pq.Len() > 0 { result := (*pq)[0] if result.index != INVALID_INDEX && result.Expire.After(now) { // 只要活着,就留在优先级队列中,等待分配任务 // log.Println("Find Valid Worker...") result.priority -= 1 // 调整Worker的优先级 heap.Fix(pq, result.index) return result } else { if result.index != INVALID_INDEX { log.Errorf("Invalid Item index in PriorityQueue#NextWorker") } else { log.Println("Worker Expired") // 只有过期的元素才删除 heap.Remove(pq, result.index) } } } log.Println("Has Not Worker...") return nil }
func (s *sandboxData) rmEndpoint(ep *endpoint) int { ep.Lock() joinInfo := ep.joinInfo ep.Unlock() sb := s.sandbox() for _, i := range sb.Info().Interfaces() { // Only remove the interfaces owned by this endpoint from the sandbox. if ep.hasInterface(i.SrcName()) { if err := i.Remove(); err != nil { logrus.Debugf("Remove interface failed: %v", err) } } } // Remove non-interface routes. for _, r := range joinInfo.StaticRoutes { if err := sb.RemoveStaticRoute(r); err != nil { logrus.Debugf("Remove route failed: %v", err) } } // We don't check if s.endpoints is empty here because // it should never be empty during a rmEndpoint call and // if it is we will rightfully panic here s.Lock() highEpBefore := s.endpoints[0] var ( i int e *endpoint ) for i, e = range s.endpoints { if e == ep { break } } heap.Remove(&s.endpoints, i) var highEpAfter *endpoint if len(s.endpoints) > 0 { highEpAfter = s.endpoints[0] } s.Unlock() if highEpBefore != highEpAfter { s.updateGateway(highEpAfter) } s.Lock() s.refCnt-- refCnt := s.refCnt s.Unlock() if refCnt == 0 { s.sandbox().Destroy() } return refCnt }
func (sb *sandbox) clearNetworkResources(ep *endpoint) error { sb.Lock() osSbox := sb.osSbox sb.Unlock() if osSbox != nil { for _, i := range osSbox.Info().Interfaces() { // Only remove the interfaces owned by this endpoint from the sandbox. if ep.hasInterface(i.SrcName()) { if err := i.Remove(); err != nil { log.Debugf("Remove interface failed: %v", err) } } } ep.Lock() joinInfo := ep.joinInfo ep.Unlock() // Remove non-interface routes. for _, r := range joinInfo.StaticRoutes { if err := osSbox.RemoveStaticRoute(r); err != nil { log.Debugf("Remove route failed: %v", err) } } } sb.Lock() if len(sb.endpoints) == 0 { // sb.endpoints should never be empty and this is unexpected error condition // We log an error message to note this down for debugging purposes. log.Errorf("No endpoints in sandbox while trying to remove endpoint %s", ep.Name()) sb.Unlock() return nil } highEpBefore := sb.endpoints[0] var ( i int e *endpoint ) for i, e = range sb.endpoints { if e == ep { break } } heap.Remove(&sb.endpoints, i) var highEpAfter *endpoint if len(sb.endpoints) > 0 { highEpAfter = sb.endpoints[0] } delete(sb.epPriority, ep.ID()) sb.Unlock() if highEpBefore != highEpAfter { sb.updateGateway(highEpAfter) } return nil }
func (jq *JobQueue) remove(jobID snowflake.Snowflake, err error) error { for i, entry := range jq.working { if entry.ID == jobID { heap.Remove(&jq.working, i) return nil } } for i, entry := range jq.available { if entry.ID == jobID { heap.Remove(&jq.available, i) return nil } } return jobs.ErrJobNotFound }
//removeMessage removes the message from mh. //If mh is empty, message is nil, or message is not in mh, then this is a nop //and returns false. //Returns true or false indicating whether or not message was actually removed //from mh. func (mh *messageHeap) removeMessage(message *Message) bool { if mh.Len() == 0 || message == nil || message.index == notInIndex || message.mh != mh { return false } result := heap.Remove(mh, message.index).(*Message) beforeRemoval(result) return true }
func (q *writeQueue) deque() (Frame, bool) { if len(q.frames) > 0 { result := q.frames[0].frame heap.Remove(&q.frames, 0) return result, true } return nil, false }
// Job is complete; update heap func (b *Balancer) completed(w *Worker) { // One fewer in the queue. w.pending-- // Remove it from heap. heap.Remove(&b.pool, w.index) // Put it into its place on the heap. heap.Push(&b.pool, w) }
// remove removes an element from purgatory (if it's experienced an // error) or from the priority queue by index. Caller must hold mutex. func (bq *baseQueue) remove(item *replicaItem) { if _, ok := bq.mu.purgatory[item.value.RangeID]; ok { delete(bq.mu.purgatory, item.value.RangeID) } else { heap.Remove(&bq.mu.priorityQ, item.index) } delete(bq.mu.replicas, item.value.RangeID) }
func (h *hostQueue) UpdatePriority(hostName string, priority int) { index := h.hostMap[hostName] host := h.hosts[index] host.priority = priority //heap.Fix(h, index) heap.Remove(h, index) heap.Push(h, host) }
// calculates the shortest path between two GraphNodes; // if no path is found, found will be false func Path(from, to GraphNode) (path []GraphNode, distance int, found bool) { nodeMap := nodeMap{} queue := &PriorityQueue{} heap.Init(queue) fromNode := nodeMap.get(from) fromNode.open = true heap.Push(queue, (*item)(fromNode)) for { if queue.Len() == 0 { // there's no path, return found false return } // priority queue does its magic: current := (*aStarNode)(heap.Pop(queue).(*item)) current.open = false current.closed = true if current == nodeMap.get(to) { // found a path to the goal! reversePath := []GraphNode{} curr := current for curr != nil { reversePath = append(reversePath, curr.graphNode) curr = curr.parent } // reverse path to get from --> to path = make([]GraphNode, len(reversePath)) j := 0 for i := len(reversePath) - 1; i >= 0; i-- { path[j] = reversePath[i] j++ } return path, current.cost, true } for _, neighbor := range current.graphNode.GetNeighbors() { cost := current.cost + current.graphNode.ActualNeighborCost(neighbor) neighborNode := nodeMap.get(neighbor) if cost < neighborNode.cost { // this branch is for handling nodes // that have already been assessed in previous iterations // where the new cost is cheaper if neighborNode.open { heap.Remove(queue, neighborNode.index) } neighborNode.open = false neighborNode.closed = false } if !neighborNode.open && !neighborNode.closed { neighborNode.cost = cost neighborNode.open = true neighborNode.rank = cost + neighbor.EstimatedTargetCost(to) neighborNode.parent = current heap.Push(queue, (*item)(neighborNode)) } } } }
func (m *memLS) hold(n *memLSNode) { if n.held { panic("webdav: memLS inconsistent held state") } n.held = true if n.details.Duration >= 0 && n.byExpiryIndex >= 0 { heap.Remove(&m.byExpiry, n.byExpiryIndex) } }
// Set a task's key with runtime O(n). func (pq *PriorityQueue) SetKey(id int64, k float64) { var i, task = pq.h.FindId(id) if i < 0 { return } heap.Remove(pq.h, i) task.Task().(PrioritizedTask).SetKey(k) heap.Push(pq.h, task) }
func (p *periodicHeap) Remove(job *structs.Job) error { if pJob, ok := p.index[job.ID]; ok { heap.Remove(&p.heap, pJob.index) delete(p.index, job.ID) return nil } return fmt.Errorf("heap doesn't contain job %v", job.ID) }
// Remove will remove an identifier from the secondary index and deletes the // corresponding node from the heap. func (h *vaultClientHeap) Remove(id string) error { if entry, ok := h.heapMap[id]; ok { heap.Remove(&h.heap, entry.index) delete(h.heapMap, id) return nil } return fmt.Errorf("heap doesn't contain entry for %v", id) }
func (stc *stopTimerCommand) Done(o *basic.Object) error { defer o.ProcessSeqnum() if v, ok := TimerModule.tq.ref[stc.h]; ok { heap.Remove(TimerModule.tq, v) } return nil }