1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
/*
//
// Copyright 2010 SRI International
//
// This file is part of the Computational Morphometry Toolkit.
//
// http://www.nitrc.org/projects/cmtk/
//
// The Computational Morphometry Toolkit 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.
//
// The Computational Morphometry Toolkit 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.
//
// You should have received a copy of the GNU General Public License along
// with the Computational Morphometry Toolkit. If not, see
// <http://www.gnu.org/licenses/>.
//
// $Revision: 5436 $
//
// $LastChangedDate: 2018-12-10 19:01:20 -0800 (Mon, 10 Dec 2018) $
//
// $LastChangedBy: torstenrohlfing $
//
*/
#ifndef __cmtkDeviceMemory_h_included_
#define __cmtkDeviceMemory_h_included_
#include <cmtkconfig.h>
#ifdef CMTK_USE_CUDA
# include "cmtkDeviceMemoryCUDA.h"
#else
# include "cmtkDeviceMemoryCL.h"
#endif
namespace
cmtk
{
/** \addtogroup GPU */
//@{
/// Resource managing class template for type-specific memory allocated on a GPU device through .
#ifdef CMTK_USE_CUDA
template<typename T,class DeviceMemoryGPU = DeviceMemoryCUDA>
#else
template<typename T,class DeviceMemoryGPU = DeviceMemoryCL>
#endif
class DeviceMemory :
/// Inherit privately from raw pointer base class.
private DeviceMemoryGPU
{
public:
/// This class.
typedef DeviceMemory<T,DeviceMemoryGPU> Self;
/// Smart pointer-to-const.
typedef SmartConstPointer<Self> SmartConstPtr;
/// Smart pointer.
typedef SmartPointer<Self> SmartPtr;
/// Base class.
typedef DeviceMemoryGPU Superclass;
/// Constructor: allocate memory on device through base class.
DeviceMemory( const size_t n, /*!< Number of items.*/ const size_t padToMultiple = 1 )
: DeviceMemoryGPU( n * sizeof( T ), padToMultiple * sizeof( T ) ),
m_NumberOfItems( n )
{}
/// Create new object and allocate memory.
static typename Self::SmartPtr Create( const size_t nItems, /*!< Allocate (at least) this many items of type T.*/
const size_t padToMultiple = 1 /*!< Pad number of allocated elements to next multiple of this number.*/ )
{
return typename Self::SmartPtr( new Self( nItems, padToMultiple ) );
}
/// Create new object, allocate, and initialize memory.
static typename Self::SmartPtr Create( const size_t nItems, /*!< Allocate (at least) this many items of type T.*/
const T* initFrom, /*!< Initialize from this region in host memory.*/
const size_t padToMultiple = 1 /*!< Pad number of allocated elements to next multiple of this number.*/ )
{
Self* newObject = new Self( nItems, padToMultiple );
newObject->CopyToDevice( initFrom, nItems );
return typename Self::SmartPtr( newObject );
}
/// Get const pointer.
const T* Ptr() const
{
return static_cast<const T*>( this->m_PointerDevice );
}
/// Get non-const pointer.
T* Ptr()
{
return static_cast<T*>( this->m_PointerDevice );
}
/// Copy from host to device memory.
void CopyToDevice( const T *const srcPtrHost, const size_t count )
{
this->Superclass::CopyToDevice( srcPtrHost, count * sizeof( T ) );
}
/// Copy from device to host memory.
void CopyToHost( void *const dstPtrHost, const size_t count ) const
{
this->Superclass::CopyToHost( dstPtrHost, count * sizeof( T ) );
}
/// Copy between two device memory locations.
void CopyOnDevice( const Self& srcPtrDevice, const size_t count )
{
this->Superclass::CopyOnDevice( srcPtrDevice, count * sizeof( T ) );
}
/// Clear device memory (set to all zeroes).
void SetToZero()
{
this->Superclass::Memset( 0, this->m_NumberOfItems * sizeof( T ) );
}
/// Get number of items.
size_t GetNumberOfItems() const
{
return this->m_NumberOfItems;
}
private:
/// Number of items allocated.
size_t m_NumberOfItems;
};
//@}
} // namespace cmtk
#endif // #ifndef __cmtkDeviceMemory_h_included_
|
