llmongodb/counter.go

// counter
package main

import (
	"sync"
	"time"
)

type Counter struct {
	mu          sync.Mutex
	user        int
	log         int
	rem         int
	err         int
	dup         int
	time        time.Duration
	wg          []int
	tconsumer   float64
	tremover    float64
	tproducer   float64
	maxconsumer float64
	maxremover  float64
	minconsumer float64
	minremover  float64
}

func NewCounter() *Counter {
	return &Counter{
		user:        0,
		log:         0,
		err:         0,
		rem:         0,
		dup:         0,
		time:        0,
		maxconsumer: 0,
		maxremover:  0,
		minconsumer: 9999999999,
		minremover:  9999999999,
		tconsumer:   0,
		tremover:    0,
		tproducer:   0,
		wg:          make([]int, opts.Concurrent),
	}
}

func (c *Counter) AddUser() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.user++
}

func (c *Counter) AddDuplicate() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.dup++
}

func (c *Counter) AddLog(add int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.log += add
}

func (c *Counter) AddRem(add int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.rem += add
}

func (c *Counter) AddWG(id int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.wg[id]++
}

func (c *Counter) AddErr() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.err++
}

func (c *Counter) AddProducerTime(time time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.tproducer = (c.tproducer + time.Seconds()) / 2.0
}

func (c *Counter) AddConsumerTime(time time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.tconsumer = (c.tconsumer + time.Seconds()) / 2.0
	if c.maxconsumer < time.Seconds() {
		c.maxconsumer = time.Seconds()
	}
	if c.minconsumer > time.Seconds() {
		c.minconsumer = time.Seconds()
	}
}

func (c *Counter) AddRemoverTime(time time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.tremover = (c.tremover + time.Seconds()) / 2.0
	if c.maxremover < time.Seconds() {
		c.maxremover = time.Seconds()
	}
	if c.minremover > time.Seconds() {
		c.minremover = time.Seconds()
	}
}

func (c *Counter) DelWG(id int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.wg[id]--
}

func (c *Counter) GetUser() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.user
	return
}

func (c *Counter) GetDup() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.dup
	return
}

func (c *Counter) GetLog() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.log
	return
}

func (c *Counter) GetErr() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.err
	return
}

func (c *Counter) GetRem() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.rem
	return
}

func (c *Counter) GetWG(id int) (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.wg[id]
	return
}

func (c *Counter) GetTime() (ret float64) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.time.Seconds()
	return
}

func (c *Counter) GetConsumerTime() (ret float64) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.tconsumer
	return
}

func (c *Counter) GetRemoverTime() (ret float64) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.tremover
	return
}

func (c *Counter) GetProducerTime() (ret float64) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.tproducer
	return
}

func (c *Counter) GetMaxConsumer() (ret float64) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.maxconsumer
	return
}

func (c *Counter) GetMinConsumer() (ret float64) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.minconsumer
	return
}

func (c *Counter) GetMaxRemover() (ret float64) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.maxremover
	return
}

func (c *Counter) GetMinRemover() (ret float64) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.minremover
	return
}

func (c *Counter) SetTime(t time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.time = t
}