/build/buildd/viennacl-1.1.2/viennacl/tools/entry_proxy.hpp

Go to the documentation of this file.

/* =======================================================================
   Copyright (c) 2010, Institute for Microelectronics, TU Vienna.
   http://www.iue.tuwien.ac.at
                             -----------------
                     ViennaCL - The Vienna Computing Library
                             -----------------
                            
   authors:    Karl Rupp                          rupp@iue.tuwien.ac.at
               Florian Rudolf                     flo.rudy+viennacl@gmail.com
               Josef Weinbub                      weinbub@iue.tuwien.ac.at

   license:    MIT (X11), see file LICENSE in the ViennaCL base directory
======================================================================= */

#ifndef _VIENNACL_TOOLS_ENTRY_PROXY_HPP_
#define _VIENNACL_TOOLS_ENTRY_PROXY_HPP_

#include "viennacl/forwards.h"
#include "viennacl/ocl/backend.hpp"
#include "viennacl/scalar.hpp"

namespace viennacl
{
    //proxy class for single vector entries (this is a slow operation!!)
    template <typename SCALARTYPE>
    class entry_proxy
    {
      public:
        explicit entry_proxy(unsigned int mem_offset, 
                             viennacl::ocl::handle<cl_mem> const & mem_handle) 
         : _index(mem_offset), _mem_handle(mem_handle) {};
        
         
        //operators:
        entry_proxy & operator+=(SCALARTYPE value)
        {
          SCALARTYPE temp = read();
          temp += value; 
          write(temp);         
          return *this;
        }

        entry_proxy &  operator-=(SCALARTYPE value)
        {
          SCALARTYPE temp = read();
          temp -= value; 
          write(temp);         
          return *this;
        }

        entry_proxy &  operator*=(SCALARTYPE value)
        {
          SCALARTYPE temp = read();
          temp *= value; 
          write(temp);         
          return *this;
        }

        entry_proxy &  operator/=(SCALARTYPE value)
        {
          SCALARTYPE temp = read();
          temp /= value; 
          write(temp);         
          return *this;
        }

        entry_proxy &  operator=(SCALARTYPE value)
        {
          write(value);
          return *this;
        }

        entry_proxy & operator=(scalar<SCALARTYPE> const & value)
        {
          cl_int err = clEnqueueCopyBuffer(viennacl::ocl::get_queue().handle(), value.handle(), _mem_handle, 0, sizeof(SCALARTYPE)*_index, sizeof(SCALARTYPE), 0, NULL, NULL);
          //assert(err == CL_SUCCESS);
          VIENNACL_ERR_CHECK(err);
          return *this;
        }

        entry_proxy &  operator=(entry_proxy const & other)
        {
          cl_int err = clEnqueueCopyBuffer(viennacl::ocl::get_queue().handle(),
                                           other._mem_handle, //src
                                           _mem_handle,       //dest
                                           sizeof(SCALARTYPE) * other._index, //offset src
                                           sizeof(SCALARTYPE) * _index,       //offset dest
                                           sizeof(SCALARTYPE), 0, NULL, NULL);
          VIENNACL_ERR_CHECK(err);
          return *this;
        }

        //type conversion:
        // allows to write something like:
        //  double test = vector(4);
        operator SCALARTYPE () const
        {
          SCALARTYPE temp = read();
          return temp;
        }
        
        unsigned int index() const { return _index; }
        
        viennacl::ocl::handle<cl_mem> const & handle() const { return _mem_handle; }

      private:
        SCALARTYPE read() const
        {
          SCALARTYPE temp;
          cl_int err;
          err = clEnqueueReadBuffer(viennacl::ocl::get_queue().handle(), _mem_handle, CL_TRUE, sizeof(SCALARTYPE)*_index, sizeof(SCALARTYPE), &temp, 0, NULL, NULL);
          //assert(err == CL_SUCCESS);
          VIENNACL_ERR_CHECK(err);
          viennacl::ocl::get_queue().finish();
          return temp;
        }
        
        void write(SCALARTYPE value)
        {
          cl_int err;
          err = clEnqueueWriteBuffer(viennacl::ocl::get_queue().handle(), _mem_handle, CL_TRUE, sizeof(SCALARTYPE)*_index, sizeof(SCALARTYPE), &value, 0, NULL, NULL);
          //assert(err == CL_SUCCESS);
          VIENNACL_ERR_CHECK(err);
        }
        
        unsigned int _index;
        viennacl::ocl::handle<cl_mem> const & _mem_handle;
    }; //entry_proxy
    
}

#endif