https://github.com/smasher164/mem

A memory allocator for Go.
https://github.com/smasher164/mem

Last synced: about 2 months ago
JSON representation

A memory allocator for Go.

• Host: GitHub
• URL: https://github.com/smasher164/mem
• Owner: smasher164
• License: 0bsd
• Created: 2019-06-05T19:50:41.000Z (over 5 years ago)
• Default Branch: master
• Last Pushed: 2020-03-11T20:00:57.000Z (almost 5 years ago)
• Last Synced: 2024-11-08T22:36:44.193Z (about 2 months ago)
• Language: Go
• Size: 16.6 KB
• Stars: 81
• Watchers: 3
• Forks: 5
• Open Issues: 2
• Metadata Files:
  • Readme: README.md
  • License: LICENSE.md

Awesome Lists containing this project

README

        
# mem

[![Documentation](https://img.shields.io/badge/%E2%80%8B-reference-007d9c?logo=go&logoColor=white)](https://pkg.go.dev/github.com/smasher164/mem)

[![Build Status](https://travis-ci.org/smasher164/mem.svg?branch=master)](https://travis-ci.org/smasher164/mem)

Package mem implements a memory allocator and deallocator.

It currently uses mmap on unix and VirtualAlloc on windows

to request pages of memory from the operating system, and

munmap and VirtualFree to release pages of memory to the

operating system. The allocator uses a first-fit algorithm

on a singly-linked free list of blocks. Blocks are divided

into sets called arenas, which correspond to the chunk of

memory mapped from the operating system. When all of the

blocks in a set are freed, the arena is unmapped.

```

// Alloc allocates size bytes of memory, and returns a pointer to it.

// It is goroutine-safe and attempts to preserve the semantics of

// POSIX libc's malloc. However, Alloc panics if an error occurs when

// requesting more memory from the operating system.

func Alloc(size uint) unsafe.Pointer

// Free deallocates the memory pointed to by p. It is goroutine-safe

// and attempts to preserve the semantics of POSIX libc's free.

// However, Free panics if an error occurs when releasing memory to

// the operating system.

func Free(p unsafe.Pointer)

```

### Why?

I am working on a rudimentary language interpreter for which I want

to implement my own garbage collection algorithm in Go. Also, this

is a good opportunity for me to brush up on memory allocation

techniques.

### Should I use this?

If you want to? ¯\\\_(ツ)\_/¯ It's passed all the tests I've run so far.

But don't hold me liable if your multi-million dollar production

workload comes crashing down! Instead, file an issue. :)

### What can I do to help?

Why thank you for offering! I am really interested in exploring

more efficient memory allocation techniques, like using a

best-fit algorithm, using a doubly-linked list for constant-time

cleanup, segregated lists to divide allocations of different

size classes, and buddy allocation. I would also like to improve

test quality by testing edge cases and platform-specific eccentricities.