고랭과 아레나

package arena

import (
	"reflect"
	"runtime"
	"syscall"
	"unsafe"

	"github.com/unsafe-risk/mi/mimalloc"
)

// This code is implemented by lemon-mint.
// I brought the code from unsafe-risk/umem.

// This Implementation is based on the proposal in the following url: https://github.com/golang/go/issues/51317

// Thread-unsafe Allocation Arena.
type Arena struct {
	// The start address of the region.
	head uintptr
	// Tail of the region.
	tail uintptr
}

func NewFinalizer() *Arena {
	a := &Arena{}
	runtime.SetFinalizer(a, arenaFinalizer)
	return a
}

func New() *Arena {
	a := &Arena{}
	return a
}

func arenaFinalizer(a *Arena) {
	a.Free()
}

// Page Structure
/*
	|  0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |
	|-----|-----|-----|-----|-----|-----|-----|-----|
	|  page size            |  page head            |
	|-----|-----|-----|-----|-----|-----|-----|-----|
	|  Next Page Ptr                                |
	|-----|-----|-----|-----|-----|-----|-----|-----|
	|                                               |
	|                                               |
	|                                               |
	|                      Data                     |
	|                                               |
	|                                               |
	|                                               |
	|-----|-----|-----|-----|-----|-----|-----|-----|
*/

func (r *Arena) newPage(size int) {
	// println("Allocating new page", size)
	sptr := mimalloc.Malloc(size + 16)
	pagesize := (*uint32)(unsafe.Pointer(sptr))
	pagehead := (*uint32)(unsafe.Pointer(uintptr(sptr) + 4))
	nextpage := (*uint64)(unsafe.Pointer(uintptr(sptr) + 8))

	*pagesize = uint32(size)
	*pagehead = 0
	*nextpage = 0

	if r.tail != 0 {
		// Add to the tail of the region.
		tailNextPage := (*uint64)(unsafe.Pointer(r.tail + 8))
		if *tailNextPage != 0 {
			*nextpage = *tailNextPage
		}
		*tailNextPage = uint64(uintptr(sptr))
	}
	r.tail = uintptr(sptr)
	if r.head == 0 {
		r.head = uintptr(sptr)
	}
	// println("New page allocated", size, sptr)
}

var defaultPageSize = syscall.Getpagesize()*4 - 16

func (r *Arena) allocate(size int) uintptr {
retry:
	if r.tail == 0 {
		// println("tail is 0, allocating new page")
		if size > defaultPageSize {
			r.newPage(size)
		} else {
			r.newPage(defaultPageSize)
		}
	}

	pagesize := (*uint32)(unsafe.Pointer(r.tail))
	pagehead := (*uint32)(unsafe.Pointer(r.tail + 4))
	nextpage := (*uint64)(unsafe.Pointer(r.tail + 8))
	if *pagesize-*pagehead < uint32(size) {
		if *nextpage != 0 {
			r.tail = uintptr(*nextpage)
			goto retry
		}
		if size > defaultPageSize {
			r.newPage(size)
		} else {
			r.newPage(defaultPageSize)
		}
		pagesize = (*uint32)(unsafe.Pointer(r.tail))
		pagehead = (*uint32)(unsafe.Pointer(r.tail + 4))
		nextpage = (*uint64)(unsafe.Pointer(r.tail + 8))
	}

	data := r.tail + 16 + uintptr(*pagehead)
	*pagehead += uint32(size)
	return data
}

package arena

import (
	"testing"
)

type Person struct {
	Name    string
	Age     int
	Address string
	number  int
	uuid    string
}

const nAlloc = 1000000

func BenchmarkAllocateUmemUninitializedPerson(b *testing.B) {
	r := New()
	for i := 0; i < b.N; i++ {
		for j := 0; j < nAlloc; j++ {
			p := NewOfUninitialized[Person](r)
			p.Name = "John"
			p.Age = 42
			p.Address = "London"
			p.number = i
			p.uuid = "12345"
		}
	}
	r.Free()
}

func BenchmarkAllocateUmemPerson(b *testing.B) {
	r := New()
	for i := 0; i < b.N; i++ {
		for j := 0; j < nAlloc; j++ {
			p := NewOf[Person](r)
			p.Name = "John"
			p.Age = 42
			p.Address = "London"
			p.number = i
			p.uuid = "12345"
		}
	}
	r.Free()
}

//go:noinline
func StdNewPerson() *Person {
	p := new(Person)
	return p
}

func BenchmarkAllocateStdNew(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for j := 0; j < nAlloc; j++ {
			p := StdNewPerson()
			p.Name = "John"
			p.Age = 42
			p.Address = "London"
			p.number = i
			p.uuid = "12345"
		}
	}
}

package arena_test

import (
	"runtime"
	"testing"

	"github.com/unsafe-risk/mi/arena"
)

type Person struct {
	Name string
	Age  int
	Addr string
	Zip  int
}

const MAX = 2000000

func BenchmarkMiArenaPerson(b *testing.B) {
	b.RunParallel(func(p *testing.PB) {
		for p.Next() {
			a := arena.New()
			for i := 0; i < MAX; i++ {
				p := arena.NewOf[Person](a)
				p.Name = "John"
				p.Age = 32
				p.Addr = "Istanbul"
				p.Zip = 397
			}
			a.Free()
		}
	})
}

//go:noinline
func StdNewPerson() *Person {
	p := new(Person)
	return p
}

func BenchmarkStdNew(b *testing.B) {
	b.RunParallel(func(p *testing.PB) {
		for p.Next() {
			for i := 0; i < MAX; i++ {
				p := StdNewPerson()
				p.Name = "John"
				p.Age = 32
				p.Addr = "London"
				p.Zip = 1111
			}
			runtime.GC()
		}
	})
}