Randy-Jordan/mem
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Randy Jordan
2026-03-06 08:51:02 -06:00
commit 0c69151528
10 changed files with 502 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
LICENSE Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) [year] [fullname]
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

85
Makefile Normal file
View File

@@ -0,0 +1,85 @@
# Compiler Flags
CC := gcc
CFLAGS := -g -Wall -Wextra -Werror -pedantic -fno-omit-frame-pointer
export ASAN_OPTIONS = allocator_may_return_null=1
# Directory variables
LIBDIR := lib
OBJ := obj
INC := include
SRC := src
TEST := tests
# Filepath Pattern Matching
LIB := $(LIBDIR)/lib.a
SRCS := $(wildcard $(SRC)/*.c)
OBJS := $(patsubst $(SRC)/%.c, $(OBJ)/%.o, $(SRCS))
TESTS := $(wildcard $(TEST)/*.c)
TESTBINS := $(patsubst $(TEST)/%.c, $(TEST)/bin/%, $(TESTS))
# Commands must be labeled PHONY
.PHONY: all release clean test
# Compiler Release Flags
release: CFLAGS := -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined -fno-omit-frame-pointer -O2 -DNDEBUG
release: clean $(LIB)
# Target for compilation.
all: $(LIB)
# Target / Dependencies
$(LIB): $(OBJS) | $(LIBDIR)
$(RM) $(LIB)
ar -cvrs $@ $^
$(OBJ)/%.o: $(SRC)/%.c $(SRC)/%.h | $(OBJ)
$(CC) $(CFLAGS) -c $< -o $@
$(OBJ)/%.o: $(SRC)/%.c | $(OBJ)
$(CC) $(CFLAGS) -c $< -o $@
$(TEST)/bin/%: $(TEST)/%.c $(LIB) | $(TEST)/bin
$(CC) $(CFLAGS) $< $(LIB) -o $@
# Make directories if none.
$(LIBDIR):
mkdir $@
$(INC):
mkdir $@
$(OBJ):
mkdir $@
$(TEST)/bin:
mkdir $@
# Run the tests in the bin folder and track results
test: $(LIB) $(TESTBINS)
@SUCCESS=0; FAILURE=0; \
RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'; NC='\033[0m'; \
for t in $(TESTBINS); do \
NAME=$$(basename $$t); \
START=$$(date +%s%N); \
if $$t; then \
RET=0; \
else \
RET=$$?; \
fi; \
END=$$(date +%s%N); \
ELAPSED_NS=$$((END - START)); \
ELAPSED_MS=$$((ELAPSED_NS / 1000000)); \
if [ $$RET -eq 0 ]; then \
printf "%-20s %bPASS%b (%b%4d ms%b)\n" "$$NAME" "$$GREEN" "$$NC" "$$YELLOW" "$$ELAPSED_MS" "$$NC"; \
SUCCESS=$$((SUCCESS + 1)); \
else \
printf "%-20s %bFAIL%b (%b%4d ms%b)\n" "$$NAME" "$$RED" "$$NC" "$$YELLOW" "$$ELAPSED_MS" "$$NC"; \
FAILURE=$$((FAILURE + 1)); \
fi; \
done; \
printf "\nTests completed\n"; \
printf "SUCCESS: %b%d%b\n" "$$GREEN" "$$SUCCESS" "$$NC"; \
printf "FAILURE: %b%d%b\n" "$$RED" "$$FAILURE" "$$NC"; \
test $$FAILURE -eq 0
clean:
$(RM) -r $(LIBDIR) $(OBJ) $(TEST)/bin/

28
README.md Normal file
View File

@@ -0,0 +1,28 @@
# mem
## Description
Simple memory allocator written in C.
## Table of Contents
- [Description](#description)
- [Features](#features)
- [Usage](#usage)
- [Credits / Resources](#credits--resources)
- [License](#license)
## Features / TODOS
- [x] Try / Catch
- [x] Versatile Error Handling
## Usage
`make` to build.<br>
`make test` to build and run tests. ASAN allocator may fail option is turned on to showcase failure handling.<br>
## Credits / Resources
[Memory Allocation Strategies - Ginger Bill](https://www.gingerbill.org/series/memory-allocation-strategies/)<br>
[Arena allocator tips and tricks - Chris Wellons](https://nullprogram.com/blog/2023/09/27/)<br>
[C Interfaces and Implementations](https://github.com/drh/cii)<br>
## License
This project is licensed under MIT - see the [LICENSE](LICENSE) file for details.

107
include/except.h Normal file
View File

@@ -0,0 +1,107 @@
#ifndef EXCEPT_INCLUDED
#define EXCEPT_INCLUDED
#include <setjmp.h>
struct Exception {
const char *reason;
};
typedef struct Exception Exception;
struct Except_Frame {
struct Except_Frame *prev;
jmp_buf env;
const char *file;
int line;
const struct Exception *exception;
};
typedef struct Except_Frame Except_Frame;
enum { EXCEPT_STATE_ENTERED=0,
EXCEPT_STATE_RAISED,
EXCEPT_STATE_HANDLED,
EXCEPT_STATE_FINALIZED,
EXCEPT_STATE_COUNT};
extern struct Except_Frame *except_stack;
extern const struct Exception assertion_failed;
void except_raise(const Exception *e, const char *file, int line);
#undef assert
#ifdef NDEBUG
#define assert(e) ((void)0)
#else
extern void asserted(int e);
#define assert(e) ((void)((e)||(RAISE(assertion_failed),0)))
#endif
#ifdef WIN32
#include <windows.h>
extern DWORD except_index;
extern void except_init(void);
extern void except_push(Except_Frame *fp);
extern void except_pop(void);
#endif
#ifdef WIN32
#define RAISE(e) except_raise(&(e), __FILE__, __LINE__)
#define RERAISE except_raise(except_frame.exception, \
except_frame.file, except_frame.line)
#define RETURN switch (except_pop(),0) default: return
#define TRY do { \
volatile int except_flag; \
Except_Frame except_frame; \
if (except_index == -1) \
except_init(); \
except_push(&except_frame); \
except_flag = setjmp(except_frame.env); \
if (except_flag == EXCEPT_STATE_ENTERED) {
#define EXCEPT(e) \
if (except_flag == EXCEPT_STATE_ENTERED) except_pop(); \
} else if (except_frame.exception == &(e)) { \
except_flag = EXCEPT_STATE_HANDLED;
#define ELSE \
if (except_flag == EXCEPT_STATE_ENTERED) except_pop(); \
} else { \
except_flag = EXCEPT_STATE_HANDLED;
#define FINALLY \
if (except_flag == EXCEPT_STATE_ENTERED) except_pop(); \
} { \
if (except_flag == EXCEPT_STATE_ENTERED) \
except_flag = EXCEPT_STATE_FINALIZED;
#define END_TRY \
if (except_flag == EXCEPT_STATE_ENTERED) except_pop(); \
} if (except_flag == EXCEPT_STATE_RAISED) RERAISE; \
} while (0)
#else
#define RAISE(e) except_raise(&(e), __FILE__, __LINE__)
#define RERAISE except_raise(except_frame.exception, \
except_frame.file, except_frame.line)
#define RETURN switch (except_stack = except_stack->prev,0) default: return
#define TRY do { \
volatile int except_flag; \
Except_Frame except_frame; \
except_frame.prev = except_stack; \
except_stack = &except_frame; \
except_flag = setjmp(except_frame.env); \
if (except_flag == EXCEPT_STATE_ENTERED) {
#define EXCEPT(e) \
if (except_flag == EXCEPT_STATE_ENTERED) except_stack = except_stack->prev; \
} else if (except_frame.exception == &(e)) { \
except_flag = EXCEPT_STATE_HANDLED;
#define ELSE \
if (except_flag == EXCEPT_STATE_ENTERED) except_stack = except_stack->prev; \
} else { \
except_flag = EXCEPT_STATE_HANDLED;
#define FINALLY \
if (except_flag == EXCEPT_STATE_ENTERED) except_stack = except_stack->prev; \
} { \
if (except_flag == EXCEPT_STATE_ENTERED) \
except_flag = EXCEPT_STATE_FINALIZED;
#define END_TRY \
if (except_flag == EXCEPT_STATE_ENTERED) except_stack = except_stack->prev; \
} if (except_flag == EXCEPT_STATE_RAISED) RERAISE; \
} while (0)
#endif
#endif // except.h

31
include/mem.h Normal file
View File

@@ -0,0 +1,31 @@
#ifndef MEM_INCLUDED
#define MEM_INCLUDED
#include "except.h" // Exceptions
#include <stddef.h> // size_t
/* General Macros*/
#define MEM_KB(x) ((size_t)(x) * 1024ULL)
#define MEM_MB(x) ((size_t)(x) * 1024ULL * 1024ULL)
#define MEM_GB(x) ((size_t)(x) * 1024ULL * 1024ULL * 1024ULL)
#define MEM_SIZE(x) (ptrdiff_t)sizeof(x)
#define MEM_COUNT(a) (MEM_SIZE(a) / MEM_SIZE(*(a)))
#define MEM_LEN(s) (MEM_COUNT(s) - 1)
extern const Exception oom; // Out of memory
extern void *mem_alloc (size_t nbytes,const char *file, int line);
extern void *mem_calloc(size_t count, size_t nbytes, const char *file, int line);
extern void mem_free(void *ptr, const char *file, int line);
extern void *mem_resize(void *ptr, size_t nbytes, const char *file, int line);
#define ALLOC(nbytes) mem_alloc((nbytes), __FILE__, __LINE__)
#define CALLOC(count, nbytes) mem_calloc((count), (nbytes), __FILE__, __LINE__)
#define NEW(p) ((p) = ALLOC((size_t)sizeof *(p)))
#define NEW0(p) ((p) = CALLOC(1, (size_t)sizeof *(p)))
#define FREE(ptr) ((void)(mem_free((ptr), __FILE__, __LINE__), (ptr) = 0))
#define RESIZE(ptr, nbytes) ((ptr) = mem_resize((ptr), (nbytes), __FILE__, __LINE__))
#endif

82
src/except.c Normal file
View File

@@ -0,0 +1,82 @@
#include <stdlib.h>
#include <stdio.h>
#include "../include/except.h"
struct Except_Frame *except_stack = NULL;
const struct Exception assertion_failed = { "Assertion failed" };
void asserted(int e){
if(!e){
RAISE(assertion_failed);
}
}
void except_raise(const struct Exception *e, const char *file,int line)
{
#ifdef WIN32
Except_Frame *p;
if (except_index == TLS_OUT_OF_INDEXES)
except_init();
p = TlsGetValue(except_index);
#else
struct Except_Frame *p = except_stack;
#endif
asserted(e != NULL);
if (p == NULL) {
fprintf(stderr, "Uncaught exception");
if (e->reason)
fprintf(stderr, " %s", e->reason);
else
fprintf(stderr, " at 0x%p", (void*)e);
if (file && line > 0)
fprintf(stderr, " raised at %s:%d\n", file, line);
fprintf(stderr, "aborting...\n");
fflush(stderr);
abort();
}
p->exception = e;
p->file = file;
p->line = line;
#ifdef WIN32
except_pop();
#else
except_stack = except_stack->prev;
#endif
longjmp(p->env, EXCEPT_STATE_RAISED);
}
#ifdef WIN32
_CRTIMP void __cdecl _assert(void *, void *, unsigned);
#undef assert
#define assert(e) ((e) || (_assert(#e, __FILE__, __LINE__), 0))
DWORD except_index = -1;
void except_init(void) {
BOOL cond;
except_index = TlsAlloc();
assert(except_index != TLS_OUT_OF_INDEXES);
cond = TlsSetValue(except_index, NULL);
assert(cond == TRUE);
}
void except_push(Except_Frame *fp) {
BOOL cond;
fp->prev = TlsGetValue(except_index);
cond = TlsSetValue(except_index, fp);
assert(cond == TRUE);
}
void except_pop(void) {
BOOL cond;
Except_Frame *tos = TlsGetValue(except_index);
cond = TlsSetValue(except_index, tos->prev);
assert(cond == TRUE);
}
#endif

62
src/mem.c Normal file
View File

@@ -0,0 +1,62 @@
#include <stdlib.h>
#include <stddef.h>
#include "../include/except.h"
#include "../include/mem.h"
const struct Exception oom = { "Out of memory!" };
void *mem_alloc(size_t nbytes, const char *file, int line)
{
void *ptr;
assert(nbytes > 0);
ptr = malloc(nbytes);
if (ptr == NULL)
{
if (file == NULL)
RAISE(oom);
else
except_raise(&oom, file, line);
}
return ptr;
}
void *mem_calloc(size_t count, size_t nbytes, const char *file, int line)
{
void *ptr;
assert(count > 0);
assert(nbytes > 0);
ptr = calloc(count, nbytes);
if (ptr == NULL)
{
if (file == NULL)
RAISE(oom);
else
except_raise(&oom, file, line);
}
return ptr;
}
void mem_free(void *ptr, const char *file, int line)
{
(void) file;
(void) line;
if (ptr)
free(ptr);
}
void *mem_resize(void *ptr, size_t nbytes, const char *file, int line)
{
assert(ptr); // ?
assert(nbytes > 0);// ?
void *tmp = realloc(ptr, nbytes);
if (tmp == NULL)
{
if (file == NULL)
RAISE(oom);
else
except_raise(&oom, file, line);
}
ptr = tmp;
return ptr;
}

31
tests/01_malloc.c Normal file
View File

@@ -0,0 +1,31 @@
#define DEBUG
#include <stdlib.h>
#include <string.h>
#include "../include/mem.h"
int mem_is_zero(const void *ptr, size_t nbytes) {
assert(ptr);
assert(nbytes > 0);
static const unsigned char zero_block[1024] = {0};
while (nbytes >= sizeof(zero_block)) {
if (memcmp(ptr, zero_block, sizeof(zero_block)) != 0)
return 0;
ptr = (const unsigned char *)ptr + sizeof(zero_block);
nbytes -= sizeof(zero_block);
}
if (nbytes > 0 && memcmp(ptr, zero_block, nbytes) != 0)
return 0;
return 1;
}
int main(void){
size_t nbytes = 4096;
void *tmp = malloc(nbytes);
memset(tmp, 0xAB, nbytes);
free(tmp);
void *ptr = ALLOC(nbytes); // likely gets the same region back
assert(!mem_is_zero(ptr, nbytes)); // FAILS — 0xAB still there
assert(ptr != NULL);
return EXIT_SUCCESS;
}

27
tests/02_calloc.c Normal file
View File

@@ -0,0 +1,27 @@
#define DEBUG
#include <stdlib.h>
#include <string.h>
#include "../include/mem.h"
int mem_is_zero(const void *ptr, size_t nbytes) {
assert(ptr);
assert(nbytes > 0);
static const unsigned char zero_block[1024] = {0};
while (nbytes >= sizeof(zero_block)) {
if (memcmp(ptr, zero_block, sizeof(zero_block)) != 0)
return 0;
ptr = (const unsigned char *)ptr + sizeof(zero_block);
nbytes -= sizeof(zero_block);
}
if (nbytes > 0 && memcmp(ptr, zero_block, nbytes) != 0)
return 0;
return 1;
}
int main(void){
size_t nbytes = 4096;
void *ptr = CALLOC(1,nbytes);
assert(ptr != NULL);
assert( mem_is_zero(ptr, nbytes));
return EXIT_SUCCESS;
}

28
tests/03_exception.c Normal file
View File

@@ -0,0 +1,28 @@
#define DEBUG
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include "../include/mem.h"
int main(void){
size_t nbytes = MEM_GB(1024);
void *buf;
TRY {
buf = ALLOC(nbytes); /* try 1GB */
if (!buf)
RAISE(oom);
free(buf);
}
EXCEPT(oom) {
/* handle memory failure gracefully */
fprintf(stderr, "Caught: %s\n", oom.reason);
return EXIT_SUCCESS; /* requested behavior */
}
FINALLY {
/* cleanup if needed, runs always */
if (buf) free(buf);
}
END_TRY;
return EXIT_FAILURE; /* shouldn't reach here for this example */
}