Linalg - Vector Class

src/shogun/lib/common.h

@@ -42,6 +42,9 @@
 #undef __STDC_FORMAT_MACROS
 #endif
 
+/** CPU cache line size */
+#define CPU_CACHE_LINE_SIZE 64
+
 /**
  * Implementations tend to follow IEEE754
  * @see http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=4610935

src/shogun/mathematics/linalg/GPUVectorImpl.cpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2016, Shogun-Toolbox e.V. <shogun-team@shogun-toolbox.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  3. Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: 2016 Pan Deng, Soumyajit De, Viktor Gal
+*/
+
+#include <shogun/mathematics/linalg/GPUVectorImpl.h>
+
+#ifdef HAVE_CXX11
+#ifdef HAVE_VIENNACL
+
+namespace shogun
+{
+
+template<class T>
+LinalgVector<T>::GPUVectorImpl::GPUVectorImpl()
+{
+}
+
+template<class T>
+LinalgVector<T>::GPUVectorImpl::GPUVectorImpl(T* data, index_t len)
+:m_GPUptr(new VCLMemoryArray()), m_len(len), m_offset(0)
+{
+
+	{
+		viennacl::backend::memory_create(*m_GPUptr, sizeof(T)*m_len,
+	        	viennacl::context());
+
+		viennacl::backend::memory_write(*m_GPUptr, 0, m_len*sizeof(T), data);
+	}
+}
+
+template<class T>
+LinalgVector<T>::GPUVectorImpl::GPUVectorImpl
+(const LinalgVector<T>::GPUVectorImpl &array)
+{
+	m_GPUptr = array.m_GPUptr;
+	m_len = array.m_len;
+	m_offset = array.m_offset;
+}
+
+template<class T>
+typename LinalgVector<T>::GPUVectorImpl::VCLVectorBase LinalgVector<T>::GPUVectorImpl::GPUvec()
+{
+	return VCLVectorBase(*m_GPUptr, m_len, m_offset, 1);
+}
+
+template<class T>
+typename LinalgVector<T>::GPUVectorImpl::VCLVector LinalgVector<T>::GPUVectorImpl::vector()
+{
+	return VCLVector(LinalgVector<T>::GPUVectorImpl::GPUvec());
+}
+
+template class LinalgVector<int32_t>;
+template class LinalgVector<float32_t>;
+
+}
+
+#endif //HAVE_VIENNACL
+#endif //HAVE_CXX11

src/shogun/mathematics/linalg/GPUVectorImpl.h

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2016, Shogun-Toolbox e.V. <shogun-team@shogun-toolbox.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  3. Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: 2016 Pan Deng, Soumyajit De, Viktor Gal
+ */
+
+
+
+#include <shogun/lib/config.h>
+#include <shogun/io/SGIO.h>
+#include <shogun/lib/SGVector.h>
+#include <shogun/mathematics/linalg/linalgVector.h>
+#include <memory>
+
+#ifndef GPU_VECTOR_IMPL_H__
+#define GPU_VECTOR_IMPL_H__
+
+#ifdef HAVE_CXX11
+#ifdef HAVE_VIENNACL
+#include <viennacl/vector.hpp>
+
+namespace shogun
+{
+
+/** GPU array structure */
+template <class T>
+class LinalgVector<T>::GPUVectorImpl
+{
+
+	typedef viennacl::backend::mem_handle VCLMemoryArray;
+	typedef viennacl::vector_base<T, std::size_t, std::ptrdiff_t> VCLVectorBase;
+	typedef viennacl::vector<T> VCLVector;
+
+public:
+	GPUVectorImpl();
+
+	/** Creates a gpu vector with LinalgVector */
+	GPUVectorImpl(T* data, index_t len);
+
+	/** Copy Constructor */
+	GPUVectorImpl(const LinalgVector<T>::GPUVectorImpl &array);
+
+	/** Returns a ViennaCL vector wrapped around the data of this vector. Can be
+	 * used to call native ViennaCL methods on this vector
+	 */
+	VCLVectorBase GPUvec();
+
+	/** Cast of VCLVectorBase to VCLVector
+	 * allows element access
+	 */
+	VCLVector vector();
+
+
+private:
+	/** Memory segment holding the data for the vector */
+	alignas(CPU_CACHE_LINE_SIZE) std::shared_ptr<VCLMemoryArray> m_GPUptr;
+
+	/** Vector length */
+	alignas(CPU_CACHE_LINE_SIZE) index_t m_len;
+
+	/** Offset for the memory segment, i.e the data of the vector
+	 * starts at vector+offset
+	 */
+	alignas(CPU_CACHE_LINE_SIZE) index_t m_offset;
+
+};
+
+}
+
+#endif //HAVE_CXX11
+#endif //HAVE_VIENNACL
+
+#endif

src/shogun/mathematics/linalg/linalgVector.cpp

@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2016, Shogun-Toolbox e.V. <shogun-team@shogun-toolbox.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  3. Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: 2016 Pan Deng, Soumyajit De, Viktor Gal
+*/
+
+#include <shogun/mathematics/linalg/linalgVector.h>
+#include <shogun/mathematics/linalg/GPUVectorImpl.h>
+
+#ifdef HAVE_CXX11
+
+namespace shogun
+{
+
+template<class T>
+LinalgVector<T>::LinalgVector()
+{
+	init();
+}
+
+template<class T>
+LinalgVector<T>::LinalgVector(SGVector<T> const &vector)
+{
+	init();
+	m_data = reinterpret_cast<T*>(SG_MALLOC(aligned_t, vector.vlen));
+	std::copy(vector.vector, vector.vector+vector.vlen, m_data);
+	m_len = vector.vlen;
+}
+
+template<class T>
+LinalgVector<T>::LinalgVector(LinalgVector<T> const &vector)
+{
+	init();
+	m_data = vector.m_data;
+	m_len = vector.m_len;
+	m_onGPU = vector.m_onGPU;
+
+	if (vector.onGPU())
+	{
+		m_onGPU = true;
+		m_gpu_impl = std::unique_ptr<GPUVectorImpl>(new GPUVectorImpl(*(vector.m_gpu_impl)));
+	}
+}
+
+template<class T>
+LinalgVector<T>::~LinalgVector()
+{
+	free(m_data);
+}
+
+template<class T>
+LinalgVector<T>& LinalgVector<T>::operator=(SGVector<T> const &vector)
+{
+	m_data = reinterpret_cast<T*>(SG_MALLOC(aligned_t, vector.vlen));
+	std::copy(vector.vector, vector.vector+vector.vlen, m_data);
+	m_len = vector.vlen;
+	m_onGPU = false;
+	m_gpu_impl.release();
+	return *this;
+}
+
+template<class T>
+LinalgVector<T>& LinalgVector<T>::operator=(LinalgVector<T> const &vector)
+{
+
+	m_data = vector.m_data;
+	m_len = vector.m_len;
+	m_onGPU = vector.m_onGPU;
+	if (vector.onGPU())
+	{
+		m_gpu_impl.reset(new GPUVectorImpl(*(vector.m_gpu_impl)));
+	}
+	return *this;
+
+}
+
+template<class T>
+LinalgVector<T>::operator SGVector<T>() const
+{
+	return SGVector<T>(m_data, m_len);
+}
+
+template<class T>
+bool LinalgVector<T>::onGPU() const
+{
+	return m_onGPU;
+}
+
+template<class T>
+T* LinalgVector<T>::data()
+{
+	return m_data;
+}
+
+template<class T>
+T const * LinalgVector<T>::data() const
+{
+	return m_data;
+}
+
+template<class T>
+index_t LinalgVector<T>::size() const
+{
+	return m_len;
+}
+
+template<class T>
+void LinalgVector<T>::transferToGPU()
+{
+#ifdef HAVE_VIENNACL
+	m_gpu_impl = std::unique_ptr<GPUVectorImpl>(new GPUVectorImpl(m_data, m_len));
+	m_onGPU = true;
+#else
+	SG_SERROR("User did not register GPU backend. \n");
+#endif
+}
+
+template<class T>
+void LinalgVector<T>::transferToCPU()
+{
+	if (m_gpu_impl != nullptr)
+	{
+		m_gpu_impl.release();
+	}
+	m_onGPU = false;
+}
+
+template<class T>
+void LinalgVector<T>::init()
+{
+	m_data = nullptr;
+	m_len = 0;
+	m_onGPU = false;
+}
+
+template class LinalgVector<int32_t>;
+template class LinalgVector<float32_t>;
+
+}
+
+#endif //HAVE_CXX11