HTTPS SSH

What is that?

This is the SLAB-like memory allocator for use in the user space applications. USlab stands for user space slab.

It is very portable and have no direct dependencies on the standard C library. It has been tested on Linux and Windows.

The technique itself is described in Bonwick94 and Bonwick01. The first one is absolutely must read if you want to write memory manager and it is recommended for better understanding of the ideas under USlab too.

This technique and its derivatives is widely used inside a OS kernels and as parts of the segregate user space memory allocators. It was first introduced in the SunOS 2.4 kernel.

The basic idea under it is that initialization of an object may be more costly than allocating memory for it, so it is worthwhile to keep some unused initialized objects for future use. So you ask a big chunk of the memory, split it into the smaller pieces and recycle them.

Basically, chunk can be called as slab, set of the slabs can be called a cache. Each slab is a few of the initialized objects.

Usage

USlab have a very simple API. It is described in the uslab.h. You need two files from the distribution: uslab.h and uslab.c. For usage examples see test.c file.

If you have special requirements (for example, you can't use standard C library), you need to specify few data types in the beginning of the uslab.h.

It should be stressed that it is not allocate memory directly from the OS. It means that you need to specify your functions for memory allocation and deallocation. It does not meaningful what upper lying allocator you will use - it can be simple wrappers on top of the C malloc()/free() or simple page supplier on top of the virtual memory API used in your OS. The following functions should be OK for you in most cases:

/* simple wrappers on top of the C library */
void *stdc_alloc_mem(size_t size, void *udata)
{
    /* NOTE: it should return NULL on error,
    /* just like malloc() does */
    return malloc(size);
}

void stdc_free_mem(void *p, void *udata)
{
    free(p);
}

Objects tagging

This allocator support objects tagging. You can assign to any slab cache integer value - a tag. All objects inside the slab cache share the same tag value.

Tag is a simple integer value. You can easily create them using enum in C/C++. It may be useful if you want to distinguish different object types (like in Lisp interpreter ;).

Memory usage and performance

Following the terminology given in the above noted papers USlab is the implementation of the large slabs, so for a small objects (up to 512 bytes) it can be not so effective as for large objects. But not go away!

It is generally as memory effective as any modern memory manager. Typically, any malloc() also allocates additionally 8-32 bytes per any allocation. USlab allocates additionally (roughly) 4-8 bytes (depending on the machine word size). So you will not waste too much.

If you need to allocate/deallocate objects often USlab can give you up to 30-40% (or even more) additional performance compared to raw allocation using malloc()/free(). When you want to allocate many objects and deallocate them all when they are became unneeded, you can just destroy the cache - it will twice faster then using standard malloc()/free() for each object (tested using glibc malloc()/free()).

I hope you will find it useful. Enjoy!

References