func NewWorker(fetchers uint64, tc <-chan Archive, rc chan<- Status) *Worker { w := new(Worker) w.ID = atomic.AddUint32(&workerID, 1) w.Targets, w.Report = tc, rc w.Fetchers = make([]*Fetcher, fetchers) w.FRequest = make(chan FetchRequest, 30) w.FResult = make(chan FetchResult, 30*fetchers) for i := range w.Fetchers { f := new(Fetcher) f.ID = atomic.AddUint32(&fetchID, 1) f.Request = w.FRequest f.Result = w.FResult w.Fetchers[i] = f go w.Fetchers[i].fetch() } go w.Watch() go func() { for result := range w.FResult { if !result.Ok { log.Printf("Fetch error: %s", result.Description) } } }() return w }
// ServeConn serves HTTP requests from the given connection. // // ServeConn returns nil if all requests from the c are successfully served. // It returns non-nil error otherwise. // // Connection c must immediately propagate all the data passed to Write() // to the client. Otherwise requests' processing may hang. // // ServeConn closes c before returning. func (s *Server) ServeConn(c net.Conn) error { if s.MaxConnsPerIP > 0 { pic := wrapPerIPConn(s, c) if pic == nil { c.Close() return ErrPerIPConnLimit } c = pic } n := atomic.AddUint32(&s.concurrency, 1) if n > uint32(s.getConcurrency()) { atomic.AddUint32(&s.concurrency, ^uint32(0)) c.Close() return ErrConcurrencyLimit } err := s.serveConn(c) atomic.AddUint32(&s.concurrency, ^uint32(0)) if err != errHijacked { err1 := c.Close() if err == nil { err = err1 } } else { err = nil } return err }
func (f *Fixer) updateCounters(chains [][]*x509.Certificate, ferrs []*FixError) { atomic.AddUint32(&f.validChainsProduced, uint32(len(chains))) var verifyFailed bool var fixFailed bool for _, ferr := range ferrs { switch ferr.Type { case VerifyFailed: verifyFailed = true case FixFailed: fixFailed = true } } // No errors --> reconstructed // VerifyFailed --> notReconstructed // VerifyFailed but no FixFailed --> fixed // VerifyFailed and FixFailed --> notFixed if verifyFailed { atomic.AddUint32(&f.notReconstructed, 1) // FixFailed error will only be present if a VerifyFailed error is, as // fixChain() is only called if constructChain() fails. if fixFailed { atomic.AddUint32(&f.notFixed, 1) return } atomic.AddUint32(&f.fixed, 1) return } atomic.AddUint32(&f.reconstructed, 1) }
// GetSeqNum returns a sequence number that is bigger than the previously sequence number by 1. func (m32 *MonoIncSeqNumGenerator32) GetSeqNum() uint32 { seq := atomic.AddUint32((*uint32)(m32), 1) for seq == 0 { seq = atomic.AddUint32((*uint32)(m32), 1) } return seq }
func (rcv *TCP) handleConnection(conn net.Conn) { atomic.AddInt32(&rcv.active, 1) defer atomic.AddInt32(&rcv.active, -1) defer conn.Close() reader := bufio.NewReader(conn) for { conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) line, err := reader.ReadBytes('\n') if err != nil { if err == io.EOF { if len(line) > 0 { logrus.Warningf("[tcp] Unfinished line: %#v", line) } } else { atomic.AddUint32(&rcv.errors, 1) logrus.Error(err) } break } if len(line) > 0 { // skip empty lines if msg, err := points.ParseText(string(line)); err != nil { atomic.AddUint32(&rcv.errors, 1) logrus.Info(err) } else { atomic.AddUint32(&rcv.metricsReceived, 1) rcv.out <- msg } } } }
func doTarget(target string, pkg []string) { //println("DEBUG ", target, pkg) if onlyJS && target != "js" { results <- resChan{string("Target " + target + " ignored"), nil} return } var lastErr error exe := "bash" _, err := exec.LookPath(exe) if err != nil { switch exe { default: panic(" error - executable not found: " + exe) } } out := []byte{} if target == "all" { prms := append([]string{"./testtgoall.sh"}, pkg...) out, lastErr = exec.Command(exe, prms...).CombinedOutput() } else { out, lastErr = exec.Command(exe, "./testtgo.sh", target, pkg[0]).CombinedOutput() } layout := "%-25s %s" for n := range pkg { if lastErr != nil { //out = append(out, []byte(lastErr.Error())...) scores[fmt.Sprintf(layout, pkg[n], target)] = "Fail" atomic.AddUint32(&failures, 1) } else { scores[fmt.Sprintf(layout, pkg[n], target)] = "Pass" atomic.AddUint32(&passes, 1) } } results <- resChan{string(out), lastErr} }
func (mux *SimpleMux) getNextSessID() uint64 { baseID := atomic.AddUint32(&(mux.nextSessID), 1) for baseID == 0 { baseID = atomic.AddUint32(&(mux.nextSessID), 1) } return ((uint64(time.Now().Unix()) << 32) | uint64(baseID)) }
func TestCache(t *testing.T) { iris.ResetDefault() expectedBodyStr := "Imagine it as a big message to achieve x20 response performance!" var textCounter, htmlCounter uint32 iris.Get("/text", iris.Cache(func(ctx *iris.Context) { atomic.AddUint32(&textCounter, 1) ctx.Text(iris.StatusOK, expectedBodyStr) }, cacheDuration)) iris.Get("/html", iris.Cache(func(ctx *iris.Context) { atomic.AddUint32(&htmlCounter, 1) ctx.HTML(iris.StatusOK, expectedBodyStr) }, cacheDuration)) e := httptest.New(iris.Default, t) // test cache on text/plain if err := runCacheTest(e, "/text", &textCounter, expectedBodyStr, "text/plain"); err != nil { t.Fatal(err) } // text cache on text/html if err := runCacheTest(e, "/html", &htmlCounter, expectedBodyStr, "text/html"); err != nil { t.Fatal(err) } }
func (pool *streampool) pickupstreams(udp bool) []*upstream { pool.waitforalive() // pick udp and tcp equally pool.RLock() defer pool.RUnlock() // pick one of each switch { case udp && pool.udplen > 0: rn := int(atomic.AddUint32(&pool.rn, 1) - 1) return []*upstream{pool.udpool[rn%pool.udplen]} case pool.tcplen > 0 && pool.udplen > 0: // pick one of each rn := int(atomic.AddUint32(&pool.rn, 1) - 1) return []*upstream{ pool.udpool[rn%pool.udplen], pool.tcpool[rn%pool.tcplen], } case pool.tcplen == 0 || pool.udplen == 0: // pick 2 alived rn := int(atomic.AddUint32(&pool.rn, 2) - 2) return []*upstream{ pool.alived[rn%pool.alvlen], pool.alived[(rn+1)%pool.alvlen], } } logrus.Warnln("no upstream avalible for pick") return nil }
func loadStats(f io.Reader) { s := bufio.NewScanner(f) wg := new(sync.WaitGroup) tmp := make([][]byte, sNum) unkC = 0 srch := func(b [][]byte) { for _, v := range b { t := root.search(convertIP(v)) if t == nil { atomic.AddUint32(&unkC, 1) } else { atomic.AddUint32(&t.count, 1) } } wg.Done() } i := 0 for s.Scan() { tmp[i] = make([]byte, len(s.Bytes())) copy(tmp[i], s.Bytes()) i++ if i == sNum { wg.Add(1) go srch(tmp) i, tmp = 0, make([][]byte, sNum) } } if i > 0 { wg.Add(1) go srch(tmp[:i]) } wg.Wait() }
// save stat func (p *Whisper) doCheckpoint() { updateOperations := atomic.LoadUint32(&p.updateOperations) commitedPoints := atomic.LoadUint32(&p.commitedPoints) atomic.AddUint32(&p.updateOperations, -updateOperations) atomic.AddUint32(&p.commitedPoints, -commitedPoints) created := atomic.LoadUint32(&p.created) atomic.AddUint32(&p.created, -created) logrus.WithFields(logrus.Fields{ "updateOperations": int(updateOperations), "commitedPoints": int(commitedPoints), "created": int(created), }).Info("[persister] doCheckpoint()") p.Stat("updateOperations", float64(updateOperations)) p.Stat("commitedPoints", float64(commitedPoints)) if updateOperations > 0 { p.Stat("pointsPerUpdate", float64(commitedPoints)/float64(updateOperations)) } else { p.Stat("pointsPerUpdate", 0.0) } p.Stat("created", float64(created)) }
func TestSemaphoreMultipleGoroutines(t *testing.T) { var done uint32 sem := NewSemaphore(0) sem2 := NewSemaphore(0) go func() { sem.Wait() atomic.AddUint32(&done, 1) sem2.Post() }() go func() { time.Sleep(10 * time.Nanosecond) atomic.AddUint32(&done, 1) sem.Post() }() go func() { time.Sleep(20 * time.Nanosecond) atomic.AddUint32(&done, 1) sem.Post() }() sem.Wait() go func() { time.Sleep(10 * time.Nanosecond) atomic.AddUint32(&done, 1) sem.Post() }() sem.Wait() sem2.Wait() doneVal := atomic.LoadUint32(&done) if doneVal != 4 { t.Fatalf("sem.Wait did not wait for sem.Posts") } }
func (rcv *UDP) statWorker(exit chan bool) { ticker := time.NewTicker(rcv.metricInterval) defer ticker.Stop() for { select { case <-ticker.C: metricsReceived := atomic.LoadUint32(&rcv.metricsReceived) atomic.AddUint32(&rcv.metricsReceived, -metricsReceived) rcv.Stat("udp.metricsReceived", float64(metricsReceived)) incompleteReceived := atomic.LoadUint32(&rcv.incompleteReceived) atomic.AddUint32(&rcv.incompleteReceived, -incompleteReceived) rcv.Stat("udp.incompleteReceived", float64(incompleteReceived)) errors := atomic.LoadUint32(&rcv.errors) atomic.AddUint32(&rcv.errors, -errors) rcv.Stat("udp.errors", float64(errors)) logrus.WithFields(logrus.Fields{ "metricsReceived": int(metricsReceived), "incompleteReceived": int(incompleteReceived), "errors": int(errors), }).Info("[udp] doCheckpoint()") case <-exit: rcv.conn.Close() return } } }
// Get returns existed connection from the pool or creates a new one. func (p *ConnPool) Get() (*Conn, error) { if p.Closed() { return nil, ErrClosed } atomic.AddUint32(&p.stats.Requests, 1) // Fetch first non-idle connection, if available. if cn := p.First(); cn != nil { atomic.AddUint32(&p.stats.Hits, 1) return cn, nil } // Try to create a new one. if p.conns.Reserve() { cn, err := p.NewConn() if err != nil { p.conns.CancelReservation() return nil, err } p.conns.Add(cn) return cn, nil } // Otherwise, wait for the available connection. atomic.AddUint32(&p.stats.Waits, 1) if cn := p.wait(); cn != nil { return cn, nil } atomic.AddUint32(&p.stats.Timeouts, 1) return nil, ErrPoolTimeout }
func (u *urlCache) getURL(url string) ([]byte, error) { r, ok := u.cache.get(url) if ok { atomic.AddUint32(&u.hit, 1) return r, nil } c, err := u.client.Get(url) if err != nil { atomic.AddUint32(&u.errors, 1) return nil, err } defer c.Body.Close() // TODO(katjoyce): Add caching of permanent errors. if c.StatusCode != 200 { atomic.AddUint32(&u.badStatus, 1) return nil, fmt.Errorf("can't deal with status %d", c.StatusCode) } r, err = ioutil.ReadAll(c.Body) if err != nil { atomic.AddUint32(&u.readFail, 1) return nil, err } atomic.AddUint32(&u.miss, 1) u.cache.set(url, r) return r, nil }
func (pc *ProxyCounter) GetList(args *storageproto.GetArgs, reply *storageproto.GetListReply) error { if pc.override { reply.Status = pc.overrideStatus return pc.overrideErr } byteCount := len(args.Key) if args.WantLease { atomic.AddUint32(&pc.leaseRequestCount, 1) } if pc.disableLease { args.WantLease = false } err := pc.srv.Call("StorageRPC.GetList", args, reply) for _, s := range reply.Value { byteCount += len(s) } if reply.Lease.Granted { if pc.overrideLeaseSeconds > 0 { reply.Lease.ValidSeconds = pc.overrideLeaseSeconds } atomic.AddUint32(&pc.leaseGrantedCount, 1) } atomic.AddUint32(&pc.rpcCount, 1) atomic.AddUint32(&pc.byteCount, uint32(byteCount)) return err }
// QueueChain adds the given chain to the queue to be posted to the log. func (l *Logger) QueueChain(chain []*x509.Certificate) { if chain == nil { return } atomic.AddUint32(&l.queued, 1) // Has a chain for the cert this chain if for already been successfully //posted to the log by this Logger? h := hash(chain[0]) // Chains are cert -> root if l.postCertCache.get(h) { atomic.AddUint32(&l.reposted, 1) return // Don't post chain for a cert that has already had a chain posted. } // If we assume all chains for the same cert are equally // likely to succeed, then we could mark the cert as posted // here. However, bugs might cause a log to refuse one chain // and accept another, so try each unique chain. // Has this Logger already tried to post this chain? h = hashChain(chain) if l.postChainCache.get(h) { atomic.AddUint32(&l.chainReposted, 1) return } l.postChainCache.set(h, true) p := &toPost{chain: chain, retries: 5} l.postToLog(p) }
// ServeConn serves HTTP requests from the given connection. // // ServeConn returns nil if all requests from the c are successfully served. // It returns non-nil error otherwise. // // Connection c must immediately propagate all the data passed to Write() // to the client. Otherwise requests' processing may hang. // // ServeConn closes c before returning. func (s *Server) ServeConn(c net.Conn) error { if s.MaxConnsPerIP > 0 { pic := wrapPerIPConn(s, c) if pic == nil { return ErrPerIPConnLimit } c = pic } n := atomic.AddUint32(&s.concurrency, 1) if n > uint32(s.getConcurrency()) { atomic.AddUint32(&s.concurrency, ^uint32(0)) s.writeFastError(c, StatusServiceUnavailable, "The connection cannot be served because Server.Concurrency limit exceeded") c.Close() return ErrConcurrencyLimit } err := s.serveConn(c) atomic.AddUint32(&s.concurrency, ^uint32(0)) if err != errHijacked { err1 := c.Close() if err == nil { err = err1 } } else { err = nil } return err }
func TestCancelAndClose(t *testing.T) { cf := &testCFetcher{} ccf := CNew(cf) var canceled uint32 done1 := make(chan struct{}) cancel1 := make(chan struct{}) go func() { _, err := ccf.CFetch(cancel1, "key") if err == nil { t.Fatalf("Gets nil, wants errors") } atomic.AddUint32(&canceled, 1) close(done1) }() done2 := make(chan struct{}) go func() { _, err := ccf.CFetch(nil, "key") if err == nil { t.Fatalf("Gets nil, wants errors") } atomic.AddUint32(&canceled, 1) close(done2) }() done3 := make(chan struct{}) go func() { _, err := ccf.CFetch(nil, "KEY") if err == nil { t.Fatalf("Gets nil, wants errors") } atomic.AddUint32(&canceled, 1) close(done3) }() close(cancel1) <-done1 time.Sleep(10 * time.Millisecond) // Check if done2 isn't canceled if canceled != 1 { t.Fatalf("Gets %d canceled, wants 1", canceled) } if cf.cnt != 0 { t.Fatalf("Gets %d canceled internal calls, wants 0", canceled) } ccf.Close() <-done2 <-done3 cf.wg.Wait() time.Sleep(10 * time.Millisecond) // Wait for all cancel calls if canceled != 3 { t.Fatalf("Gets %d canceled, wants 3", canceled) } if cf.cnt != 2 { t.Fatalf(`Gets %d canceled internal calls, wants 2 ("key" and "KEY")`, cf.cnt) } }
func (arch *Archive) ScanCheckpointsFast(opts *CommandOptions) error { if opts.Concurrency == 0 { return errors.New("Zero concurrency") } var errs uint32 tick := makeTicker(func(_ uint) { arch.ReportCheckpointStats() }) var wg sync.WaitGroup wg.Add(opts.Concurrency) req := make(chan scanCheckpointFastReq) cats := Categories() go func() { for _, cat := range cats { for _, pth := range RangePaths(opts.Range) { req <- scanCheckpointFastReq{category: cat, pathprefix: pth} } } close(req) }() for i := 0; i < opts.Concurrency; i++ { go func() { for { r, ok := <-req if !ok { break } ch, es := arch.ListCategoryCheckpoints(r.category, r.pathprefix) for n := range ch { tick <- true arch.NoteCheckpointFile(r.category, n, true) if opts.Verify { atomic.AddUint32(&errs, noteError(arch.VerifyCategoryCheckpoint(r.category, n))) } } atomic.AddUint32(&errs, drainErrors(es)) } wg.Done() }() } wg.Wait() close(tick) log.Printf("Checkpoint files scanned with %d errors", errs) arch.ReportCheckpointStats() if errs != 0 { return fmt.Errorf("%d errors scanning checkpoints", errs) } return nil }
func (l *Logger) postServer() { for { c := <-l.toPost atomic.AddUint32(&l.active, 1) l.postChain(c) atomic.AddUint32(&l.active, ^uint32(0)) l.wg.Done() } }
// Listen bind port. Receive messages and send to out channel func (rcv *TCP) Listen(addr *net.TCPAddr) error { var err error rcv.listener, err = net.ListenTCP("tcp", addr) if err != nil { return err } go func() { ticker := time.NewTicker(time.Minute) defer ticker.Stop() for { select { case <-ticker.C: cnt := atomic.LoadUint32(&rcv.metricsReceived) atomic.AddUint32(&rcv.metricsReceived, -cnt) rcv.Stat("metricsReceived", float64(cnt)) rcv.Stat("active", float64(atomic.LoadInt32(&rcv.active))) errors := atomic.LoadUint32(&rcv.errors) atomic.AddUint32(&rcv.errors, -errors) rcv.Stat("errors", float64(errors)) case <-rcv.exit: rcv.listener.Close() return } } }() handler := rcv.handleConnection if rcv.isPickle { handler = rcv.handlePickle } go func() { defer rcv.listener.Close() for { conn, err := rcv.listener.Accept() if err != nil { if strings.Contains(err.Error(), "use of closed network connection") { break } logrus.Warningf("[tcp] Failed to accept connection: %s", err) continue } go handler(conn) } }() return nil }
func store(p *Whisper, values *points.Points) { path := filepath.Join(p.rootPath, strings.Replace(values.Metric, ".", "/", -1)+".wsp") w, err := whisper.Open(path) if err != nil { schema := p.schemas.match(values.Metric) if schema == nil { logrus.Errorf("[persister] No storage schema defined for %s", values.Metric) return } aggr := p.aggregation.match(values.Metric) if aggr == nil { logrus.Errorf("[persister] No storage aggregation defined for %s", values.Metric) return } logrus.WithFields(logrus.Fields{ "retention": schema.retentionStr, "schema": schema.name, "aggregation": aggr.name, "xFilesFactor": aggr.xFilesFactor, "method": aggr.aggregationMethodStr, }).Debugf("[persister] Creating %s", path) if err = os.MkdirAll(filepath.Dir(path), os.ModeDir|os.ModePerm); err != nil { logrus.Error(err) return } w, err = whisper.Create(path, schema.retentions, aggr.aggregationMethod, float32(aggr.xFilesFactor)) if err != nil { logrus.Errorf("[persister] Failed to create new whisper file %s: %s", path, err.Error()) return } atomic.AddUint32(&p.created, 1) } points := make([]*whisper.TimeSeriesPoint, len(values.Data)) for i, r := range values.Data { points[i] = &whisper.TimeSeriesPoint{Time: int(r.Timestamp), Value: r.Value} } atomic.AddUint32(&p.commitedPoints, uint32(len(values.Data))) atomic.AddUint32(&p.updateOperations, 1) defer w.Close() defer func() { if r := recover(); r != nil { logrus.Errorf("[persister] UpdateMany %s recovered: %s", path, r) } }() w.UpdateMany(points) }
func TestLRUCache_ConcurrentSetGet(t *testing.T) { runtime.GOMAXPROCS(runtime.NumCPU()) seed := time.Now().UnixNano() t.Logf("seed=%d", seed) const ( N = 2000000 M = 4000 C = 3 ) var set, get uint32 wg := &sync.WaitGroup{} c := NewLRUCache(M / 4) for ni := uint64(0); ni < C; ni++ { r0 := rand.New(rand.NewSource(seed + int64(ni))) r1 := rand.New(rand.NewSource(seed + int64(ni) + 1)) ns := c.GetNamespace(ni) wg.Add(2) go func(ns Namespace, r *rand.Rand) { for i := 0; i < N; i++ { x := uint64(r.Int63n(M)) o := ns.Get(x, func() (int, interface{}) { atomic.AddUint32(&set, 1) return 1, x }) if v := o.Value().(uint64); v != x { t.Errorf("#%d invalid value, got=%d", x, v) } o.Release() } wg.Done() }(ns, r0) go func(ns Namespace, r *rand.Rand) { for i := 0; i < N; i++ { x := uint64(r.Int63n(M)) o := ns.Get(x, nil) if o != nil { atomic.AddUint32(&get, 1) if v := o.Value().(uint64); v != x { t.Errorf("#%d invalid value, got=%d", x, v) } o.Release() } } wg.Done() }(ns, r1) } wg.Wait() t.Logf("set=%d get=%d", set, get) }
// QueueChain queues the given chain to be fixed wrt the roots of the logger // contained in fl, and then logged to the Certificate Transparency log // represented by the logger. Note: chain is expected to be in the order of // cert --> root. func (fl *FixAndLog) QueueChain(chain []*x509.Certificate) { if chain != nil { if fl.logger.IsPosted(chain[0]) { atomic.AddUint32(&fl.alreadyPosted, 1) return } fl.fixer.QueueChain(chain[0], chain, fl.logger.RootCerts()) atomic.AddUint32(&fl.chainsSent, 1) } }
func NewUUID(version byte) (uuid UUID, err error) { switch version { case UUIDv1: seq := atomic.AddUint32(&monotonic_v1, 1) now := uint64(time.Now().UnixNano()/100 + 12219292800000) binary.BigEndian.PutUint32(uuid[0:4], uint32(now)) binary.BigEndian.PutUint16(uuid[4:6], uint16(now>>32)) binary.BigEndian.PutUint16(uuid[6:8], uint16(now>>48)) binary.BigEndian.PutUint16(uuid[8:10], uint16(seq)) copy(uuid[10:16], HardWareAddress[0:6]) uuid[6] = (uuid[6] & 0x0f) | (UUIDv1) uuid[8] = (uuid[8] & 0x3f) | (UUID_RFC) return case UUIDv1MacRand: seq := atomic.AddUint32(&monotonic_v1, 1) now := uint64(time.Now().UnixNano()/100 + 12219292800000) binary.BigEndian.PutUint32(uuid[0:4], uint32(now)) binary.BigEndian.PutUint16(uuid[4:6], uint16(now>>32)) binary.BigEndian.PutUint16(uuid[6:8], uint16(now>>48)) binary.BigEndian.PutUint16(uuid[8:10], uint16(seq)) _, err = rand.Read(uuid[10:16]) uuid[6] = (uuid[6] & 0x0f) | (UUIDv1) uuid[8] = (uuid[8] & 0x3f) | (UUID_RFC) return case UUIDv1_timestamp: seq := atomic.AddUint32(&monotonic_v1, 1) now := uint64(time.Now().UnixNano()/100 + 12219292800000) binary.BigEndian.PutUint32(uuid[0:4], uint32(now)) binary.BigEndian.PutUint16(uuid[4:6], uint16(now>>32)) binary.BigEndian.PutUint16(uuid[6:8], uint16(now>>48)) binary.BigEndian.PutUint16(uuid[8:10], uint16(seq)) uuid[6] = (uuid[6] & 0x0f) | (UUIDv1) uuid[8] = (uuid[8] & 0x3f) | (UUID_RFC) return case UUIDv4: _, err = rand.Read(uuid[:]) if err != nil { return } uuid[6] = (uuid[6] & 0x0f) | (UUIDv4) uuid[8] = (uuid[8] & 0x3f) | (UUID_RFC) return default: err = errors.New("cant generate this uuid") return } }
func (pc *proxyCounter) Delete(args *storagerpc.DeleteArgs, reply *storagerpc.DeleteReply) error { if pc.override { reply.Status = pc.overrideStatus return pc.overrideErr } byteCount := len(args.Key) err := pc.srv.Call("StorageServer.Delete", args, reply) atomic.AddUint32(&pc.rpcCount, 1) atomic.AddUint32(&pc.byteCount, uint32(byteCount)) return err }
func (pc *proxyCounter) AppendToList(args *storagerpc.PutArgs, reply *storagerpc.PutReply) error { if pc.override { reply.Status = pc.overrideStatus return pc.overrideErr } byteCount := len(args.Key) + len(args.Value) err := pc.srv.Call("StorageServer.AppendToList", args, reply) atomic.AddUint32(&pc.rpcCount, 1) atomic.AddUint32(&pc.byteCount, uint32(byteCount)) return err }
func (pc *ProxyCounter) RemoveFromList(args *storageproto.PutArgs, reply *storageproto.PutReply) error { if pc.override { reply.Status = pc.overrideStatus return pc.overrideErr } byteCount := len(args.Key) + len(args.Value) err := pc.srv.Call("StorageRPC.RemoveFromList", args, reply) atomic.AddUint32(&pc.rpcCount, 1) atomic.AddUint32(&pc.byteCount, uint32(byteCount)) return err }
// Get returns buffer with length of n. func (p *BufferPool) Get(n int) []byte { atomic.AddUint32(&p.get, 1) if poolNum := p.poolNum(n); poolNum == 0 { // Fast path. if b, ok := p.pool[0].Get().([]byte); ok { switch { case cap(b) > n: atomic.AddUint32(&p.less, 1) return b[:n] case cap(b) == n: atomic.AddUint32(&p.equal, 1) return b[:n] default: panic("not reached") } } else { atomic.AddUint32(&p.miss, 1) } return make([]byte, n, p.baseline0) } else { sizePtr := &p.size[poolNum-1] if b, ok := p.pool[poolNum].Get().([]byte); ok { switch { case cap(b) > n: atomic.AddUint32(&p.less, 1) return b[:n] case cap(b) == n: atomic.AddUint32(&p.equal, 1) return b[:n] default: atomic.AddUint32(&p.greater, 1) if uint32(cap(b)) >= atomic.LoadUint32(sizePtr) { p.pool[poolNum].Put(b) } } } else { atomic.AddUint32(&p.miss, 1) } if size := atomic.LoadUint32(sizePtr); uint32(n) > size { if size == 0 { atomic.CompareAndSwapUint32(sizePtr, 0, uint32(n)) } else { sizeMissPtr := &p.sizeMiss[poolNum-1] if atomic.AddUint32(sizeMissPtr, 1) == 20 { atomic.StoreUint32(sizePtr, uint32(n)) atomic.StoreUint32(sizeMissPtr, 0) } } return make([]byte, n) } else { return make([]byte, n, size) } } }