SparseSlabFactory.hpp

Go to the documentation of this file.

#ifndef TATAMI_CHUNKED_SPARSE_SLAB_FACTORY_HPP
#define TATAMI_CHUNKED_SPARSE_SLAB_FACTORY_HPP
 
#include "SlabCacheStats.hpp"
#include "utils.hpp"
 
#include <vector>
#include <cstddef>
 
#include "sanisizer/sanisizer.hpp"
 
namespace tatami_chunked {
 
template<typename Value_, typename Index_, typename Count_ = Index_>
class SparseSlabFactory {
private:
    Index_ my_target_dim, my_non_target_dim;
    bool my_needs_value, my_needs_index;
 
    // Might as well use size_t here, as we'll be doing pointer arithmetic in create().
    std::size_t my_slab_size;
    std::size_t my_offset_number = 0;
    std::size_t my_offset_slab = 0;
 
    std::vector<Value_> my_value_pool;
    std::vector<Index_> my_index_pool;
    std::vector<Count_> my_number_pool;
 
public:
    template<typename MaxSlabs_>
    SparseSlabFactory(Index_ target_dim, Index_ non_target_dim, std::size_t slab_size, MaxSlabs_ max_slabs, bool needs_value, bool needs_index) : 
        my_target_dim(target_dim),
        my_non_target_dim(non_target_dim),
        my_needs_value(needs_value),
        my_needs_index(needs_index),
        my_slab_size(slab_size),
        my_number_pool(sanisizer::product<I<decltype(my_number_pool.size())> >(max_slabs, target_dim))
    {
        if (needs_value) {
            my_value_pool.resize(sanisizer::product<I<decltype(my_value_pool.size())> >(max_slabs, slab_size));
        }
        if (needs_index) {
            my_index_pool.resize(sanisizer::product<I<decltype(my_index_pool.size())> >(max_slabs, slab_size));
        }
    }
 
    template<typename MaxSlabs_>
    SparseSlabFactory(Index_ target_dim, Index_ non_target_dim, MaxSlabs_ max_slabs, bool needs_value, bool needs_index) : 
        SparseSlabFactory(target_dim, non_target_dim, sanisizer::product<std::size_t>(target_dim, non_target_dim), max_slabs, needs_value, needs_index) {}
 
    template<typename MaxSlabs_>
    SparseSlabFactory(Index_ target_dim, Index_ non_target_dim, const SlabCacheStats<MaxSlabs_>& stats, bool needs_value, bool needs_index) : 
        SparseSlabFactory(target_dim, non_target_dim, stats.slab_size_in_elements, stats.max_slabs_in_cache, needs_value, needs_index) {}
 
    // Delete the copy constructors as we're passing out pointers.
    SparseSlabFactory(const SparseSlabFactory&) = delete;
    SparseSlabFactory& operator=(const SparseSlabFactory&) = delete;
 
    // Move constructors are okay though.
    SparseSlabFactory(SparseSlabFactory&&) = default;
    SparseSlabFactory& operator=(SparseSlabFactory&&) = default;
public:
    struct Slab {
        std::vector<Value_*> values;
 
        std::vector<Index_*> indices;
 
        Count_* number = NULL;
    };
 
    Slab create() {
        Slab output;
        output.number = my_number_pool.data() + my_offset_number;
        my_offset_number += my_target_dim;
 
        if (my_needs_value) {
            output.values.reserve(my_target_dim);
            auto vptr = my_value_pool.data() + my_offset_slab;
            for (I<decltype(my_target_dim)> p = 0; p < my_target_dim; ++p, vptr += my_non_target_dim) {
                output.values.push_back(vptr);
            }
        }
 
        if (my_needs_index) {
            output.indices.reserve(my_target_dim);
            auto iptr = my_index_pool.data() + my_offset_slab;
            for (I<decltype(my_target_dim)> p = 0; p < my_target_dim; ++p, iptr += my_non_target_dim) {
                output.indices.push_back(iptr);
            }
        }
 
        my_offset_slab += my_slab_size;
        return output;
    }
};
 
}
 
#endif