← Back to branch summary

~ubuntu-branches/debian/sid/lammps/sid

« back to all changes in this revision

Viewing changes to src/KOKKOS/memory_kokkos.h

  • Committer: Package Import Robot
  • Author(s): Anton Gladky
  • Date: 2015-04-29 23:44:49 UTC
  • mfrom: (5.1.3 experimental)
  • Revision ID: package-import@ubuntu.com-20150429234449-mbhy9utku6hp6oq8
Tags: 0~20150313.gitfa668e1-1
Upload into unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/KOKKOS/memory_kokkos.h
 
1
/* -*- c++ -*- ----------------------------------------------------------
 
2
   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
 
3
   http://lammps.sandia.gov, Sandia National Laboratories
 
4
   Steve Plimpton, sjplimp@sandia.gov
 
5
 
 
6
   Copyright (2003) Sandia Corporation.  Under the terms of Contract
 
7
   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 
8
   certain rights in this software.  This software is distributed under
 
9
   the GNU General Public License.
 
10
 
 
11
   See the README file in the top-level LAMMPS directory.
 
12
------------------------------------------------------------------------- */
 
13
 
 
14
/* ----------------------------------------------------------------------
 
15
   Kokkos versions of create/grow/destroy multi-dimensional arrays
 
16
------------------------------------------------------------------------- */
 
17
 
 
18
/* ----------------------------------------------------------------------
 
19
   create a 1d array
 
20
------------------------------------------------------------------------- */
 
21
 
 
22
template <typename TYPE>
 
23
TYPE create_kokkos(TYPE &data, typename TYPE::value_type *&array, 
 
24
                   int n1, const char *name)
 
25
{
 
26
  data = TYPE(name,n1);
 
27
  array = data.h_view.ptr_on_device();
 
28
  return data;
 
29
}
 
30
 
 
31
template <typename TYPE, typename HTYPE>
 
32
  TYPE create_kokkos(TYPE &data, HTYPE &h_data, 
 
33
                     typename TYPE::value_type *&array, int n1, 
 
34
                     const char *name)
 
35
{
 
36
  data = TYPE(std::string(name),n1);
 
37
#ifndef KOKKOS_USE_CUDA_UVM
 
38
  h_data = Kokkos::create_mirror_view(data);
 
39
#else
 
40
  h_data = data;
 
41
#endif
 
42
  array = h_data.ptr_on_device();
 
43
  return data;
 
44
}
 
45
 
 
46
 
 
47
template <typename TYPE, typename HTYPE>
 
48
  TYPE create_kokkos(TYPE &data, HTYPE &h_data,
 
49
                     int n1, const char *name)
 
50
{
 
51
  data = TYPE(std::string(name),n1);
 
52
#ifndef KOKKOS_USE_CUDA_UVM
 
53
  h_data = Kokkos::create_mirror_view(data);
 
54
#else
 
55
  h_data = data;
 
56
#endif
 
57
  return data;
 
58
}
 
59
 
 
60
/* ----------------------------------------------------------------------
 
61
   grow or shrink 1st dim of a 1d array
 
62
   last dim must stay the same
 
63
------------------------------------------------------------------------- */
 
64
 
 
65
template <typename TYPE>
 
66
TYPE grow_kokkos(TYPE &data, typename TYPE::value_type *&array, 
 
67
                 int n1, const char *name)
 
68
{
 
69
  if (array == NULL) return create_kokkos(data,array,n1,name);
 
70
  
 
71
  data.resize(n1);
 
72
  array = data.h_view.ptr_on_device();
 
73
  return data;
 
74
}
 
75
 
 
76
template <typename TYPE>
 
77
void destroy_kokkos(TYPE data, typename TYPE::value_type* &array)
 
78
{
 
79
  if (array == NULL) return;
 
80
  data = TYPE();
 
81
  array = NULL;
 
82
}
 
83
 
 
84
/* ----------------------------------------------------------------------
 
85
   create a 2d array
 
86
------------------------------------------------------------------------- */
 
87
 
 
88
template <typename TYPE>
 
89
TYPE destroy_kokkos(TYPE &data)
 
90
{
 
91
  /*if(data.ptr_on_device()!=NULL)
 
92
    free(data.ptr_on_device());*/
 
93
  data = TYPE();
 
94
  return data;
 
95
}
 
96
 
 
97
template <typename TYPE>
 
98
TYPE create_kokkos(TYPE &data, int n1, const char *name)
 
99
{
 
100
  /*typename TYPE::non_const_value_type* ptr = (typename TYPE::non_const_value_type*)
 
101
    malloc(n1*sizeof(typename TYPE::non_const_value_type)*4);*/
 
102
  data = TYPE(std::string(name),n1);
 
103
  return data;
 
104
}
 
105
 
 
106
template <typename TYPE>
 
107
TYPE create_kokkos(TYPE &data, int n1, int n2, const char *name)
 
108
{
 
109
  /*typename TYPE::non_const_value_type* ptr = (typename TYPE::non_const_value_type*)
 
110
    malloc(n1*n2*sizeof(typename TYPE::non_const_value_type)*4);*/
 
111
  data = TYPE(std::string(name),n1,n2);
 
112
  return data;
 
113
}
 
114
 
 
115
template <typename TYPE>
 
116
TYPE create_kokkos(TYPE &data, int n1, int n2, int n3 ,const char *name)
 
117
{
 
118
  /*typename TYPE::non_const_value_type* ptr = (typename TYPE::non_const_value_type*)
 
119
    malloc(n1*n2*n3*sizeof(typename TYPE::non_const_value_type)*4);*/
 
120
  data = TYPE(std::string(name),n1,n2,n3);
 
121
  return data;
 
122
}
 
123
 
 
124
template <typename TYPE>
 
125
TYPE create_kokkos(TYPE &data, int n1, int n2, int n3, int n4 ,const char *name)
 
126
{
 
127
  /*typename TYPE::non_const_value_type* ptr = (typename TYPE::non_const_value_type*)
 
128
    malloc(n1*n2*n3*n4*sizeof(typename TYPE::non_const_value_type)*4);*/
 
129
  data = TYPE(std::string(name),n1,n2,n3,n4);
 
130
  return data;
 
131
}
 
132
 
 
133
template <typename TYPE>
 
134
TYPE create_kokkos(TYPE &data, int n1, int n2, int n3, int n4, int n5 ,const char *name)
 
135
{
 
136
  /*typename TYPE::non_const_value_type* ptr = (typename TYPE::non_const_value_type*)
 
137
    malloc(n1*n2*n3*n4*n5*sizeof(typename TYPE::non_const_value_type)*4);*/
 
138
  data = TYPE(std::string(name),n1,n2,n3,n4,n5);
 
139
  return data;
 
140
}
 
141
 
 
142
template <typename TYPE>
 
143
TYPE create_kokkos(TYPE &data, int n1, int n2, int n3, int n4, int n5 , int n6 ,const char *name)
 
144
{
 
145
  /*typename TYPE::non_const_value_type* ptr = (typename TYPE::non_const_value_type*)
 
146
    malloc(n1*n2*n3*n4*n5*n6*sizeof(typename TYPE::non_const_value_type)*4);*/
 
147
  data = TYPE(std::string(name) ,n1,n2,n3,n4,n5,n6);
 
148
  return data;
 
149
}
 
150
 
 
151
 
 
152
 
 
153
template <typename TYPE, typename HTYPE>
 
154
  TYPE create_kokkos(TYPE &data, HTYPE &h_data, int n1, int n2, 
 
155
                     const char *name)
 
156
{
 
157
  data = TYPE(std::string(name),n1,n2);
 
158
#ifndef KOKKOS_USE_CUDA_UVM
 
159
  h_data = Kokkos::create_mirror_view(data);
 
160
#else
 
161
  h_data = data;
 
162
#endif
 
163
  return data;
 
164
}
 
165
 
 
166
template <typename TYPE>
 
167
TYPE create_kokkos(TYPE &data, typename TYPE::value_type **&array, 
 
168
                   int n1, int n2, const char *name)
 
169
{
 
170
  data = TYPE(std::string(name),n1,n2);
 
171
  bigint nbytes = ((bigint) sizeof(typename TYPE::value_type *)) * n1;
 
172
  array = (typename TYPE::value_type **) smalloc(nbytes,name);
 
173
  
 
174
  bigint n = 0;
 
175
  for (int i = 0; i < n1; i++) {
 
176
    array[i] = &data.h_view(i,0);
 
177
    n += n2;
 
178
  }
 
179
  return data;
 
180
}
 
181
 
 
182
template <typename TYPE, typename HTYPE>
 
183
  TYPE create_kokkos(TYPE &data, HTYPE &h_data, 
 
184
                     typename TYPE::value_type **&array, int n1, int n2, 
 
185
                     const char *name)
 
186
{
 
187
  data = TYPE(std::string(name),n1,n2);
 
188
#ifndef KOKKOS_USE_CUDA_UVM
 
189
  h_data = Kokkos::create_mirror_view(data);
 
190
#else
 
191
  h_data = data;
 
192
#endif
 
193
  bigint nbytes = ((bigint) sizeof(typename TYPE::value_type *)) * n1;
 
194
  array = (typename TYPE::value_type **) smalloc(nbytes,name);
 
195
  
 
196
  bigint n = 0;
 
197
  for (int i = 0; i < n1; i++) {
 
198
    array[i] = &h_data(i,0);
 
199
    n += n2;
 
200
  }
 
201
  return data;
 
202
}
 
203
 
 
204
/* ----------------------------------------------------------------------
 
205
   grow or shrink 1st dim of a 2d array
 
206
   last dim must stay the same
 
207
------------------------------------------------------------------------- */
 
208
 
 
209
template <typename TYPE>
 
210
TYPE grow_kokkos(TYPE &data, typename TYPE::value_type **&array, 
 
211
                 int n1, int n2, const char *name)
 
212
{
 
213
  if (array == NULL) return create_kokkos(data,array,n1,n2,name);
 
214
  data.resize(n1,n2);
 
215
  bigint nbytes = ((bigint) sizeof(typename TYPE::value_type *)) * n1;
 
216
  array = (typename TYPE::value_type**) srealloc(array,nbytes,name);
 
217
  
 
218
  for (int i = 0; i < n1; i++)
 
219
    array[i] = &data.h_view(i,0);
 
220
  
 
221
  return data;
 
222
}
 
223
 
 
224
template <typename TYPE>
 
225
TYPE create_kokkos(TYPE &data, typename TYPE::value_type **&array, 
 
226
                   int n1, const char *name)
 
227
{
 
228
  data = TYPE(std::string(name),n1);
 
229
  bigint nbytes = ((bigint) sizeof(typename TYPE::value_type *)) * n1;
 
230
  array = (typename TYPE::value_type **) smalloc(nbytes,name);
 
231
  
 
232
  for (int i = 0; i < n1; i++)
 
233
    array[i] = &data.h_view(i,0);
 
234
  
 
235
  return data;
 
236
}
 
237
 
 
238
template <typename TYPE>
 
239
TYPE grow_kokkos(TYPE &data, typename TYPE::value_type **&array, 
 
240
                 int n1, const char *name)
 
241
{
 
242
  if (array == NULL) return create_kokkos(data,array,n1,name);
 
243
  
 
244
  data.resize(n1);
 
245
  
 
246
  bigint nbytes = ((bigint) sizeof(typename TYPE::value_type *)) * n1;
 
247
  array = (typename TYPE::value_type **) smalloc(nbytes,name);
 
248
  
 
249
  for (int i = 0; i < n1; i++)
 
250
    array[i] = &data.h_view(i,0);
 
251
  
 
252
  return data;
 
253
}
 
254
 
 
255
/* ----------------------------------------------------------------------
 
256
   destroy a 2d array
 
257
------------------------------------------------------------------------- */
 
258
 
 
259
template <typename TYPE>
 
260
void destroy_kokkos(TYPE data, typename TYPE::value_type** &array)
 
261
{
 
262
  if (array == NULL) return;
 
263
  data = TYPE();
 
264
  sfree(array);
 
265
  array = NULL;
 
266
}