vector.h

Go to the documentation of this file.

#ifndef VECTOR_H
#define VECTOR_H

#include <fstream>
#include <sstream>

#include <iostream>
#include <cstdlib>
#include <vector>
#include <assert.h>
#include <algorithm>

#include <map>

#include <starpu.h>

#include "skepu/src/debug.h"
#include "skepu/src/malloc_allocator.h"



namespace skepu
{
template <typename T>
class Vector
{
    //-- For Testing --//

    friend std::ostream& operator<< (std::ostream& output, Vector<T>& vec)
    {
        vec.acquireRead();
        
        for(unsigned int i = 0; i < vec.size(); ++i)
        {
            output<<vec.at(i) <<" ";
        }

        return output;
    }

public: //-- For Testing --//

    void randomize(int min = 0, int max = RAND_MAX)
    {
        unregisterVector(false);

        for(unsigned int i = 0; i < m_data.size(); i++)
        {
            m_data.at(i) = (T)( rand() % max + min );
        }
    }

    void save(const std::string& filename)
    {
        std::ofstream file(filename.c_str());

        if (file.is_open())
        {
            for(unsigned int i = 0; i < size(); ++i)
            {
                file<<at(i) <<" ";
            }
            file.close();
        }
        else
        {
            std::cout<<"Unable to open file\n";
        }
    }

    void load(const std::string& filename, int numElements = 0)
    {
        std::ifstream file(filename.c_str());

        if (file.is_open())
        {
            std::string line;
            getline (file,line);
            std::istringstream ss(line);
            T num;
            clear();

            //Load all elements
            if(numElements == 0)
            {
                while(ss >> num)
                {
                    push_back(num);
                }
            }
            // Load only numElements elements
            else
            {
                for(int i = 0; i < numElements; ++i)
                {
                    ss >> num;
                    push_back(num);
                }
            }

            file.close();
        }
        else
        {
            std::cout<<"Unable to open file\n";
        }
    }
    
private: // Helper methods
    
    void release_acquire()
    {
        if(isAcquire)
        {
            if(parts>1) // partitioning
            {
                DEBUG_TEXT_LEVEL1("*****  VECTOR RELEASE **** parts: "<< parts <<"\n")
//              int parts = starpu_data_get_nb_children(vector_handle);

                // parts should be equal to what parts variable points to
                assert (parts == starpu_data_get_nb_children(vector_handle));
                for (int x = 0; x < parts; x++) 
                {
                    starpu_data_release(starpu_data_get_sub_data(vector_handle, 1, x));
                }
            }
            else // no partitioning
            {
                DEBUG_TEXT_LEVEL1("*****  VECTOR RELEASE ****\n")
                starpu_data_release(vector_handle);
            }
            isAcquire = false;
        }
    }

public: 

// StaPU specific data handler and other information
starpu_data_handle_t vector_handle;
mutable int parts;
mutable bool isOnStarPU;
mutable bool isAcquire;
mutable bool isReadBack;
mutable bool isWriteBack;
struct starpu_data_filter vector_filter;
mutable enum starpu_data_access_mode mode;
            

//enum starpu_data_access_mode accessMode;

/*
* \brief To register Vector with StarPU runtime. Does not create partitions
*/
starpu_data_handle_t registerVector()
{
    // release acquire before giving vector handle
    release_acquire();
        
    if(!isOnStarPU)
    {
        starpu_vector_data_register(&vector_handle, 0, (uintptr_t)&m_data[0], m_data.size(), sizeof(m_data[0]));
        isOnStarPU=true;
        DEBUG_TEXT_LEVEL1("*****  VECTOR REGISTERING **** "<< m_data.size()<<"\n")
    }
    if(parts>1)
    {
        starpu_data_unpartition(vector_handle, 0); // unpartitioning vector.
        DEBUG_TEXT_LEVEL1("*****  VECTOR UN-PARTITIONING **** parts: "<< parts <<"\n")
        parts=1;
    }
    return vector_handle;
}



void unregisterVector(bool update=true)
{
    if(isOnStarPU)
    {
        release_acquire(); // Should we release before unregister? Yes!
            
        if(parts>1) // do we need to unpartition before unregistering? Yes!
        {
            starpu_data_unpartition(vector_handle, 0); // first unpartition the partitioning.       
            parts = 1;
        }
        
        if(update)  
            starpu_data_unregister(vector_handle);
            
        else // dont need to get updated data back
            starpu_data_unregister_no_coherency(vector_handle);
            
        isOnStarPU = false;
        isAcquire = false;      
    }
}

starpu_data_handle_t registerPartitions(int _parts)
{
    release_acquire();
        
    if(!isOnStarPU) // if not registered, register it first
    {
        starpu_vector_data_register(&vector_handle, 0, (uintptr_t)&m_data[0], m_data.size(), sizeof(m_data[0]));
        isOnStarPU=true;
        DEBUG_TEXT_LEVEL1("*****  VECTOR REGISTERING **** "<< m_data.size()<<"\n")
        parts=1;
    }
    
    if(_parts == parts)
        return vector_handle;
            
    if(parts>1)
    {
        starpu_data_unpartition(vector_handle, 0); // first unpartition previous partitioning.
        DEBUG_TEXT_LEVEL1("*****  VECTOR UNPARTITIONING **** parts: "<< parts <<"\n")
        parts = 1;
    }
    if(_parts>1)
    {   
        vector_filter.nchildren = _parts;
        starpu_data_partition(vector_handle, &vector_filter);
        DEBUG_TEXT_LEVEL1("*****  VECTOR PARTITIONING **** parts: "<< _parts <<"\n")
        parts = _parts;
    }

    return vector_handle;
}


    //-- Typedefs --//
#ifdef USE_PINNED_MEMORY
    typedef typename std::vector<T, malloc_allocator<T> >::size_type size_type;
    typedef typename std::vector<T, malloc_allocator<T> >::value_type value_type;
    typedef typename std::vector<T, malloc_allocator<T> >::difference_type difference_type;
    typedef typename std::vector<T, malloc_allocator<T> >::pointer pointer;
    typedef typename std::vector<T, malloc_allocator<T> >::reference reference;
    typedef typename std::vector<T, malloc_allocator<T> >::const_reference const_reference;
    typedef typename std::vector<T, malloc_allocator<T> >::const_iterator const_iterator;
    typedef typename std::vector<T, malloc_allocator<T> >::const_reverse_iterator const_reverse_iterator;
#else    
    typedef typename std::vector<T>::size_type size_type;
    typedef typename std::vector<T>::value_type value_type;
    typedef typename std::vector<T>::difference_type difference_type;
    typedef typename std::vector<T>::pointer pointer;
    typedef typename std::vector<T>::reference reference;
    typedef typename std::vector<T>::const_reference const_reference;
    typedef typename std::vector<T>::const_iterator const_iterator;
    typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
#endif


public: //-- Constructors & Destructor --//

    Vector();

    Vector(const Vector& vec);

    explicit Vector(size_type num, const T& val = T(), bool redVec = false);

    template<typename input_iterator>
    Vector(input_iterator start, input_iterator end);

    ~Vector();

public: //-- Member classes --//

    class iterator;

    //Use STL reverse iterator
    typedef std::reverse_iterator<iterator> reverse_iterator;

    class proxy_elem;

public: //-- Operators --//

    proxy_elem operator[](const size_type index);
    const T& operator[](const size_type index) const;
    Vector<T>& operator=(const Vector<T>& other);

    bool operator==(const Vector<T>& c1);
    bool operator!=(const Vector<T>& c1);
    bool operator<(const Vector<T>& c1);
    bool operator>(const Vector<T>& c1);
    bool operator<=(const Vector<T>& c1);
    bool operator>=(const Vector<T>& c1);

public: //-- STL vector regular interface --//

    T *getRawType() { return &m_data[0]; }
    

    //Iterators
    iterator begin();
    const_iterator begin() const;

    iterator end();
    const_iterator end() const;

    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const;

    reverse_iterator rend();
    const_reverse_iterator rend() const;


    //Capacity
    size_type capacity() const;

    size_type size() const;

    size_type max_size() const;

    void resize(size_type num, T val = T());

    bool empty() const;

    void reserve(size_type size);


    //Element access
    proxy_elem at(size_type loc);
    const T& at(size_type loc) const;

    proxy_elem back();
    const T& back() const;

    proxy_elem front();
    const T& front() const;


    //Modifiers
    void assign( size_type num, const T& val );

    template <typename input_iterator>
    void assign( input_iterator start, input_iterator end );

    void clear();

    iterator erase( iterator loc );
    iterator erase( iterator start, iterator end );

    iterator insert( iterator loc, const T& val );
    void insert( iterator loc, size_type num, const T& val );

    template <typename input_iterator>
    void insert( iterator loc, input_iterator start, input_iterator end );

    void pop_back();

    void push_back(const T& val);

    void swap(Vector<T>& from);

public: //-- Additions to interface --//

    void flush();

    // Does not care about device data, use with care
    T& operator()(const size_type index);

    // To be able to explicitly force updates without flushing entire vector.
    // Could be used with operator () above to avoid unneccesary function calls
    // due to implicit synch.
    void acquireRead() const;
    void acquireReadWrite();

private: //-- Data --//

// A custom memory allocator is written to support pinned memory allocation for CUDA. Enabled by defining USE_PINNED_MEMORY macro
#ifdef USE_PINNED_MEMORY
    mutable std::vector<T, malloc_allocator<T> > m_data;
#else
    mutable std::vector<T> m_data;
#endif
    
};

}

#include "src/vector_iterator.inl"
#include "src/vector_proxy.inl"
#include "src/vector.inl"


#endif