io.hpp

Go to the documentation of this file.

// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  * Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//  * 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.
//  * Neither the name of the University of Bonn 
//    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.
//*LE*

#ifndef __CUV_BASICS_IO_HPP__
#define __CUV_BASICS_IO_HPP__
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/array.hpp>
#include <boost/serialization/split_free.hpp>
#include <cuv/basics/tensor.hpp>

namespace boost
{
        namespace serialization
        {
        template<class Archive, class V, class M>
            void load(Archive& ar, cuv::memory<V,M>& m, const unsigned int version ){
                typename cuv::memory<V,M>::size_type size;
                ar >> size;
                if(size){
                    V* tmp = new V[size];
                    ar >> make_array(tmp,size);
                    // copy to dev
                    cuv::allocator<V,unsigned int,M> a;
                    V* tmpo;
                    a.alloc(&tmpo, sizeof(V)*size);
                    a.copy(tmpo,tmp,size, cuv::host_memory_space());
                    m.reset(tmpo, size);
                    delete[] tmp;
                }
            }
        template<class Archive, class V, class M>
            void save(Archive& ar, const cuv::memory<V,M>& m, const unsigned int version ){
                // copy to host
                typename cuv::memory<V,M>::size_type size = m.size();
                ar << size;
                if(m.size()){
                    V* tmp = new V[size];
                    cuv::allocator<V,unsigned int,cuv::host_memory_space> a;
                    a.copy(tmp,m.ptr(),size,M());
                    ar << make_array(tmp, size);
                    delete[] tmp;
                }
            }
                template<class Archive, class V, class M>
                void serialize(Archive& ar, cuv::memory<V,M>& m, const unsigned int version){
                        boost::serialization::split_free(ar, m, version);
                }

                template<class Archive, class V>
                void serialize(Archive& ar, cuv::pitched_memory<V,cuv::dev_memory_space>& m, const unsigned int version){
                ar & boost::serialization::base_object<cuv::memory<V,cuv::dev_memory_space> >(m);
                ar  & m.m_rows
                    & m.m_cols
                    & m.m_pitch;
                        //boost::serialization::split_free(ar, m, version);
                }
        

                /****************************************************
                 * serialize linear memory
                 ****************************************************/
                template<class Archive, class V, class MS>
                void serialize(Archive& ar, cuv::linear_memory<V,MS>& m, const unsigned int version){
            ar & boost::serialization::base_object<cuv::memory<V,MS> >(m);
                        //boost::serialization::split_free(ar, m, version);
                }


                /****************************************************
                 * serialize tensor
                 ****************************************************/
                template<class Archive, class V, class MS,class ML>
                void save(Archive& ar, const cuv::tensor<V,MS, ML>& t, const unsigned int version){
                        ar <<  t.info().host_shape
                << t.info().host_stride;
            ar << t.mem();
                        if(t.ndim()>0 && t.mem()){
                long int i = (long int)t.ptr() - (long int)t.mem()->ptr();
                ar << i;
                        }
                }
                template<class Archive, class V, class MS, class ML>
                void load(Archive& ar, cuv::tensor<V,MS, ML>& t, const unsigned int version){
                        ar >> t.info().host_shape;
                        ar >> t.info().host_stride;
            ar >> t.mem();
                        if(t.ndim()>0 && t.mem()){
                long int i;
                ar >> i;
                t.set_ptr_offset(i);
                        }
                }
                template<class Archive, class V, class MS, class ML>
                void serialize(Archive& ar, cuv::tensor<V,MS, ML>& t, const unsigned int version){
                        boost::serialization::split_free(ar, t, version);
                }

        }
}
#endif /* __CUV_BASICS_IO_HPP__ */