cache_manager.h

#pragma once
 
#include "definitions_cxx.hpp"
#include "etl/intrusive_list.h"
#include "memory/stealable.h"
#include "util/misc.h"
#include <array>
#include <cstddef>
 
class MemoryRegion;
 
class CacheManager {
    using list_type = etl::intrusive_list<Stealable, Stealable::link_type>;
 
public:
    CacheManager() = default;
 
    list_type& queue(StealableQueue destination) { return reclamation_queue_.at(util::to_underlying(destination)); }
 
    uint32_t& longest_runs(size_t idx) { return longest_runs_.at(idx); }

    void QueueForReclamation(StealableQueue queue, Stealable& stealable) {
        size_t q = util::to_underlying(queue);

        reclamation_queue_[q].push_back(stealable);
        longest_runs_[q] = 0xFFFFFFFF; // TODO: actually investigate neighbouring memory "run".
    }
 
    uint32_t ReclaimMemory(MemoryRegion& region, int32_t totalSizeNeeded, void* thingNotToStealFrom,
                           int32_t* __restrict__ foundSpaceSize);
 
private:
    std::array<list_type, kNumStealableQueue> reclamation_queue_;
 
    // Keeps track, semi-accurately, of biggest runs of memory that could be stolen. In a perfect world, we'd have a
    // second index on stealableClusterQueues[q], for run length. Although even that wouldn't automatically reflect
    // changes to run lengths as neighbouring memory is allocated.
    std::array<uint32_t, kNumStealableQueue> longest_runs_;
};