View spinlock_mutex.cpp
// ============================================================================ | |
// This code is in the Public Domain - I claim no copyrights over it. | |
// Use at your own leisure and risk. | |
// | |
// Compiled and tested with: | |
// c++ -std=c++11 -fno-exceptions -Wall -Wextra -pedantic -O3 spinlock_mutex.cpp | |
// ============================================================================ | |
#include <cassert> | |
#include <cstdio> |
View debug_allocator.hpp
// ================================================================================================ | |
// -*- C++ -*- | |
// File: debug_allocator.hpp | |
// Author: Guilherme R. Lampert | |
// Created on: 03/12/16 | |
// | |
// About: | |
// Virtual memory pages backed debug allocator. Aligns each memory allocation to one | |
// or more pages and adds an additional header and footer protected pages, ensuring that |
View template_method_specialization.cpp
// | |
// Overriding a member method of a template class/struct by defining a specialized implementation. | |
// | |
#include <cstdio> | |
#include <typeinfo> | |
template<typename T> | |
struct Foo | |
{ |
View data_race_detection.cpp
// | |
// Simple unique lock guard to detect concurrent access to unsynchronized global data. | |
// | |
// This can be a useful tool to debug data races and identify places where a mutex should | |
// be introduced. Once the race is fixed, you'll likely want to strip out this code... | |
// | |
// -------------------------------------------------------- | |
#include <atomic> |
View simple_heap.hpp
#pragma once | |
// ======================================================== | |
#include <algorithm> | |
#include <array> | |
#include <cstddef> | |
#include <cstdint> | |
#include <cstring> |
View in_place_function.hpp
#pragma once | |
// ============================================================================ | |
// About: | |
// std::function-like functor that has an inline buffer to store the | |
// callable object. It is guaranteed to never allocate. If the callable | |
// is too big, a static_assert is triggered. The size of the functor is | |
// defined as a template argument, so it can be of any size. It also doesn't | |
// use C++ exceptions. | |
// |
View lockless_hash_table.cpp
// License: | |
// Public Domain. Feel free to copy, distribute, and modify this file as you see fit. | |
#include <cassert> | |
#include <cstddef> | |
#include <cstdint> | |
#include <cstdio> | |
#include <array> | |
#include <atomic> |
View tiny_allocator.cpp
// | |
// Simple allocator for small memory blocks (from 1 to 255 bytes). | |
// It keeps freelists of small blocks, built on top of 8K pages. | |
// The allocator only grows - empty pages are never freed back | |
// to the system. | |
// | |
// This allocator could easily be made lockless with atomic freelists. | |
// | |
#include <cstdint> |
View mini_heap_allocator.cpp
// | |
// General purpose minimal heap allocator. | |
// | |
// Keeps a freelist of chunks of arbitrary size. First round of allocations | |
// will use the whole heap block before it starts going into the freelist. | |
// Freeing just pushes the block back into the freelist and is constant time. | |
// Allocating might search the freelist if the whole heap was already allocated | |
// once. | |
// | |
// To reduce fragmentation we could merge free nodes either on free or allocate. |
View memory_pools.hpp
// ================================================================================================ | |
// -*- C++ -*- | |
// File: memory_pools.hpp | |
// Author: Guilherme R. Lampert | |
// Created on: 08/02/17 | |
// | |
// About: | |
// Useful templated memory pools of objects (header only). | |
// This file provides a DynamicPool and a pair of FixedSizePools, |
OlderNewer