https://github.com/rajamukherji/ramp
Raja's Attempt at a Memory Pool
https://github.com/rajamukherji/ramp
memory-management pool-allocator
Last synced: 26 days ago
JSON representation
Raja's Attempt at a Memory Pool
- Host: GitHub
- URL: https://github.com/rajamukherji/ramp
- Owner: rajamukherji
- License: mit
- Created: 2018-08-19T13:24:41.000Z (over 7 years ago)
- Default Branch: master
- Last Pushed: 2024-01-03T04:06:35.000Z (over 2 years ago)
- Last Synced: 2024-01-03T05:27:31.751Z (over 2 years ago)
- Topics: memory-management, pool-allocator
- Language: C
- Size: 61.5 KB
- Stars: 0
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Ramp
Raja's Attempt at a Memory Pool
## About
`ramp` is a very simple library which provides a non-threadsafe memory pool.
It is designed to be used in event based applications written in C, and allows memory to be allocated easily within an event and then freed automatically at the end of the event.
Each `ramp_t` object keeps track of a linked list of pages of memory, with the page size specified at `ramp_t` construction.
Memory can be allocated from a `ramp_t` object using `ramp_alloc`.
## Building
Building `ramp` requires [`rabs`](http://github.com/wrapl/rabs).
```
$ git clone https://github.com/rajamukherji/ramp
$ cd ramp
$ rabs
```
## Usage
If the request block of memory is too big to fit into a single page, then an external block of memory is allocated, but still tracked within the `ramp_t`.
At the beginning of each handling each event, allocated a new `ramp_t` object by calling `ramp_new(size_t PageSize)`.
The `PageSize` argument to `ramp_new` sets the size of each new page.
```c
ramp_t *Ramp = ramp_new(512);
```
During the event handling, any number of memory blocks can be allocated using `ramp_alloc(ramp_t *Ramp, size_t Size)`.
```c
char *Buffer = ramp_alloc(Ramp, 128);
```
Finally, after the event is handled, all of the memory allocated with the `ramp_t` instance can be freed using `ramp_clear(ramp_t *Ramp)`.
```c
ramp_clear(Ramp);
```
If additional cleanup is required when `ramp_clear()` is called, `ramp_defer(ramp_t *Ramp, size_t Size, void (*CleanupFn)(void *))` can be used instead of `ramp_alloc()`. `CleanupFn()` will be called with the returned pointer when `ramp_clear()` is called.
```c
void object_cleanup(struct object_t *Object) {
// clean up code
}
struct object_t *Object = (object_t *)ramp_defer(Ramp, sizeof(object_t), object_cleanup);
```
The `ramp_t` instance can be reused if required.
When the `ramp_t` instance is no longer required, it can be freed with `ramp_free(ramp_t *Ramp)`.
```c
ramp_free(Ramp);
```