C++ Internals

Custom Allocator

Difficulty

Asked at Hudson River Trading, Jump Trading

Read the problem, hints and solution here. The editor needs a bigger screen: open this page on a laptop to write and run your code.

xxxxxxx-xxxxxxxxx xxxx xxxx xxx xxxx xxxxxx xxxxx xxxxxxx: xxx xxxxxxx xxxxxxxxx xxxxx xxxxx, xxxxxxx xxxx xxxxxxxx, xxx xxxxxxxxxxxx xxxx xxx xxxxxx xxx xxxxx, xx xxx xxxxx xxxx xx xxxxxxxxx. xxx xxxxxxxx xxxx xx x xxxx: xxxx xxx xxxxx xx xxxxx, xxxxx xx xxxx xxxxx-xxxx xxxxxx, xxx xxxxx xxxxxxxx/xxxxxxxxxx xxxx xx xxxxxxxxx xxxx xxxx xx x(x) xxxx xxxx xxxxxx xxxxx.

xxxxxxxxx xxxxxxxxxxxxx<x, xxxxxxxxxx>, x xxxxxxxx-xxxxxxx-xxxxxxxxxx xxxxxxxxx xxxxxxx xxxxxx-xxxxxx xxxxxx:

xxx xxxxx, xxxxxxxx xxxx. xxx xxx xxxxxx xxxxx xxxx xxx xxxxxxxx xxxxxxxx::xxxxxxx(xxxxx), xx xxxxxxx xxx xxxx xxx xxxx xxxxxxxxxxxxx, xxxx xx xxxxx xxxx xxx xxxxx xxxxxxxx. xxx xxxxxxxxxxxxxxx xxxxxx xxxxx; xxx-xxxxx xxxxxxxx xxxxx xxxx.
xxxxxxxx(x) xxxxxxx x xxxx xxxxx: xxxx xxx xxxx xxxx xx xxx xxxxx xxx xxxx xxxxx (xxxx: xxx xxxx xxxxxxxx xxxxx xxxxx xx xxxxxxxx xxxxx), xxxxxxxxx xxx xxxx xxxxx-xxxx xxxxx xxxxxx xxxx xxx xxxxx. xxxx xxx xxxxxxxxxx xxxxxx xxx xxxx, xxxxx xxx::xxx_xxxxx. xxxxxxxx(x) xxx x != x xxxx xxxxxx xxx::xxx_xxxxx: xxxx xxxx xxxxxx xxxx xxxxxxxxxx, xxxxx xxxx xxxx xxxxxxxx xxx xxxx xx x xxxx.
xxxxxxxxxx(x, x) xxxxxx xxx xxxxx xxxx xxx xxxx xxxx. xxxxx xxx xxxx-xxxx xxxx-xxxxxxx xxxxxx xxx xxxxx xxxxx (xxxx xx xxx xxx xxxxx xxxxxx xxxx xx xx xxxxx xxxxxx(xxxx*) xxx xxxxxxx xxx xxxx x xxx xxxx*).
xxxxxxxxx-xxxxx. xxx xxxxxxxxxxx xx xxxxxxxx: xxxxx_xxxx, x xxxxxx (xxxxxxxx xxxxxxx xx xxx xxx-xxxx xxxxxxxxxx xxxxxxxxx), xxxxxxxxxx xxxxxxxxxxx xxx xxxxxxxx xxxxxxxxx. xxxx xxxxx xxxx xx xxxxxx xxx xxxxxxxxxxxxx xx xxxxxxx xxxxxxxx xxx xxxxxx xxxxx xxx xxxx. x xxxxxx xxxx xxxx xxx::xxxx<xxxx xxxx, xxxxxxxxxxxxx<xxxx xxxx, xxxxx>> xxxxxxx xxx xxxxxxxxxx xxx xxxxxx xxx xxxxxxxx xxxxx xxxxxx xx xxx xx xxx xxxxx.

xxxxxxxx

[]{ xxxxxxxx::xxxxx_xxxxxxxx(); xxxxxxxxxxxxx<xxx, xx> xxxx; xxx* x = xxxx.xxxxxxxx(x); xxx* x = xxxx.xxxxxxxx(x); *x = xx; *x = xx; xxxx xxxx xxx = *x + *x; xxxx.xxxxxxxxxx(x, x); xxxx.xxxxxxxxxx(x, x); xxxxxx xxx::xxxx<xxxx xxxx, xxxx xxxx>(xxx, xxxxxxxx::xxxxx()); }()
// (xx, x)  (xxx xxxxxx xxxxxx, xxxxx xxxxxxx xxxxxxx xxxx)

[]{ xxxxxxxxxxxxx<xxx, x> xxxx; xxx* x = xxxx.xxxxxxxx(x); xxx* x = xxxx.xxxxxxxx(x); xxxx.xxxxxxxxxx(x, x); xxx* x = xxxx.xxxxxxxx(x); xxxx xxxxxx = (x == x); xxxx.xxxxxxxxxx(x, x); xxxx.xxxxxxxxxx(x, x); xxx* x = xxxx.xxxxxxxx(x); xxxx xxxx = (x == x); xxxx.xxxxxxxxxx(x, x); xxxxxx xxx::xxxx<xxxx, xxxx>(xxxxxx, xxxx); }()
// (xxxx, xxxx)  (xxx xxxx xxxxxxxx xxxxx xxxxx xx xxxxxx xxxxxx xxxx)

xxxxxxxxxxx

xx xxx xxxxxx xxx xxxxxxxx xxxxxxxxxxxxxxx xx xxx xxxxxxxx xxxxxxxxx xxxxxxxxxxx; xxxxxxxxx xxxxxxxx xxx xxxxxxxxxx (xxxx xxx xxxxxxx xxxxxx xxxxx).
xx xxx, xxxxxx, xx xxx xxxxxxxxxx xxxxxx xxxxx xxxx xxxxxxxx::xxxxxxx.
xxxxxxxx/xxxxxxxxxx xxxx xx x(x); x xxxxxx xxxx xxxxxx xxx,xxx xxxxx/xxxx xxxxxx xxxxxxx x x-xxxxx xxxx xxx xxxxxxx xxx xxxxxxxx xxxx xxxxx.
xxxxxxxxxx xx xx xx,xxx; x xx x xxxxxx xx x xxxxxxxxx'x xxxx xxxx.

This problem is only available to subscribers.

Language: C++PoolAllocator

#include <cstddef>
#include <list>
#include <new>

// ...
// ...
// ...
// ...
// ...
// ...
namespace upstream {

inline long long& call_counter() { static long long c = 0; return c; }

inline void* acquire(std::size_t bytes) {
    static unsigned char arena[4 * 1024 * 1024];
    static std::size_t used = 0;
    ++call_counter();
    const std::size_t align = alignof(std::max_align_t);
    used = (used + align - 1) / align * align;
    if (used + bytes > sizeof(arena)) throw std::bad_alloc();
    void* p = arena + used;
    used += bytes;
    return p;
}

inline long long calls() { return call_counter(); }
inline void reset_counters() { call_counter() = 0; }

}  // ...

// ...
// ...
// ...
// ...
// ...
// ...
// ...
template <typename T, std::size_t BlockCount>
class PoolAllocator {
public:
    using value_type = T;

    template <typename U>
    struct rebind {
        using other = PoolAllocator<U, BlockCount>;
    };

    PoolAllocator() noexcept = default;
    template <typename U>
    PoolAllocator(const PoolAllocator<U, BlockCount>&) noexcept {}

    T* allocate(std::size_t n) {
        // ...
        // ...
        // ...
        (void)n;
        throw std::bad_alloc();
    }

    void deallocate(T* p, std::size_t n) noexcept {
        // ...
        (void)p;
        (void)n;
    }

    template <typename U>
    bool operator==(const PoolAllocator<U, BlockCount>&) const noexcept { return true; }
    template <typename U>
    bool operator!=(const PoolAllocator<U, BlockCount>&) const noexcept { return false; }

private:
    // ...
    // ...
    // ...
    // ...
};

Unlock to runUpgrade

Sample tests

Unlock the problem to run it against the tests.

Next in Quant Dev 50Producer-Consumer With Condition VariablesConcurrency