feat: separate into packages

Author: joetifa2003

collections_bench_test.go

@@ -1,6 +1,10 @@
-package mm
+package linkedlist
 
-import "fmt"
+import (
+	"fmt"
+
+	"github.com/joetifa2003/mm-go"
+)
 
 var popEmptyMsg = "cannot pop empty linked list"
 
@@ -18,23 +22,23 @@ type LinkedList[T any] struct {
 	length int
 }
 
-// NewLinkedList creates a new linked list.
-func NewLinkedList[T any]() *LinkedList[T] {
-	linkedList := Alloc[LinkedList[T]]()
+// New creates a new linked list.
+func New[T any]() *LinkedList[T] {
+	linkedList := mm.Alloc[LinkedList[T]]()
 
 	return linkedList
 }
 
 func (ll *LinkedList[T]) init(value T) {
-	ll.head = Alloc[linkedListNode[T]]()
+	ll.head = mm.Alloc[linkedListNode[T]]()
 	ll.head.value = value
 	ll.tail = ll.head
 	ll.length++
 }
 
 func (ll *LinkedList[T]) popLast() T {
 	value := ll.tail.value
-	Free(ll.tail)
+	mm.Free(ll.tail)
 	ll.tail = nil
 	ll.head = nil
 	ll.length--
@@ -49,7 +53,7 @@ func (ll *LinkedList[T]) PushBack(value T) {
 		return
 	}
 
-	newNode := Alloc[linkedListNode[T]]()
+	newNode := mm.Alloc[linkedListNode[T]]()
 	newNode.value = value
 	newNode.prev = ll.tail
 	ll.tail.next = newNode
@@ -65,7 +69,7 @@ func (ll *LinkedList[T]) PushFront(value T) {
 		return
 	}
 
-	newNode := Alloc[linkedListNode[T]]()
+	newNode := mm.Alloc[linkedListNode[T]]()
 	newNode.value = value
 	newNode.next = ll.head
 	ll.head.prev = newNode
@@ -86,7 +90,7 @@ func (ll *LinkedList[T]) PopBack() T {
 	value := ll.tail.value
 	newTail := ll.tail.prev
 	newTail.next = nil
-	Free(ll.tail)
+	mm.Free(ll.tail)
 	ll.tail = newTail
 	ll.length--
 
@@ -106,7 +110,7 @@ func (ll *LinkedList[T]) PopFront() T {
 	value := ll.head.value
 	newHead := ll.head.next
 	newHead.prev = nil
-	Free(ll.head)
+	mm.Free(ll.head)
 	ll.head = newHead
 	ll.length--
 
@@ -163,7 +167,7 @@ func (ll *LinkedList[T]) RemoveAt(idx int) T {
 	prevNode.next = nextNode
 	ll.length--
 
-	Free(node)
+	mm.Free(node)
 
 	return value
 }
@@ -258,9 +262,9 @@ func (ll *LinkedList[T]) Free() {
 
 	for currentNode != nil {
 		nextNode := currentNode.next
-		Free(currentNode)
+		mm.Free(currentNode)
 		currentNode = nextNode
 	}
 
-	Free(ll)
+	mm.Free(ll)
 }

linked_list.go linkedlist/linked_list.go

@@ -1,15 +1,16 @@
-package mm
+package linkedlist_test
 
 import (
 	"testing"
 
+	"github.com/joetifa2003/mm-go/linkedlist"
 	"github.com/stretchr/testify/assert"
 )
 
 func testPushAndPop(t *testing.T) {
 	assert := assert.New(t)
 
-	ll := NewLinkedList[int]()
+	ll := linkedlist.New[int]()
 	defer ll.Free()
 
 	ll.PushBack(15)
@@ -47,7 +48,7 @@ func testPushAndPop(t *testing.T) {
 func testForEach(t *testing.T) {
 	assert := assert.New(t)
 
-	ll := NewLinkedList[int]()
+	ll := linkedlist.New[int]()
 	defer ll.Free()
 
 	ll.PushBack(2)
@@ -71,7 +72,7 @@ func testForEach(t *testing.T) {
 func testIndexing(t *testing.T) {
 	assert := assert.New(t)
 
-	ll := NewLinkedList[int]()
+	ll := linkedlist.New[int]()
 	defer ll.Free()
 
 	ll.PushBack(1)
@@ -110,7 +111,7 @@ func testIndexing(t *testing.T) {
 func testRemove(t *testing.T) {
 	assert := assert.New(t)
 
-	ll := NewLinkedList[int]()
+	ll := linkedlist.New[int]()
 	defer ll.Free()
 
 	ll.PushBack(1)

linked_list_test.go linkedlist/linked_list_test.go

@@ -1,10 +1,12 @@
-package mm
+package mm_test
 
 import (
 	"fmt"
 	"runtime"
 	"testing"
 
+	"github.com/joetifa2003/mm-go"
+	"github.com/joetifa2003/mm-go/typedarena"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -42,7 +44,7 @@ func BenchmarkHeapManaged(b *testing.B) {
 }
 
 func manual(nodes int) {
-	allocatedNodes := AllocMany[Node](nodes)
+	allocatedNodes := mm.AllocMany[Node](nodes)
 
 	for j := 0; j < nodes; j++ {
 		var prev *Node
@@ -61,7 +63,7 @@ func manual(nodes int) {
 		}
 	}
 
-	FreeMany(allocatedNodes)
+	mm.FreeMany(allocatedNodes)
 	runtime.GC()
 }
 
@@ -70,7 +72,7 @@ func BenchmarkManual(b *testing.B) {
 }
 
 func arenaManual(nodes int) {
-	arena := NewTypedArena[Node](nodes)
+	arena := typedarena.New[Node](nodes)
 	allocatedNodes := arena.AllocMany(nodes)
 
 	for j := 0; j < nodes; j++ {
@@ -126,7 +128,7 @@ func createTreeManaged(depth int) *TreeNode {
 	return nil
 }
 
-func createTreeManual(depth int, arena *TypedArena[TreeNode]) *TreeNode {
+func createTreeManual(depth int, arena *typedarena.TypedArena[TreeNode]) *TreeNode {
 	if depth != 0 {
 		node := arena.Alloc()
 		node.left = createTreeManual(depth-1, arena)
@@ -157,7 +159,7 @@ func BenchmarkBinaryTreeArena(b *testing.B) {
 	for _, chunkSize := range []int{50, 100, 150, 250, 500} {
 		b.Run(fmt.Sprintf("chunk size %d", chunkSize), func(b *testing.B) {
 			for n := 0; n < b.N; n++ {
-				arena := NewTypedArena[TreeNode](chunkSize)
+				arena := typedarena.New[TreeNode](chunkSize)
 				tree := createTreeManual(25, arena)
 				sumBinaryTree(tree)
 				arena.Free()
@@ -170,8 +172,8 @@ func BenchmarkBinaryTreeArena(b *testing.B) {
 func TestAllocMany(t *testing.T) {
 	assert := assert.New(t)
 
-	allocated := AllocMany[int](2) // allocates 2 ints and returns it as a slice of ints with length 2
-	defer FreeMany(allocated)      // it's recommended to make sure the data gets deallocated (defer recommended to prevent leaks)
+	allocated := mm.AllocMany[int](2) // allocates 2 ints and returns it as a slice of ints with length 2
+	defer mm.FreeMany(allocated)      // it's recommended to make sure the data gets deallocated (defer recommended to prevent leaks)
 	assert.Equal(2, len(allocated))
 	allocated[0] = 15    // changes the data in the slice (aka the heap)
 	ptr := &allocated[0] // takes a pointer to the data in the heap
@@ -183,33 +185,33 @@ func TestAllocMany(t *testing.T) {
 func TestAlloc(t *testing.T) {
 	assert := assert.New(t)
 
-	ptr := Alloc[int]() // allocates a single int and returns a ptr to it
-	defer Free(ptr)     // frees the int (defer recommended to prevent leaks)
+	ptr := mm.Alloc[int]() // allocates a single int and returns a ptr to it
+	defer mm.Free(ptr)     // frees the int (defer recommended to prevent leaks)
 
 	*ptr = 15
 	assert.Equal(15, *ptr)
 
-	ptr2 := Alloc[[1e3]int]() // creates large array to make malloc mmap new chunk
-	defer Free(ptr2)
+	ptr2 := mm.Alloc[[1e3]int]() // creates large array to make malloc mmap new chunk
+	defer mm.Free(ptr2)
 }
 
 func TestReallocate(t *testing.T) {
 	assert := assert.New(t)
 
-	allocated := AllocMany[int](2) // allocates 2 int and returns it as a slice of ints with length 2
+	allocated := mm.AllocMany[int](2) // allocates 2 int and returns it as a slice of ints with length 2
 	allocated[0] = 15
 	assert.Equal(2, len(allocated))
-	allocated = Reallocate(allocated, 3)
+	allocated = mm.Reallocate(allocated, 3)
 	assert.Equal(3, len(allocated))
 	assert.Equal(15, allocated[0]) // data after reallocation stays the same
-	FreeMany(allocated)            // didn't use defer here because i'm doing a reallocation and changing the value of allocated variable (otherwise can segfault)
+	mm.FreeMany(allocated)         // didn't use defer here because i'm doing a reallocation and changing the value of allocated variable (otherwise can segfault)
 }
 
 func TestUnmapChunk(t *testing.T) {
-	data1 := AllocMany[int](1e6)
-	data2 := AllocMany[int](1e6)
-	data3 := AllocMany[int](1e6)
-	FreeMany(data2)
-	FreeMany(data1)
-	FreeMany(data3)
+	data1 := mm.AllocMany[int](1e6)
+	data2 := mm.AllocMany[int](1e6)
+	data3 := mm.AllocMany[int](1e6)
+	mm.FreeMany(data2)
+	mm.FreeMany(data1)
+	mm.FreeMany(data3)
 }

mm_test.go

@@ -1,13 +1,18 @@
-package mm
+package typedarena
+
+import (
+	"github.com/joetifa2003/mm-go"
+	"github.com/joetifa2003/mm-go/vector"
+)
 
 type typedChunk[T any] struct {
 	data []T
 	len  int
 }
 
 func newChunk[T any](size int) *typedChunk[T] {
-	chunk := Alloc[typedChunk[T]]()
-	chunk.data = AllocMany[T](size)
+	chunk := mm.Alloc[typedChunk[T]]()
+	chunk.data = mm.AllocMany[T](size)
 
 	return chunk
 }
@@ -24,25 +29,25 @@ func (c *typedChunk[T]) AllocMany(n int) []T {
 }
 
 func (c *typedChunk[T]) Free() {
-	FreeMany(c.data)
-	Free(c)
+	mm.FreeMany(c.data)
+	mm.Free(c)
 }
 
 // TypedArena is a growable typed arena
 type TypedArena[T any] struct {
-	chunks    *Vector[*typedChunk[T]]
+	chunks    *vector.Vector[*typedChunk[T]]
 	chunkSize int
 }
 
-// NewTypedArena creates a typed arena with the specified chunk size.
+// New creates a typed arena with the specified chunk size.
 // a chunk is the the unit of the arena, if T is int for example and the
 // chunk size is 5, then each chunk is going to hold 5 ints. And if the
 // chunk is filled it will allocate another chunk that can hold 5 ints.
 // then you can call FreeArena and it will deallocate all chunks together
-func NewTypedArena[T any](chunkSize int) *TypedArena[T] {
-	tArena := Alloc[TypedArena[T]]()
+func New[T any](chunkSize int) *TypedArena[T] {
+	tArena := mm.Alloc[TypedArena[T]]()
 	tArena.chunkSize = chunkSize
-	tArena.chunks = NewVector[*typedChunk[T]]()
+	tArena.chunks = vector.New[*typedChunk[T]]()
 
 	firstChunk := newChunk[T](chunkSize)
 	tArena.chunks.Push(firstChunk)
@@ -86,5 +91,5 @@ func (ta *TypedArena[T]) Free() {
 		c.Free()
 	}
 	ta.chunks.Free()
-	Free(ta)
+	mm.Free(ta)
 }

typed_arena.go typedarena/typed_arena.go

@@ -1,15 +1,16 @@
-package mm
+package typedarena_test
 
 import (
 	"testing"
 
+	"github.com/joetifa2003/mm-go/typedarena"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestTypedArena(t *testing.T) {
 	assert := assert.New(t)
 
-	arena := NewTypedArena[int](4)
+	arena := typedarena.New[int](4)
 	defer arena.Free()
 
 	int1 := arena.Alloc()      // allocates 1 int from arena