Golang StoreInt64示例

说明

golang storeint64示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: sync/atomic

示例#1
文件: batch_tx.go 项目: achanda/etcd

func (t *batchTx) commit(stop bool) {
	var err error
	// commit the last tx
	if t.tx != nil {
		if t.pending == 0 && !stop {
			t.backend.mu.RLock()
			defer t.backend.mu.RUnlock()
			atomic.StoreInt64(&t.backend.size, t.tx.Size())
			return
		}
		err = t.tx.Commit()
		atomic.AddInt64(&t.backend.commits, 1)

		t.pending = 0
		if err != nil {
			log.Fatalf("mvcc: cannot commit tx (%s)", err)
		}
	}

	if stop {
		return
	}

	t.backend.mu.RLock()
	defer t.backend.mu.RUnlock()
	// begin a new tx
	t.tx, err = t.backend.db.Begin(true)
	if err != nil {
		log.Fatalf("mvcc: cannot begin tx (%s)", err)
	}
	atomic.StoreInt64(&t.backend.size, t.tx.Size())
}

示例#2
文件: throttled.go 项目: Psiphon-Labs/psiphon-tunnel-core

// SetLimits modifies the rate limits of an existing
// ThrottledConn. It is safe to call SetLimits while
// other goroutines are calling Read/Write. This function
// will not block, and the new rate limits will be
// applied within Read/Write, but not necessarily until
// some futher I/O at previous rates.
func (conn *ThrottledConn) SetLimits(limits RateLimits) {

	// Using atomic instead of mutex to avoid blocking
	// this function on throttled I/O in an ongoing
	// read or write. Precise synchronized application
	// of the rate limit values is not required.

	// Negative rates are invalid and -1 is a special
	// value to used to signal throttling initialized
	// state. Silently normalize negative values to 0.
	rate := limits.ReadBytesPerSecond
	if rate < 0 {
		rate = 0
	}
	atomic.StoreInt64(&conn.readBytesPerSecond, rate)
	atomic.StoreInt64(&conn.readUnthrottledBytes, limits.ReadUnthrottledBytes)

	rate = limits.WriteBytesPerSecond
	if rate < 0 {
		rate = 0
	}
	atomic.StoreInt64(&conn.writeBytesPerSecond, rate)
	atomic.StoreInt64(&conn.writeUnthrottledBytes, limits.WriteUnthrottledBytes)

	closeAfterExhausted := int32(0)
	if limits.CloseAfterExhausted {
		closeAfterExhausted = 1
	}
	atomic.StoreInt32(&conn.closeAfterExhausted, closeAfterExhausted)
}

示例#3
文件: cronManager.go 项目: sdgoij/goat

// cronPrintCurrentStatus logs the regular status check banner
func cronPrintCurrentStatus() {
	// Grab server status
	stat := common.GetServerStatus()
	if stat == (common.ServerStatus{}) {
		log.Println("Could not print current status")
		return
	}

	// Regular status banner
	log.Printf("status - [goroutines: %d] [memory: %02.3f MB]", stat.NumGoroutine, stat.MemoryMB)

	// HTTP stats
	if common.Static.Config.HTTP {
		log.Printf("  http - [current: %d] [total: %d]", stat.HTTP.Current, stat.HTTP.Total)

		// Reset current HTTP counter
		atomic.StoreInt64(&common.Static.HTTP.Current, 0)
	}

	// UDP stats
	if common.Static.Config.UDP {
		log.Printf("   udp - [current: %d] [total: %d]", stat.UDP.Current, stat.UDP.Total)

		// Reset current UDP counter
		atomic.StoreInt64(&common.Static.UDP.Current, 0)
	}
}

示例#4
文件: wal.go 项目: li-ang/influxdb

// newSegmentFile will close the current segment file and open a new one, updating bookkeeping info on the log
func (l *WAL) newSegmentFile() error {
	l.currentSegmentID++
	if l.currentSegmentWriter != nil {
		if err := l.currentSegmentWriter.close(); err != nil {
			return err
		}
		atomic.StoreInt64(&l.stats.OldBytes, int64(l.currentSegmentWriter.size))
	}

	fileName := filepath.Join(l.path, fmt.Sprintf("%s%05d.%s", WALFilePrefix, l.currentSegmentID, WALFileExtension))
	fd, err := os.OpenFile(fileName, os.O_CREATE|os.O_RDWR, 0666)
	if err != nil {
		return err
	}
	l.currentSegmentWriter = NewWALSegmentWriter(fd)

	if stat, err := fd.Stat(); err == nil {
		l.lastWriteTime = stat.ModTime()
	}

	// Reset the current segment size stat
	atomic.StoreInt64(&l.stats.CurrentBytes, 0)

	return nil
}

示例#5
文件: partition_consumer.go 项目: elodina/gonzo

func (pc *KafkaPartitionConsumer) initOffset() bool {
	log.Infof("Initializing offset for topic %s, partition %d", pc.topic, pc.partition)
	for {
		offset, err := pc.client.GetOffset(pc.config.Group, pc.topic, pc.partition)
		if err != nil {
			if err == siesta.ErrUnknownTopicOrPartition {
				return pc.resetOffset()
			}
			log.Warning("Cannot get offset for group %s, topic %s, partition %d: %s\n", pc.config.Group, pc.topic, pc.partition, err)
			select {
			case <-pc.stop:
				{
					log.Warning("PartitionConsumer told to stop trying to get offset, returning")
					return false
				}
			default:
			}
		} else {
			validOffset := offset + 1
			log.Infof("Initialized offset to %d", validOffset)
			atomic.StoreInt64(&pc.offset, validOffset)
			atomic.StoreInt64(&pc.highwaterMarkOffset, validOffset)
			return true
		}
		time.Sleep(pc.config.InitOffsetBackoff)
	}
}

示例#6
文件: datum.go 项目: yanghongkjxy/mtail

func (d *Datum) stamp(timestamp time.Time) {
	if timestamp.IsZero() {
		atomic.StoreInt64(&d.Time, time.Now().UTC().UnixNano())
	} else {
		atomic.StoreInt64(&d.Time, timestamp.UnixNano())
	}
}

示例#7
文件: client.go 项目: jamloop/rtbkit

func (c *Client) HealthCheck(url string) (err error) {
	r, err := defaults.Client(c.Client).Get(url)
	if err != nil {
		atomic.StoreInt64(&c.count, 0)
		//trace.Error(ctx, "Errors.Fail", err)
		log.Println("forensiq:", err)
		return
	}

	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		atomic.StoreInt64(&c.count, 0)
		//trace.Error(ctx, "Errors.Down", err)
		log.Println("forensiq: down")
		return
	}

	if result := string(body); r.StatusCode != http.StatusOK || result[0] != '1' {
		atomic.StoreInt64(&c.count, 0)
		err = fmt.Errorf("%s: %s", r.Status, result)
		//trace.Error(ctx, "Errors.Status", err)
		log.Println("forensiq:", err)
		return
	}

	atomic.StoreInt64(&c.count, defaults.Int64(c.FailCount, 10))
	return
}

示例#8
文件: consumer.go 项目: jcoene/go-nsq

func (r *Consumer) backoff() {

	if atomic.LoadInt32(&r.stopFlag) == 1 {
		atomic.StoreInt64(&r.backoffDuration, 0)
		return
	}

	// pick a random connection to test the waters
	conns := r.conns()
	if len(conns) == 0 {
		// backoff again
		backoffDuration := 1 * time.Second
		atomic.StoreInt64(&r.backoffDuration, backoffDuration.Nanoseconds())
		time.AfterFunc(backoffDuration, r.backoff)
		return
	}
	idx := r.rng.Intn(len(conns))
	choice := conns[idx]

	r.log(LogLevelWarning,
		"(%s) backoff timeout expired, sending RDY 1",
		choice.String())
	// while in backoff only ever let 1 message at a time through
	err := r.updateRDY(choice, 1)
	if err != nil {
		r.log(LogLevelWarning, "(%s) error updating RDY - %s", choice.String(), err)
		backoffDuration := 1 * time.Second
		atomic.StoreInt64(&r.backoffDuration, backoffDuration.Nanoseconds())
		time.AfterFunc(backoffDuration, r.backoff)
		return
	}

	atomic.StoreInt64(&r.backoffDuration, 0)
}

示例#9
文件: gostrich.go 项目: xianxu/gostrich

func (s *intSampler) Clear() {
	atomic.StoreInt64(&s.count, 0)
	atomic.StoreInt64(&s.sum, 0)
	for i := range s.cache {
		atomic.StoreInt64(&s.cache[i], 0)
	}
}

示例#10
文件: speed.go 项目: hidu/tool

func (sp *Speed) printLog(now time.Time) {
	now_used := now.Sub(sp.LastTime).Seconds()
	sp.LastTime = now
	if now_used == 0 || sp.TotalSec == 0 {
		return
	}
	log_format := "total=%d,qps=%d,total_%ds=%d,speed=%.2fMps,total_size=%s,total_suc=%d," + fmt.Sprintf("total_%ds_suc", int64(now_used)) + "=%d"
	size_speed := float64(sp.TotalSecSize) / now_used / (1024 * 1024)

	TotalSize_str := ""
	if sp.TotalSize > gsize {
		TotalSize_str = fmt.Sprintf("%.2fG", float64(sp.TotalSize)/float64(gsize))
	} else if sp.TotalSize > msize {
		TotalSize_str = fmt.Sprintf("%.2fM", float64(sp.TotalSize)/float64(msize))
	} else {
		TotalSize_str = fmt.Sprintf("%.2fK", float64(sp.TotalSize)/float64(1024))
	}

	logMsg := fmt.Sprintf(log_format, sp.Total, int64(float64(sp.TotalSec)/now_used), int64(now_used), sp.TotalSec, size_speed, TotalSize_str, sp.TotalSuccess, sp.TotalSecSuccess)
	sp.PrintFn(logMsg, sp)

	atomic.StoreInt64(&sp.TotalSec, 0)
	atomic.StoreInt64(&sp.TotalSecSize, 0)
	atomic.StoreInt64(&sp.TotalSecSuccess, 0)
}

示例#11
文件: batch_tx.go 项目: CliffYuan/etcd

func (t *batchTx) commit(stop bool) {
	var err error
	// commit the last tx
	if t.tx != nil {
		if t.pending == 0 && !stop {
			t.backend.mu.RLock()
			defer t.backend.mu.RUnlock()
			atomic.StoreInt64(&t.backend.size, t.tx.Size())
			return
		}
		start := time.Now()
		err = t.tx.Commit()
		commitDurations.Observe(time.Since(start).Seconds())
		atomic.AddInt64(&t.backend.commits, 1)

		t.pending = 0
		if err != nil {
			plog.Fatalf("cannot commit tx (%s)", err)
		}
	}

	if stop {
		return
	}

	t.backend.mu.RLock()
	defer t.backend.mu.RUnlock()
	// begin a new tx
	t.tx, err = t.backend.db.Begin(true)
	if err != nil {
		plog.Fatalf("cannot begin tx (%s)", err)
	}
	atomic.StoreInt64(&t.backend.size, t.tx.Size())
}

示例#12
文件: midi_cgo.go 项目: lamproae/sigourney

func midiLoop(s *portmidi.Stream) {
	noteOn := make([]int64, 0, 128)
	for e := range s.Listen() {
		switch e.Status {
		case 144: // note on
			on := false
			for _, n := range noteOn {
				if n == e.Data1 {
					on = true
				}
			}
			if !on {
				noteOn = append(noteOn, e.Data1)
			}
			atomic.StoreInt64(&midiNote, e.Data1)
			atomic.StoreInt64(&midiGate, 1)
		case 128: // note off
			for i, n := range noteOn {
				if n == e.Data1 {
					copy(noteOn[i:], noteOn[i+1:])
					noteOn = noteOn[:len(noteOn)-1]
				}
			}
			if len(noteOn) > 0 {
				n := noteOn[len(noteOn)-1]
				atomic.StoreInt64(&midiNote, n)
			} else {
				atomic.StoreInt64(&midiGate, 0)
			}
		}
	}
}

示例#13
文件: consumer.go 项目: pgpst/pgpst

func (r *Consumer) resume() {
	if atomic.LoadInt32(&r.stopFlag) == 1 {
		atomic.StoreInt64(&r.backoffDuration, 0)
		return
	}

	// pick a random connection to test the waters
	conns := r.conns()
	if len(conns) == 0 {
		r.log(LogLevelWarning, "no connection available to resume")
		r.log(LogLevelWarning, "backing off for %.04f seconds", 1)
		r.backoff(time.Second)
		return
	}
	idx := r.rng.Intn(len(conns))
	choice := conns[idx]

	r.log(LogLevelWarning,
		"(%s) backoff timeout expired, sending RDY 1",
		choice.String())

	// while in backoff only ever let 1 message at a time through
	err := r.updateRDY(choice, 1)
	if err != nil {
		r.log(LogLevelWarning, "(%s) error resuming RDY 1 - %s", choice.String(), err)
		r.log(LogLevelWarning, "backing off for %.04f seconds", 1)
		r.backoff(time.Second)
		return
	}

	atomic.StoreInt64(&r.backoffDuration, 0)
}

示例#14
文件: task.go 项目: 0x9e3779b9/golang_lab

func (t *Task) Run() {
	var tag int64
	t.wg.Add(1)
	defer t.wg.Done()
LOOP:
	for {
		select {
		case <-t.pauseCh:
			atomic.StoreInt64(&tag, 1)
		case <-t.continueCh:
			atomic.StoreInt64(&tag, 0)
		case <-t.stopCh:
			break LOOP
		default:
			if atomic.LoadInt64(&tag) == 0 {
				t.do(t.index + 1)
				t.index++
				if t.index >= t.cnt {
					atomic.StoreInt64(&t.state, FINISH)
					break LOOP
				}
			} else {
				time.Sleep(time.Second * 1)
			}
		}
	}
}

示例#15
文件: worker.go 项目: jrallison/go-workers

func (w *worker) work(messages chan *Msg) {
	for {
		select {
		case message := <-messages:
			atomic.StoreInt64(&w.startedAt, time.Now().UTC().Unix())
			w.currentMsg = message

			if w.process(message) {
				w.manager.confirm <- message
			}

			atomic.StoreInt64(&w.startedAt, 0)
			w.currentMsg = nil

			// Attempt to tell fetcher we're finished.
			// Can be used when the fetcher has slept due
			// to detecting an empty queue to requery the
			// queue immediately if we finish work.
			select {
			case w.manager.fetch.FinishedWork() <- true:
			default:
			}
		case w.manager.fetch.Ready() <- true:
			// Signaled to fetcher that we're
			// ready to accept a message
		case <-w.stop:
			w.exit <- true
			return
		}
	}
}

示例#16
文件: counter.go 项目: CrocdileChan/kingshard

//flush the count per second
func (counter *Counter) FlushCounter() {
	atomic.StoreInt64(&counter.OldClientQPS, counter.ClientQPS)
	atomic.StoreInt64(&counter.OldErrLogTotal, counter.ErrLogTotal)
	atomic.StoreInt64(&counter.OldSlowLogTotal, counter.SlowLogTotal)

	atomic.StoreInt64(&counter.ClientQPS, 0)
}

示例#17
文件: file.go 项目: rawlingsj/gofabric8

func (f *File) Open() error {
	atomic.StoreInt64(&f.at, 0)
	atomic.StoreInt64(&f.readDirCount, 0)
	f.fileData.Lock()
	f.closed = false
	f.fileData.Unlock()
	return nil
}

示例#18
文件: reporter.go 项目: miffa/coffo

func (self *ResultData) Clear() {
	atomic.StoreInt64(&self.end_time, 0)
	atomic.StoreInt64(&self.begin_time, 0)
	atomic.StoreInt32(&self.msg_send, 0)
	atomic.StoreInt32(&self.msg_succ, 0)
	atomic.StoreInt32(&self.msg_failed, 0)
	atomic.StoreInt32(&self.msg_error, 0)
}

示例#19
文件: raf.go 项目: influx6/gu

// Toggle switches the state of the clock from paused to resume and vise versa.
func (c *Clock) Toggle() {
	if atomic.LoadInt64(&c.paused) < 0 {
		atomic.StoreInt64(&c.paused, 1)
		return
	}

	atomic.StoreInt64(&c.paused, -1)
}

示例#20
文件: clock.go 项目: mehulsbhatt/cistern

func Run() {
	atomic.StoreInt64(&now, time.Now().Unix())
	log.Println("  Starting internal clock")
	go func() {
		for t := range time.Tick(time.Second) {
			atomic.StoreInt64(&now, t.Unix())
		}
	}()
}

示例#21
文件: m7.go 项目: hqr/surge

// Similar to unicast models in this package,
// startNewChunk is in effect a minimalistic embedded client.
// The client, via startNewChunk, generates a new random chunk if and once
// the required number of replicas (configStorage.numReplicas)
// of the previous chunk are transmitted,
// written to disks and then ACK-ed by the respective servers.
//
// Since all the gateways in the model run the same code, the cumulative
// effect of randomly generated chunks by many dozens or hundreds
// gateways means that there's probably no need, simulation-wise,
// to have each gateway generate multiple chunks simultaneously..
//
func (r *gatewaySeven) startNewChunk() {
	assert(r.chunk == nil)
	r.chunk = NewChunk(r, configStorage.sizeDataChunk*1024)

	r.numreplicas = 0
	r.rzvgroup.init(0, true) // cleanup

	// given a pseudo-random chunk id, select a multicast group
	// to store this chunk
	ngid := r.selectNgtGroup(r.chunk.cid, r.prevgroupid)
	ngobj := NewNgtGroup(ngid)

	// create flow and tios
	targets := ngobj.getmembers()
	assert(len(targets) == configReplicast.sizeNgtGroup)

	// new IO request and new multicast flow
	tioparent := NewTioRr(r, r.putpipeline, r.chunk)
	mcastflow := NewFlow(r, r.chunk.cid, tioparent, ngobj)

	// children tios; each server must see its own copy of
	// the message
	for _, srv := range targets {
		NewTioRr(r, r.putpipeline, tioparent, r.chunk, mcastflow, srv)
	}
	assert(tioparent.GetNumTioChildren() == ngobj.getCount(), fmt.Sprintf("%d != %d", len(tioparent.children), ngobj.getCount()))

	mcastflow.setbw(0)
	mcastflow.totalbytes = r.chunk.sizeb
	mcastflow.rb = &DummyRateBucket{}

	log("gwy-new-mcastflow-tio", mcastflow.String(), tioparent.String())

	// start negotiating; each server in the negotiating group
	// will subsequently respond with a bid
	//
	// atomic on/off here and elsewhere is done to make sure that
	// all the put-request messages are issued at
	// the same exact system tick, to simulate multicast IP router
	// simultaneously transmitting a buffered frame on all designated ports
	//
	atomic.StoreInt64(&r.NowMcasting, 1)
	for _, srv := range targets {
		tio := tioparent.GetTioChild(srv)
		ev := newMcastChunkPutRequestEvent(r, ngobj, r.chunk, srv, tio)
		tio.next(ev, SmethodDirectInsert)
	}
	atomic.StoreInt64(&r.NowMcasting, 0)

	r.rb.use(int64(configNetwork.sizeControlPDU * 8))
	mcastflow.GetRb().use(int64(configNetwork.sizeControlPDU * 8))
	mcastflow.timeTxDone = Now.Add(configNetwork.durationControlPDU)

	atomic.AddInt64(&r.txbytestats, int64(configNetwork.sizeControlPDU))
	r.prevgroupid = ngid
}

示例#22
文件: funcstats.go 项目: taterbase/monkit

// Reset resets all recorded data.
func (f *FuncStats) Reset() {
	atomic.StoreInt64(&f.current, 0)
	atomic.StoreInt64(&f.highwater, 0)
	f.parentsAndMutex.Lock()
	f.errors = make(map[string]int64, len(f.errors))
	f.panics = 0
	f.successTimes.Reset()
	f.failureTimes.Reset()
	f.parentsAndMutex.Unlock()
}

示例#23
文件: cache.go 项目: CNDonny/scope

func (cache *Cache) Clear() {
	for i := 0; i < 256; i++ {
		cache.locks[i].Lock()
		newSeg := newSegment(len(cache.segments[i].rb.data), i)
		cache.segments[i] = newSeg
		cache.locks[i].Unlock()
	}
	atomic.StoreInt64(&cache.hitCount, 0)
	atomic.StoreInt64(&cache.missCount, 0)
}

示例#24
文件: terminal.go 项目: fgrehm/pucrs-simple-json-db

func (t *Terminal) ioloop() {
	t.wg.Add(1)
	defer t.wg.Done()
	var (
		isEscape       bool
		isEscapeEx     bool
		expectNextChar bool
	)

	buf := bufio.NewReader(Stdin)
	for {
		if !expectNextChar {
			atomic.StoreInt64(&t.isReading, 0)
			select {
			case <-t.kickChan:
				atomic.StoreInt64(&t.isReading, 1)
			case <-t.stopChan:
				return
			}
		}
		expectNextChar = false
		r, _, err := buf.ReadRune()
		if err != nil {
			break
		}

		if isEscape {
			isEscape = false
			if r == CharEscapeEx {
				expectNextChar = true
				isEscapeEx = true
				continue
			}
			r = escapeKey(r)
		} else if isEscapeEx {
			isEscapeEx = false
			r = escapeExKey(r, buf)
		}

		expectNextChar = true
		switch r {
		case CharEsc:
			if t.cfg.VimMode {
				t.outchan <- r
				break
			}
			isEscape = true
		case CharInterrupt, CharEnter, CharCtrlJ:
			expectNextChar = false
			fallthrough
		default:
			t.outchan <- r
		}
	}
}

示例#25
文件: cronManager.go 项目: gernest/goat

// cronStatsReset triggers a reset of certain statistic counters at regular intervals
func cronStatsReset() {
	// Trigger events every hour
	hour := time.NewTicker(1 * time.Hour)

	// Trigger events every half hour
	halfHour := time.NewTicker(30 * time.Minute)

	// Trigger events every minute
	minute := time.NewTicker(1 * time.Minute)

	for {
		select {
		case <-hour.C:
			// Reset hourly stats counters
			atomic.StoreInt64(&common.Static.API.Hour, 0)
			atomic.StoreInt64(&common.Static.HTTP.Hour, 0)
			atomic.StoreInt64(&common.Static.UDP.Hour, 0)
		case <-halfHour.C:
			// Reset half-hourly stats counters
			atomic.StoreInt64(&common.Static.API.HalfHour, 0)
			atomic.StoreInt64(&common.Static.HTTP.HalfHour, 0)
			atomic.StoreInt64(&common.Static.UDP.HalfHour, 0)
		case <-minute.C:
			// Reset minute stats counters
			atomic.StoreInt64(&common.Static.API.Minute, 0)
			atomic.StoreInt64(&common.Static.HTTP.Minute, 0)
			atomic.StoreInt64(&common.Static.UDP.Minute, 0)
		}
	}
}

示例#26
文件: osl.go 项目: adamkruger/psiphon-tunnel-core

// issueSLOKs checks client progress against each candidate seed spec
// and seeds SLOKs when the client traffic levels are achieved. After
// checking progress, and if the SLOK time period has changed since
// progress was last recorded, progress is reset. Partial, insufficient
// progress is intentionally dropped when the time period rolls over.
// Derived SLOKs are cached to avoid redundant CPU intensive operations.
// All issued SLOKs are retained in the client state for the duration
// of the client's session.
func (state *ClientSeedState) issueSLOKs() {

	// Concurrency: the caller must lock state.mutex.

	if state.scheme == nil {
		return
	}

	progressSLOKTime := time.Unix(0, state.progressSLOKTime)

	for index, progress := range state.progress {

		seedSpec := state.scheme.SeedSpecs[index]

		if progress.exceeds(&seedSpec.Targets) {

			ref := &slokReference{
				PropagationChannelID: state.propagationChannelID,
				SeedSpecID:           string(seedSpec.ID),
				Time:                 progressSLOKTime,
			}

			state.scheme.derivedSLOKCacheMutex.RLock()
			slok, ok := state.scheme.derivedSLOKCache[*ref]
			state.scheme.derivedSLOKCacheMutex.RUnlock()
			if !ok {
				slok = deriveSLOK(state.scheme, ref)
				state.scheme.derivedSLOKCacheMutex.Lock()
				state.scheme.derivedSLOKCache[*ref] = slok
				state.scheme.derivedSLOKCacheMutex.Unlock()
			}

			// Previously issued SLOKs are not re-added to
			// the payload.
			if state.issuedSLOKs[string(slok.ID)] == nil {
				state.issuedSLOKs[string(slok.ID)] = slok
				state.payloadSLOKs = append(state.payloadSLOKs, slok)
			}
		}
	}

	slokTime := getSLOKTime(state.scheme.SeedPeriodNanoseconds)

	if slokTime != atomic.LoadInt64(&state.progressSLOKTime) {
		atomic.StoreInt64(&state.progressSLOKTime, slokTime)
		// The progress map structure is not reset or modifed; instead
		// the mapped accumulator values are zeroed. Concurrently, port
		// forward relay goroutines continue to add to these accumulators.
		for _, progress := range state.progress {
			atomic.StoreInt64(&progress.BytesRead, 0)
			atomic.StoreInt64(&progress.BytesWritten, 0)
			atomic.StoreInt64(&progress.PortForwardDurationNanoseconds, 0)
		}
	}
}

示例#27
文件: server.go 项目: pingcap/tso

func (t *tsoTask) Run() error {
	if t.Interrupted() {
		return errors.New("task has been interrupted already")
	}

	// enter here means I am the leader tso.
	tso := t.tso

	log.Debugf("tso leader %s run task", tso)

	if err := tso.syncTimestamp(); err != nil {
		// interrupt here
		log.Errorf("sync timestmap err %v, interrupt this task", err)

		atomic.StoreInt64(&t.interrupted, 1)
		return errors.Trace(err)
	}

	atomic.StoreInt64(&tso.isLeader, 1)

	tsTicker := time.NewTicker(time.Duration(updateTimestampStep) * time.Millisecond)

	defer func() {
		atomic.StoreInt64(&tso.isLeader, 0)

		tsTicker.Stop()

		// we should close all connections.
		t.closeAllConns()
		log.Debugf("tso leader %s task end", tso)
	}()

	for {
		select {
		case err := <-t.interruptCh:
			log.Debugf("tso leader %s is interrupted, err %v", tso, err)

			// we will interrupt this task, and we can't run this task again.
			atomic.StoreInt64(&t.interrupted, 1)
			return errors.Trace(err)
		case <-t.stopCh:
			log.Debugf("tso leader %s is stopped", tso)

			// we will stop this task, maybe run again later.
			return errors.New("task is stopped")
		case conn := <-t.connCh:
			// handle connection below
			tso.handleConn(conn)
		case <-tsTicker.C:
			if err := tso.updateTimestamp(); err != nil {
				return errors.Trace(err)
			}
		}
	}
}

示例#28
文件: stats.go 项目: absolute8511/nsq

// the slave should also update the pub size stat,
// since the slave need sync with leader (which will cost the write performance)
func (self *TopicHistoryStatsInfo) UpdateHourlySize(curPubSize int64) {
	now := int32(time.Now().Hour())
	lastBucket := self.lastHour % 24
	if now != self.lastHour {
		lastBucket = now % 24
		atomic.StoreInt64(&self.HourlyPubSize[lastBucket], 0)
		atomic.StoreInt32(&self.lastHour, now)
	}
	atomic.AddInt64(&self.HourlyPubSize[lastBucket], curPubSize-self.lastPubSize)
	atomic.StoreInt64(&self.lastPubSize, curPubSize)
}

示例#29
文件: reader.go 项目: Eric-Chen/nsq

func (q *Reader) sendRDY(c *nsqConn, count int64) error {
	var buf bytes.Buffer
	atomic.AddInt64(&q.totalRdyCount, atomic.LoadInt64(&c.rdyCount)*-1+count)
	atomic.StoreInt64(&c.rdyCount, count)
	atomic.StoreInt64(&c.lastRdyCount, count)
	err := c.sendCommand(&buf, Ready(int(count)))
	if err != nil {
		handleError(q, c, fmt.Sprintf("[%s] error sending RDY %d - %s", c, count, err.Error()))
		return err
	}
	return nil
}

示例#30
文件: control.go 项目: rkuris/gocql

func (c *controlConn) connect(endpoints []string) error {
	// intial connection attmept, try to connect to each endpoint to get an initial
	// list of nodes.

	// shuffle endpoints so not all drivers will connect to the same initial
	// node.
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	perm := r.Perm(len(endpoints))
	shuffled := make([]string, len(endpoints))

	for i, endpoint := range endpoints {
		shuffled[perm[i]] = endpoint
	}

	// store that we are not connected so that reconnect wont happen if we error
	atomic.StoreInt64(&c.connecting, -1)

	var (
		conn *Conn
		err  error
	)

	for _, addr := range shuffled {
		conn, err = c.session.connect(JoinHostPort(addr, c.session.cfg.Port), c)
		if err != nil {
			log.Printf("gocql: unable to control conn dial %v: %v\n", addr, err)
			continue
		}

		if err = c.registerEvents(conn); err != nil {
			conn.Close()
			continue
		}

		// we should fetch the initial ring here and update initial host data. So that
		// when we return from here we have a ring topology ready to go.
		break
	}

	if conn == nil {
		// this is fatal, not going to connect a session
		return err
	}

	c.conn.Store(conn)
	atomic.StoreInt64(&c.connecting, 0)

	c.closeWg.Add(1)
	go c.heartBeat()

	return nil
}

展开阅读全文