Dieterbe/main.go

## main.go
package main

import (
	"fmt"
	"os"
	"runtime"
	"time"

	"github.com/prometheus/procfs"
)

type data struct {
	d    []byte
	prev *data
}

func newData(prev *data, size int) *data {
	d := data{
		d:    make([]byte, size),
		prev: prev,
	}
	for i := range d.d {
		d.d[i] = byte(i % 255)
	}
	return &d
}

func main() {
	Mi := uint64(1024 * 1024)
	go func() {
		pid := os.Getpid()

		p, err := procfs.NewProc(pid)
		if err != nil {
			panic(err)
		}

		m := &runtime.MemStats{}
		tick := time.NewTicker(10 * time.Second)
		fmt.Println(time.Now(), "in MiB: HeapAlloc     Sys HeapSys HeapReleased HeapIdle     VSZ     RSS")
		for range tick.C {
			stat, err := p.NewStat()
			if err != nil {
				panic(err)
			}
			vsz := uint64(stat.VirtualMemory())
			rss := uint64(stat.ResidentMemory())
			runtime.ReadMemStats(m)
			fmt.Printf("%-60s%13d%8d%8d%13d%9d%8d%8d\n", time.Now(), m.HeapAlloc/Mi, m.Sys/Mi, m.HeapSys/Mi, m.HeapReleased/Mi, m.HeapIdle/Mi, vsz/Mi, rss/Mi)
		}

	}()

	fmt.Println("starting to allocate 1GiB.. this will take about a minute")
	first := newData(nil, int(Mi))
	prev := first
	for i := 0; i < 1023; i++ {
		prev = newData(prev, int(Mi))
		time.Sleep(60 * time.Millisecond)
	}
	fmt.Println(time.Now(), "done allocating")

	time.Sleep(time.Duration(30) * time.Second)

	fmt.Println(time.Now(), "freeing")
	first = nil
	prev = nil
	fmt.Println(time.Now(), "runtime.GC()")
	runtime.GC() // can be uncommented if desired if you're okay waiting for a "regular" GC cycle

	// keep program alive
	time.Sleep(time.Duration(10) * time.Minute)
}
	package main

	import (
	"fmt"
	"os"
	"runtime"
	"time"

	"github.com/prometheus/procfs"
	)

	type data struct {
	d []byte
	prev *data
	}

	func newData(prev data, size int) data {
	d := data{
	d: make([]byte, size),
	prev: prev,
	}
	for i := range d.d {
	d.d[i] = byte(i % 255)
	}
	return &d
	}

	func main() {
	Mi := uint64(1024 * 1024)
	go func() {
	pid := os.Getpid()

	p, err := procfs.NewProc(pid)
	if err != nil {
	panic(err)
	}

	m := &runtime.MemStats{}
	tick := time.NewTicker(10 * time.Second)
	fmt.Println(time.Now(), "in MiB: HeapAlloc Sys HeapSys HeapReleased HeapIdle VSZ RSS")
	for range tick.C {
	stat, err := p.NewStat()
	if err != nil {
	panic(err)
	}
	vsz := uint64(stat.VirtualMemory())
	rss := uint64(stat.ResidentMemory())
	runtime.ReadMemStats(m)
	fmt.Printf("%-60s%13d%8d%8d%13d%9d%8d%8d\n", time.Now(), m.HeapAlloc/Mi, m.Sys/Mi, m.HeapSys/Mi, m.HeapReleased/Mi, m.HeapIdle/Mi, vsz/Mi, rss/Mi)
	}

	}()

	fmt.Println("starting to allocate 1GiB.. this will take about a minute")
	first := newData(nil, int(Mi))
	prev := first
	for i := 0; i < 1023; i++ {
	prev = newData(prev, int(Mi))
	time.Sleep(60 * time.Millisecond)
	}
	fmt.Println(time.Now(), "done allocating")

	time.Sleep(time.Duration(30) * time.Second)

	fmt.Println(time.Now(), "freeing")
	first = nil
	prev = nil
	fmt.Println(time.Now(), "runtime.GC()")
	runtime.GC() // can be uncommented if desired if you're okay waiting for a "regular" GC cycle

	// keep program alive
	time.Sleep(time.Duration(10) * time.Minute)
	}