du1simd.hpp

/*
File: du1simd.hpp
Author: Tomas Volf NPRG051 2013/2014

Copyright 2014 Tomas Volf
*/

/*
simd_vector<T, S>
    T - logicky prvek kontejneru (jednoduchy datovy typ)
    S - typ reprezentujici K-tici prvku typu T
        K = sizeof(S) / sizeof(T) -- obvykle mocnina dvojky
        blok pameti lze chapat jako T[K*N] i S[N]

simd_vector<T, S>::simd_vector(size_t size)
    size - pocet prvku typu T

    - neni zvetsovani ani zmensovani
    - po vzniku neni inicializovan
    - size nemusi byt delitelne K

    - podpora move-constructor a move-assigment
    - neni podpora copy metod

    - vsechny pristupy na prvky typu S museji byt zarovnane
    - adresa delitelna sizeof(S)
*/

#include <iterator>
#include <cstdint>
#include <new>

// TODO(paladin): remove this
#include <iostream>

template< typename T, typename S>
class simd_vector;

template<typename T, typename S>
class simd_vector_iterator
    : public std::iterator<std::random_access_iterator_tag, T> {
    typedef
        typename simd_vector<T, S>::iterator
        self_type;
    typedef
        typename std::iterator<std::random_access_iterator_tag, T>::pointer
        pointer;
    typedef
        typename std::iterator<std::random_access_iterator_tag, T>::reference
        reference;
    typedef
        typename std::iterator<std::random_access_iterator_tag, T>::value_type
        value_type;
    typedef
        typename
            std::iterator<std::random_access_iterator_tag, T>::difference_type
        difference_type;
 public:
    simd_vector_iterator()
        : ptr_(nullptr) {}
    explicit simd_vector_iterator(pointer ptr)
        : ptr_(ptr) {}
    explicit simd_vector_iterator(const self_type & other)
        : ptr_(other.ptr_) {}
    explicit simd_vector_iterator(self_type && other)
        : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }

    self_type & operator=(const self_type & other) {
        ptr_ = other.ptr_;
    }

    bool operator==(const simd_vector_iterator & other) const {
        return ptr_ == other.ptr_;
    }

    bool operator!=(const simd_vector_iterator & other) const {
        return ptr_ != other.ptr_;
    }

    reference operator*() const {
        return *ptr_;
    }

    pointer operator->() const {
        return ptr_;
    }

    self_type operator++() {
        ptr_++;
        return this;
    }

    self_type operator++(int) {
        const self_type old(*this);
        ++*this;
        return old;
    }

    self_type operator--() {
        ptr_--;
        return this;
    }

    self_type operator--(int) {
        const self_type old(*this);
        --*this;
        return old;
    }

    self_type operator+(difference_type n) {
        return *this += n;
    }

    self_type operator-(difference_type n) {
        return *this -= n;
    }

    bool operator<(self_type & other) {
        return ptr_ < other.ptr_;
    }

    bool operator>(self_type & other) {
        return ptr_ > other.ptr_;
    }

    bool operator<=(self_type & other) {
        return ptr_ <= other.ptr_;
    }

    bool operator>=(self_type & other) {
        return ptr_ >= other.ptr_;
    }

    self_type operator+=(difference_type other) {
        return self_type(ptr_ + other);
    }

    self_type operator-=(difference_type other) {
        return self_type(ptr_ - other);
    }

    reference operator[](const difference_type& n) const {
        return ptr_[n];
    }

 private:
    pointer ptr_;
};

template< typename T, typename S>
simd_vector_iterator< T, S>
operator+(std::ptrdiff_t n, simd_vector_iterator< T, S> a) {
    return a += n;
}

template< typename T, typename S>
simd_vector_iterator< T, S>
operator-(std::ptrdiff_t n, simd_vector_iterator< T, S> a) {
    return a -= n;
}

/*...*/

template<typename T, typename S>
class simd_vector {
 public:
    typedef simd_vector_iterator<T, S> iterator;

    typedef /*...*/int simd_iterator;

    explicit simd_vector(std::size_t s) throw(std::bad_alloc) {
        pointer_to_allocated_memory_ =
            ::operator new(sizeof(T) * s + sizeof(S));

        uintptr_t pointer_to_allocated_memory =
            (uintptr_t) pointer_to_allocated_memory_;
        uintptr_t pointer_to_alligned_memory =
            pointer_to_allocated_memory + sizeof(S)
            - pointer_to_allocated_memory % sizeof(S);
        data_s_ = reinterpret_cast<S*>(pointer_to_alligned_memory);
        data_t_ = reinterpret_cast<T*>(pointer_to_alligned_memory);
    }

    ~simd_vector() {
        ::operator delete(pointer_to_allocated_memory_);
    }

    iterator begin() {
        iterator i(data_t_);
        return i;
    }

    iterator end() {
        /*...*/
    }

    std::size_t size() {
        return count_;
    }

    /*...*/

 private:
    void * pointer_to_allocated_memory_;
    std::size_t count_;
    S * data_s_;
    T * data_t_;
};