hi,
I am using a simple queue and bench marking it.
queue.go = implementation of the queue.
queue_test.go = benchmarking
profile002.pdf= pprof tool mem analysis
the command used to run the bench mark is
`go test -run='^#' -bench=BenchmarkAdd -benchmem -count=10`

results :
```
go test -run='^#' -bench=BenchmarkAdd -benchmem -count=10
goos: linux
goarch: amd64
pkg: queue-middleware/queue
cpu: Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz
BenchmarkAdd-8          78255547                15.13 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
BenchmarkAdd-8          86375668                13.84 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
BenchmarkAdd-8          91471299                13.00 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
BenchmarkAdd-8          87612523                12.70 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
BenchmarkAdd-8          93454760                12.76 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
BenchmarkAdd-8          91850235                12.75 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
BenchmarkAdd-8          97128108                13.36 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
BenchmarkAdd-8          93765214                12.94 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
BenchmarkAdd-8          86242954                13.07 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
BenchmarkAdd-8          88524364                12.76 ns/op            0 
B/op          0 allocs/op
--- BENCH: BenchmarkAdd-8
    queue_test.go:36: size:1
    queue_test.go:36: size:5
PASS
ok      queue-middleware/queue  11.831s
```
my understanding is 
- 0B/op = no allocation done
- 0 allocs/op = no allocation per operation

Does this mean the allocation is zero for the `Add` operation?

generally,  when you create queue it allocates memory in heap, will it not 
be reported in `benchmem`?


-- 
You received this message because you are subscribed to the Google Groups 
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to golang-nuts+unsubscr...@googlegroups.com.
To view this discussion visit 
https://groups.google.com/d/msgid/golang-nuts/42c18d81-66bc-4616-9817-77195bbadeb3n%40googlegroups.com.

Attachment: profile002.pdf
Description: Adobe PDF document

package queue

import "fmt"

type node struct {
	data int
	next *node
}

type queue struct {
	size int
	head *node
	tail *node
}

func New(size int) *queue {
	return &queue{size: size}
}

func (q *queue) Add(data int) {
	if q.size == 0 {
		return
	}
	n := &node{data: data}
	if q.head == nil {
		q.head = n
		q.tail = n
		q.size -= 1
		return
	}
	q.tail.next = n
	q.tail = n
}

func (q *queue) print() {
	temp := q.head
	for temp != nil {
		fmt.Printf("%d\n", temp.data)
		temp = temp.next
	}

}

// func New(size int) *queue {
// 	return &queue{size: size,
// 		data: make(chan int, size)}
// }

// func (q *queue) Add(data int) {
// 	if len(q.data) >= q.size {
// 		return
// 	}
// 	q.data <- data
// }
package queue

import "testing"

var q *queue

func TestNew(t *testing.T) {
	q = New(1)
}

func BenchmarkNew(b *testing.B) {
	size := []int{1, 5, 10, 50, 100}
	for _, v := range size {
		b.Logf("size:%d\n", v)
		b.ResetTimer()
		for b.Loop() {
			q = New(v)
		}

	}
}

func TestAdd(t *testing.T) {
	size := []int{1, 5}
	for _, s := range size {
		qe := New(s)
		qe.Add(1)
	}
}

func BenchmarkAdd(b *testing.B) {
	size := []int{1, 5}
	b.ReportAllocs()
	for _, v := range size {
		q = New(1)
		b.Logf("size:%d\n", v)
		for b.Loop() {
			for i := range v {
				q.Add(i)
			}

		}
	}
}

func TestPrint(t *testing.T) {
	q := New(5)
	q.Add(1)
	q.Add(2)
	q.Add(3)
	q.Add(4)
	q.Add(5)
	q.print()
}

Reply via email to