← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/KOKKOS/neighbor_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/neighbor_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
#ifndef LMP_NEIGHBOR_KOKKOS_H
 
15
#define LMP_NEIGHBOR_KOKKOS_H
 
16
 
 
17
#include "neighbor.h"
 
18
#include "neigh_list_kokkos.h"
 
19
#include "kokkos_type.h"
 
20
#include <math.h>
 
21
 
 
22
namespace LAMMPS_NS {
 
23
 
 
24
template<class Device>
 
25
class NeighborKokkosExecute
 
26
{
 
27
  typedef ArrayTypes<Device> AT;
 
28
 
 
29
 public:
 
30
  NeighListKokkos<Device> neigh_list;
 
31
  const typename AT::t_xfloat_2d_randomread cutneighsq;
 
32
  const typename AT::t_int_1d bincount;
 
33
  const typename AT::t_int_1d_const c_bincount;
 
34
  typename AT::t_int_2d bins;
 
35
  typename AT::t_int_2d_const c_bins;
 
36
  const typename AT::t_x_array_randomread x;
 
37
  const typename AT::t_int_1d_const type,mask,molecule;
 
38
 
 
39
  const typename AT::t_tagint_1d_const tag;
 
40
  const typename AT::t_tagint_2d_const special;
 
41
  const typename AT::t_int_2d_const nspecial;
 
42
  const int molecular;
 
43
  int moltemplate;
 
44
 
 
45
  int special_flag[4];
 
46
 
 
47
  const int nbinx,nbiny,nbinz;
 
48
  const int mbinx,mbiny,mbinz;
 
49
  const int mbinxlo,mbinylo,mbinzlo;
 
50
  const X_FLOAT bininvx,bininvy,bininvz;
 
51
  X_FLOAT bboxhi[3],bboxlo[3];
 
52
 
 
53
  const int nlocal;
 
54
 
 
55
  const int exclude;
 
56
 
 
57
  const int nex_type;
 
58
  const int maxex_type;
 
59
  const typename AT::t_int_1d_const ex1_type,ex2_type;
 
60
  const typename AT::t_int_2d_const ex_type;
 
61
 
 
62
  const int nex_group;
 
63
  const int maxex_group;
 
64
  const typename AT::t_int_1d_const ex1_group,ex2_group;
 
65
  const typename AT::t_int_1d_const ex1_bit,ex2_bit;
 
66
 
 
67
  const int nex_mol;
 
68
  const int maxex_mol;
 
69
  const typename AT::t_int_1d_const ex_mol_group;
 
70
  const typename AT::t_int_1d_const ex_mol_bit;
 
71
 
 
72
  typename AT::t_int_scalar resize;
 
73
  typename AT::t_int_scalar new_maxneighs;
 
74
  typename ArrayTypes<LMPHostType>::t_int_scalar h_resize;
 
75
  typename ArrayTypes<LMPHostType>::t_int_scalar h_new_maxneighs;
 
76
 
 
77
  const int xperiodic, yperiodic, zperiodic;
 
78
  const int xprd_half, yprd_half, zprd_half;
 
79
 
 
80
  NeighborKokkosExecute(
 
81
                        const NeighListKokkos<Device> &_neigh_list,
 
82
                        const typename AT::t_xfloat_2d_randomread &_cutneighsq,
 
83
                        const typename AT::t_int_1d &_bincount,
 
84
                        const typename AT::t_int_2d &_bins,
 
85
                        const int _nlocal,
 
86
                        const typename AT::t_x_array_randomread &_x,
 
87
                        const typename AT::t_int_1d_const &_type,
 
88
                        const typename AT::t_int_1d_const &_mask,
 
89
                        const typename AT::t_int_1d_const &_molecule,
 
90
                        const typename AT::t_tagint_1d_const &_tag,
 
91
                        const typename AT::t_tagint_2d_const &_special,
 
92
                        const typename AT::t_int_2d_const &_nspecial,
 
93
                        const int &_molecular,
 
94
                        const int & _nbinx,const int & _nbiny,const int & _nbinz,
 
95
                        const int & _mbinx,const int & _mbiny,const int & _mbinz,
 
96
                        const int & _mbinxlo,const int & _mbinylo,const int & _mbinzlo,
 
97
                        const X_FLOAT &_bininvx,const X_FLOAT &_bininvy,const X_FLOAT &_bininvz,
 
98
                        const int & _exclude,const int & _nex_type,const int & _maxex_type,
 
99
                        const typename AT::t_int_1d_const & _ex1_type,
 
100
                        const typename AT::t_int_1d_const & _ex2_type,
 
101
                        const typename AT::t_int_2d_const & _ex_type,
 
102
                        const int & _nex_group,const int & _maxex_group,
 
103
                        const typename AT::t_int_1d_const & _ex1_group,
 
104
                        const typename AT::t_int_1d_const & _ex2_group,
 
105
                        const typename AT::t_int_1d_const & _ex1_bit,
 
106
                        const typename AT::t_int_1d_const & _ex2_bit,
 
107
                        const int & _nex_mol,const int & _maxex_mol,
 
108
                        const typename AT::t_int_1d_const & _ex_mol_group,
 
109
                        const typename AT::t_int_1d_const & _ex_mol_bit,
 
110
                        const X_FLOAT *_bboxhi, const X_FLOAT* _bboxlo,
 
111
                        const int & _xperiodic, const int & _yperiodic, const int & _zperiodic,
 
112
                        const int & _xprd_half, const int & _yprd_half, const int & _zprd_half):
 
113
    neigh_list(_neigh_list), cutneighsq(_cutneighsq),
 
114
    bincount(_bincount),c_bincount(_bincount),bins(_bins),c_bins(_bins),
 
115
    nlocal(_nlocal),
 
116
    x(_x),type(_type),mask(_mask),molecule(_molecule),
 
117
    tag(_tag),special(_special),nspecial(_nspecial),molecular(_molecular),
 
118
    nbinx(_nbinx),nbiny(_nbiny),nbinz(_nbinz),
 
119
    mbinx(_mbinx),mbiny(_mbiny),mbinz(_mbinz),
 
120
    mbinxlo(_mbinxlo),mbinylo(_mbinylo),mbinzlo(_mbinzlo),
 
121
    bininvx(_bininvx),bininvy(_bininvy),bininvz(_bininvz),
 
122
    exclude(_exclude),nex_type(_nex_type),maxex_type(_maxex_type),
 
123
    ex1_type(_ex1_type),ex2_type(_ex2_type),ex_type(_ex_type),
 
124
    nex_group(_nex_group),maxex_group(_maxex_group),
 
125
    ex1_group(_ex1_group),ex2_group(_ex2_group),
 
126
    ex1_bit(_ex1_bit),ex2_bit(_ex2_bit),nex_mol(_nex_mol),maxex_mol(_maxex_mol),
 
127
    ex_mol_group(_ex_mol_group),ex_mol_bit(_ex_mol_bit),
 
128
    xperiodic(_xperiodic),yperiodic(_yperiodic),zperiodic(_zperiodic),
 
129
    xprd_half(_xprd_half),yprd_half(_yprd_half),zprd_half(_zprd_half){
 
130
 
 
131
    if (molecular == 2) moltemplate = 1;
 
132
    else moltemplate = 0;
 
133
 
 
134
    bboxlo[0] = _bboxlo[0]; bboxlo[1] = _bboxlo[1]; bboxlo[2] = _bboxlo[2];
 
135
    bboxhi[0] = _bboxhi[0]; bboxhi[1] = _bboxhi[1]; bboxhi[2] = _bboxhi[2];
 
136
 
 
137
    resize = typename AT::t_int_scalar("NeighborKokkosFunctor::resize");
 
138
#ifndef KOKKOS_USE_CUDA_UVM
 
139
    h_resize = Kokkos::create_mirror_view(resize);
 
140
#else
 
141
    h_resize = resize;
 
142
#endif
 
143
    h_resize() = 1;
 
144
    new_maxneighs = typename AT::
 
145
      t_int_scalar("NeighborKokkosFunctor::new_maxneighs");
 
146
#ifndef KOKKOS_USE_CUDA_UVM
 
147
    h_new_maxneighs = Kokkos::create_mirror_view(new_maxneighs);
 
148
#else
 
149
    h_new_maxneighs = new_maxneighs;
 
150
#endif
 
151
    h_new_maxneighs() = neigh_list.maxneighs;
 
152
  };
 
153
 
 
154
  ~NeighborKokkosExecute() {neigh_list.clean_copy();};
 
155
 
 
156
  template<int HalfNeigh, int GhostNewton>
 
157
  KOKKOS_FUNCTION
 
158
  void build_Item(const int &i) const;
 
159
 
 
160
  template<int ClusterSize>
 
161
  KOKKOS_FUNCTION
 
162
  void build_cluster_Item(const int &i) const;
 
163
 
 
164
#ifdef KOKKOS_HAVE_CUDA
 
165
  template<int HalfNeigh, int GhostNewton>
 
166
  __device__ inline
 
167
  void build_ItemCuda(typename Kokkos::TeamPolicy<Device>::member_type dev) const;
 
168
#endif
 
169
 
 
170
  KOKKOS_INLINE_FUNCTION
 
171
  void binatomsItem(const int &i) const;
 
172
 
 
173
  KOKKOS_INLINE_FUNCTION
 
174
  int coord2bin(const X_FLOAT & x,const X_FLOAT & y,const X_FLOAT & z) const
 
175
  {
 
176
    int ix,iy,iz;
 
177
 
 
178
    if (x >= bboxhi[0])
 
179
      ix = static_cast<int> ((x-bboxhi[0])*bininvx) + nbinx;
 
180
    else if (x >= bboxlo[0]) {
 
181
      ix = static_cast<int> ((x-bboxlo[0])*bininvx);
 
182
      ix = MIN(ix,nbinx-1);
 
183
    } else
 
184
      ix = static_cast<int> ((x-bboxlo[0])*bininvx) - 1;
 
185
 
 
186
    if (y >= bboxhi[1])
 
187
      iy = static_cast<int> ((y-bboxhi[1])*bininvy) + nbiny;
 
188
    else if (y >= bboxlo[1]) {
 
189
      iy = static_cast<int> ((y-bboxlo[1])*bininvy);
 
190
      iy = MIN(iy,nbiny-1);
 
191
    } else
 
192
      iy = static_cast<int> ((y-bboxlo[1])*bininvy) - 1;
 
193
 
 
194
    if (z >= bboxhi[2])
 
195
      iz = static_cast<int> ((z-bboxhi[2])*bininvz) + nbinz;
 
196
    else if (z >= bboxlo[2]) {
 
197
      iz = static_cast<int> ((z-bboxlo[2])*bininvz);
 
198
      iz = MIN(iz,nbinz-1);
 
199
    } else
 
200
      iz = static_cast<int> ((z-bboxlo[2])*bininvz) - 1;
 
201
 
 
202
    return (iz-mbinzlo)*mbiny*mbinx + (iy-mbinylo)*mbinx + (ix-mbinxlo);
 
203
  }
 
204
 
 
205
  KOKKOS_INLINE_FUNCTION
 
206
  int exclusion(const int &i,const int &j, const int &itype,const int &jtype) const;
 
207
 
 
208
  KOKKOS_INLINE_FUNCTION
 
209
  int find_special(const int &i, const int &j) const;
 
210
 
 
211
  KOKKOS_INLINE_FUNCTION
 
212
  int minimum_image_check(double dx, double dy, double dz) const {
 
213
    if (xperiodic && fabs(dx) > xprd_half) return 1;
 
214
    if (yperiodic && fabs(dy) > yprd_half) return 1;
 
215
    if (zperiodic && fabs(dz) > zprd_half) return 1;
 
216
    return 0;
 
217
  }
 
218
 
 
219
};
 
220
 
 
221
template<class Device>
 
222
struct NeighborKokkosBinAtomsFunctor {
 
223
  typedef Device device_type;
 
224
 
 
225
  const NeighborKokkosExecute<Device> c;
 
226
 
 
227
  NeighborKokkosBinAtomsFunctor(const NeighborKokkosExecute<Device> &_c):
 
228
    c(_c) {};
 
229
  ~NeighborKokkosBinAtomsFunctor() {}
 
230
  KOKKOS_INLINE_FUNCTION
 
231
  void operator() (const int & i) const {
 
232
    c.binatomsItem(i);
 
233
  }
 
234
};
 
235
 
 
236
template<class Device,int HALF_NEIGH,int GHOST_NEWTON>
 
237
struct NeighborKokkosBuildFunctor {
 
238
  typedef Device device_type;
 
239
 
 
240
  const NeighborKokkosExecute<Device> c;
 
241
  const size_t sharedsize;
 
242
 
 
243
  NeighborKokkosBuildFunctor(const NeighborKokkosExecute<Device> &_c, 
 
244
                             const size_t _sharedsize):c(_c),
 
245
                             sharedsize(_sharedsize) {};
 
246
  
 
247
  KOKKOS_INLINE_FUNCTION
 
248
  void operator() (const int & i) const {
 
249
    c.template build_Item<HALF_NEIGH,GHOST_NEWTON>(i);
 
250
  }
 
251
#ifdef KOKKOS_HAVE_CUDA
 
252
  KOKKOS_INLINE_FUNCTION
 
253
  void operator() (typename Kokkos::TeamPolicy<Device>::member_type dev) const {
 
254
    c.template build_ItemCuda<HALF_NEIGH,GHOST_NEWTON>(dev);
 
255
  }
 
256
  size_t shmem_size(const int team_size) const { (void) team_size; return sharedsize; }
 
257
#endif
 
258
};
 
259
 
 
260
template<class Device,int ClusterSize>
 
261
struct NeighborClusterKokkosBuildFunctor {
 
262
  typedef Device device_type;
 
263
 
 
264
  const NeighborKokkosExecute<Device> c;
 
265
  const size_t sharedsize;
 
266
 
 
267
  NeighborClusterKokkosBuildFunctor(const NeighborKokkosExecute<Device> &_c,
 
268
                             const size_t _sharedsize):c(_c),
 
269
                             sharedsize(_sharedsize) {};
 
270
 
 
271
  KOKKOS_INLINE_FUNCTION
 
272
  void operator() (const int & i) const {
 
273
    c.template build_cluster_Item<ClusterSize>(i);
 
274
  }
 
275
};
 
276
 
 
277
class NeighborKokkos : public Neighbor {
 
278
 public:
 
279
  class AtomKokkos *atomKK;
 
280
 
 
281
  int nlist_host;                       // pairwise neighbor lists on Host
 
282
  NeighListKokkos<LMPHostType> **lists_host;
 
283
  int nlist_device;                     // pairwise neighbor lists on Device
 
284
  NeighListKokkos<LMPDeviceType> **lists_device;
 
285
 
 
286
  NeighborKokkos(class LAMMPS *);
 
287
  ~NeighborKokkos();
 
288
  void init();
 
289
 
 
290
 private:
 
291
  int atoms_per_bin;
 
292
  DAT::tdual_xfloat_2d k_cutneighsq;
 
293
  DAT::tdual_int_1d k_bincount;
 
294
  DAT::tdual_int_2d k_bins;
 
295
 
 
296
  DAT::tdual_int_1d k_ex1_type,k_ex2_type;
 
297
  DAT::tdual_int_2d k_ex_type;
 
298
  DAT::tdual_int_1d k_ex1_group,k_ex2_group;
 
299
  DAT::tdual_int_1d k_ex1_bit,k_ex2_bit;
 
300
  DAT::tdual_int_1d k_ex_mol_group;
 
301
  DAT::tdual_int_1d k_ex_mol_bit;
 
302
 
 
303
  void init_cutneighsq_kokkos(int);
 
304
  int init_lists_kokkos();
 
305
  void init_list_flags1_kokkos(int);
 
306
  void init_list_flags2_kokkos(int);
 
307
  void init_list_grow_kokkos(int);
 
308
  void init_ex_type_kokkos(int);
 
309
  void init_ex_bit_kokkos();
 
310
  void init_ex_mol_bit_kokkos();
 
311
  void choose_build(int, NeighRequest *);
 
312
  void build_kokkos(int);
 
313
  void setup_bins_kokkos(int);
 
314
  void modify_ex_type_grow_kokkos();
 
315
  void modify_ex_group_grow_kokkos();
 
316
  void modify_mol_group_grow_kokkos();
 
317
 
 
318
  typedef void (NeighborKokkos::*PairPtrHost)
 
319
    (class NeighListKokkos<LMPHostType> *);
 
320
  PairPtrHost *pair_build_host;
 
321
  typedef void (NeighborKokkos::*PairPtrDevice)
 
322
    (class NeighListKokkos<LMPDeviceType> *);
 
323
  PairPtrDevice *pair_build_device;
 
324
 
 
325
  template<class DeviceType,int HALF_NEIGH>
 
326
  void full_bin_kokkos(NeighListKokkos<DeviceType> *list);
 
327
  template<class DeviceType>
 
328
  void full_bin_cluster_kokkos(NeighListKokkos<DeviceType> *list);
 
329
 
 
330
  typedef void (NeighborKokkos::*StencilPtrHost)
 
331
    (class NeighListKokkos<LMPHostType> *, int, int, int);
 
332
  StencilPtrHost *stencil_create_host;
 
333
  typedef void (NeighborKokkos::*StencilPtrDevice)
 
334
    (class NeighListKokkos<LMPDeviceType> *, int, int, int);
 
335
  StencilPtrDevice *stencil_create_device;
 
336
};
 
337
 
 
338
}
 
339
 
 
340
#endif
 
341
 
 
342
/* ERROR/WARNING messages:
 
343
 
 
344
*/