Vector.h

/*****************************************************************************
 * Copyright (c) 2011-2012 The SkelCL Team as listed in CREDITS.txt          *
 * http://skelcl.uni-muenster.de                                             *
 *                                                                           *
 * This file is part of SkelCL.                                              *
 * SkelCL is available under multiple licenses.                              *
 * The different licenses are subject to terms and condition as provided     *
 * in the files specifying the license. See "LICENSE.txt" for details        *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 * SkelCL is free software: you can redistribute it and/or modify            *
 * it under the terms of the GNU General Public License as published by      *
 * the Free Software Foundation, either version 3 of the License, or         *
 * (at your option) any later version. See "LICENSE-gpl.txt" for details.    *
 *                                                                           *
 * SkelCL is distributed in the hope that it will be useful,                 *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * GNU General Public License for more details.                              *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 * For non-commercial academic use see the license specified in the file     *
 * "LICENSE-academic.txt".                                                   *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 * If you are interested in other licensing models, including a commercial-  *
 * license, please contact the author at michel.steuwer@uni-muenster.de      *
 *                                                                           *
 *****************************************************************************/


#ifndef VECTOR_H_
#define VECTOR_H_

#include <map>
#include <memory>
#include <string>
#include <vector>

#define __CL_ENABLE_EXCEPTIONS
#include <CL/cl.hpp>
#undef  __CL_ENABLE_EXCEPTIONS

#include "detail/CopyDistribution.h"
#include "detail/Device.h"
#include "detail/DeviceBuffer.h"
#include "detail/Distribution.h"

namespace skelcl {

namespace detail {

  class Event;

  class Sizes {
  public:
    Sizes() : _sizes() {}
    void push_back(detail::DeviceBuffer::size_type size) {
      _sizes.push_back(size);
    }

    cl_uint operator[](size_t index) const {
      return static_cast<cl_uint>(_sizes[index]);
    }
  private:
    std::vector<detail::DeviceBuffer::size_type> _sizes;
  };

} // namespace detail


template <typename T>
class RegisterVectorDeviceFunctions {
public:
  RegisterVectorDeviceFunctions();
};


template <typename T>
class Vector {
public:
  typedef std::vector<T> host_buffer_type;
  typedef typename host_buffer_type::value_type value_type;
  typedef typename host_buffer_type::pointer pointer;
  typedef typename host_buffer_type::const_pointer const_pointer;
  typedef typename host_buffer_type::reference reference;
  typedef typename host_buffer_type::const_reference const_reference;
  typedef typename host_buffer_type::iterator iterator;
  typedef typename host_buffer_type::const_iterator const_iterator;
  typedef typename host_buffer_type::reverse_iterator reverse_iterator;
  typedef typename host_buffer_type::const_reverse_iterator
          const_reverse_iterator;
  typedef typename host_buffer_type::size_type size_type;
  typedef typename host_buffer_type::difference_type difference_type;
  typedef typename host_buffer_type::allocator_type allocator_type;

  Vector();

  Vector(const size_type size, const value_type& value = value_type(),
         const detail::Distribution<Vector<T>>& distribution =
             detail::Distribution<Vector<T>>());

  template <class InputIterator>
  Vector(InputIterator first, InputIterator last);
  
  template <class InputIterator>
  Vector(InputIterator first, InputIterator last,
         const detail::Distribution<Vector<T>>& distribution);

  Vector(const Vector<T>& rhs);

  Vector(Vector<T>&& rhs);

  Vector<T>& operator=(const Vector<T>& rhs);

  Vector<T>& operator=(Vector<T>&& rhs);

  ~Vector();

  iterator begin();

  const_iterator begin() const;

  iterator end();

  const_iterator end() const;

#if 0
  reverse_iterator rbegin();

  const_reverse_iterator rbegin() const;

  reverse_iterator rend();

  const_reverse_iterator rend() const;
#endif

  size_type size() const;

  detail::Sizes sizes() const;

  size_type max_size() const;

  void resize( size_type count, T value = T() );

  size_type capacity() const;

  bool empty() const;

  void reserve( size_type n );

  reference operator[]( size_type pos );

  const_reference operator[]( size_type pos ) const;

  reference at( size_type pos );

  const_reference at( size_type pos ) const;

  reference front();

  const_reference front() const;

  reference back();

  const_reference back() const;

  template <class InputIterator>
  void assign(InputIterator first, InputIterator last);

  void assign(size_type count, const T& value);

  void push_back(const T& value);

  void pop_back();

  iterator insert(iterator pos, const T& value);

  iterator insert( iterator pos, size_type count, const T& value );

  template <class InputIterator>
  void insert(iterator pos, InputIterator first, InputIterator last);

  iterator erase(iterator pos);

  iterator erase(iterator first, iterator last);

  void swap( Vector<T>& rhs );

  void clear();

  detail::Distribution<Vector<T>>& distribution() const;

  template <typename U>
  void setDistribution(const detail::Distribution<Vector<U>>& distribution)
      const;

  template <typename U>
  void setDistribution(const std::unique_ptr<detail::Distribution<Vector<U>>>&
                           distribution) const;

  void setDistribution(
      std::unique_ptr<detail::Distribution<Vector<T>>>&& distribution) const;

  void createDeviceBuffers() const;

  //
  void forceCreateDeviceBuffers() const;

  detail::Event startUpload() const;

  void copyDataToDevices() const;

  detail::Event startDownload() const;

  void copyDataToHost() const;

  void dataOnDeviceModified() const;

  void dataOnHostModified() const;

  bool hostIsUpToDate() const;

  bool devicesAreUpToDate() const;

  const detail::DeviceBuffer& deviceBuffer(const detail::Device& device) const;

  detail::DeviceBuffer& deviceBuffer(const detail::Device& device);

  host_buffer_type& hostBuffer() const;

  static std::string deviceFunctions();

private:
  std::string getInfo() const;

  std::string getDebugInfo() const;

  static RegisterVectorDeviceFunctions<T> registerVectorDeviceFunctions;

          size_type                                   _size;
  mutable
    std::unique_ptr<detail::Distribution<Vector<T>>>  _distribution;
  mutable bool                                        _hostBufferUpToDate;
  mutable bool                                        _deviceBuffersUpToDate;
  mutable host_buffer_type                            _hostBuffer;
  // _deviceBuffers empty => buffers not created yet
  mutable std::map< detail::Device::id_type,
                    detail::DeviceBuffer >            _deviceBuffers;
};

template <typename T>
RegisterVectorDeviceFunctions<T> Vector<T>::registerVectorDeviceFunctions;

} // namespace skelcl

#include "detail/VectorDef.h"

#endif // VECTOR_H_