Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F81185563
TestSort.hpp
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Wed, Sep 4, 15:38
Size
6 KB
Mime Type
text/x-c
Expires
Fri, Sep 6, 15:38 (1 d, 23 h)
Engine
blob
Format
Raw Data
Handle
20528013
Attached To
rLAMMPS lammps
TestSort.hpp
View Options
//@HEADER
// ************************************************************************
//
// Kokkos v. 2.0
// Copyright (2014) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// 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 Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
// 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.
//
// Questions? Contact H. Carter Edwards (hcedwar@sandia.gov)
//
// ************************************************************************
//@HEADER
#ifndef TESTSORT_HPP_
#define TESTSORT_HPP_
#include <gtest/gtest.h>
#include<Kokkos_Core.hpp>
#include<Kokkos_Random.hpp>
#include<Kokkos_Sort.hpp>
namespace
Test
{
namespace
Impl
{
template
<
class
ExecutionSpace
,
class
Scalar
>
struct
is_sorted_struct
{
typedef
unsigned
int
value_type
;
typedef
ExecutionSpace
execution_space
;
Kokkos
::
View
<
Scalar
*
,
ExecutionSpace
>
keys
;
is_sorted_struct
(
Kokkos
::
View
<
Scalar
*
,
ExecutionSpace
>
keys_
)
:
keys
(
keys_
)
{}
KOKKOS_INLINE_FUNCTION
void
operator
()
(
int
i
,
unsigned
int
&
count
)
const
{
if
(
keys
(
i
)
>
keys
(
i
+
1
))
count
++
;
}
};
template
<
class
ExecutionSpace
,
class
Scalar
>
struct
sum
{
typedef
double
value_type
;
typedef
ExecutionSpace
execution_space
;
Kokkos
::
View
<
Scalar
*
,
ExecutionSpace
>
keys
;
sum
(
Kokkos
::
View
<
Scalar
*
,
ExecutionSpace
>
keys_
)
:
keys
(
keys_
)
{}
KOKKOS_INLINE_FUNCTION
void
operator
()
(
int
i
,
double
&
count
)
const
{
count
+=
keys
(
i
);
}
};
template
<
class
ExecutionSpace
,
class
Scalar
>
struct
bin3d_is_sorted_struct
{
typedef
unsigned
int
value_type
;
typedef
ExecutionSpace
execution_space
;
Kokkos
::
View
<
Scalar
*
[
3
],
ExecutionSpace
>
keys
;
int
max_bins
;
Scalar
min
;
Scalar
max
;
bin3d_is_sorted_struct
(
Kokkos
::
View
<
Scalar
*
[
3
],
ExecutionSpace
>
keys_
,
int
max_bins_
,
Scalar
min_
,
Scalar
max_
)
:
keys
(
keys_
),
max_bins
(
max_bins_
),
min
(
min_
),
max
(
max_
)
{
}
KOKKOS_INLINE_FUNCTION
void
operator
()
(
int
i
,
unsigned
int
&
count
)
const
{
int
ix1
=
int
((
keys
(
i
,
0
)
-
min
)
/
max
*
max_bins
);
int
iy1
=
int
((
keys
(
i
,
1
)
-
min
)
/
max
*
max_bins
);
int
iz1
=
int
((
keys
(
i
,
2
)
-
min
)
/
max
*
max_bins
);
int
ix2
=
int
((
keys
(
i
+
1
,
0
)
-
min
)
/
max
*
max_bins
);
int
iy2
=
int
((
keys
(
i
+
1
,
1
)
-
min
)
/
max
*
max_bins
);
int
iz2
=
int
((
keys
(
i
+
1
,
2
)
-
min
)
/
max
*
max_bins
);
if
(
ix1
>
ix2
)
count
++
;
else
if
(
ix1
==
ix2
)
{
if
(
iy1
>
iy2
)
count
++
;
else
if
((
iy1
==
iy2
)
&&
(
iz1
>
iz2
))
count
++
;
}
}
};
template
<
class
ExecutionSpace
,
class
Scalar
>
struct
sum3D
{
typedef
double
value_type
;
typedef
ExecutionSpace
execution_space
;
Kokkos
::
View
<
Scalar
*
[
3
],
ExecutionSpace
>
keys
;
sum3D
(
Kokkos
::
View
<
Scalar
*
[
3
],
ExecutionSpace
>
keys_
)
:
keys
(
keys_
)
{}
KOKKOS_INLINE_FUNCTION
void
operator
()
(
int
i
,
double
&
count
)
const
{
count
+=
keys
(
i
,
0
);
count
+=
keys
(
i
,
1
);
count
+=
keys
(
i
,
2
);
}
};
template
<
class
ExecutionSpace
,
typename
KeyType
>
void
test_1D_sort
(
unsigned
int
n
,
bool
force_kokkos
)
{
typedef
Kokkos
::
View
<
KeyType
*
,
ExecutionSpace
>
KeyViewType
;
KeyViewType
keys
(
"Keys"
,
n
);
Kokkos
::
Random_XorShift64_Pool
<
ExecutionSpace
>
g
(
1931
);
Kokkos
::
fill_random
(
keys
,
g
,
Kokkos
::
Random_XorShift64_Pool
<
ExecutionSpace
>::
generator_type
::
MAX_URAND
);
double
sum_before
=
0.0
;
double
sum_after
=
0.0
;
unsigned
int
sort_fails
=
0
;
Kokkos
::
parallel_reduce
(
n
,
sum
<
ExecutionSpace
,
KeyType
>
(
keys
),
sum_before
);
Kokkos
::
sort
(
keys
,
force_kokkos
);
Kokkos
::
parallel_reduce
(
n
,
sum
<
ExecutionSpace
,
KeyType
>
(
keys
),
sum_after
);
Kokkos
::
parallel_reduce
(
n
-
1
,
is_sorted_struct
<
ExecutionSpace
,
KeyType
>
(
keys
),
sort_fails
);
double
ratio
=
sum_before
/
sum_after
;
double
epsilon
=
1e-10
;
unsigned
int
equal_sum
=
(
ratio
>
(
1.0
-
epsilon
))
&&
(
ratio
<
(
1.0
+
epsilon
))
?
1
:
0
;
ASSERT_EQ
(
sort_fails
,
0
);
ASSERT_EQ
(
equal_sum
,
1
);
}
template
<
class
ExecutionSpace
,
typename
KeyType
>
void
test_3D_sort
(
unsigned
int
n
)
{
typedef
Kokkos
::
View
<
KeyType
*
[
3
],
ExecutionSpace
>
KeyViewType
;
KeyViewType
keys
(
"Keys"
,
n
*
n
*
n
);
Kokkos
::
Random_XorShift64_Pool
<
ExecutionSpace
>
g
(
1931
);
Kokkos
::
fill_random
(
keys
,
g
,
100.0
);
double
sum_before
=
0.0
;
double
sum_after
=
0.0
;
unsigned
int
sort_fails
=
0
;
Kokkos
::
parallel_reduce
(
keys
.
dimension_0
(),
sum3D
<
ExecutionSpace
,
KeyType
>
(
keys
),
sum_before
);
int
bin_1d
=
1
;
while
(
bin_1d
*
bin_1d
*
bin_1d
*
4
<
(
int
)
keys
.
dimension_0
()
)
bin_1d
*=
2
;
int
bin_max
[
3
]
=
{
bin_1d
,
bin_1d
,
bin_1d
};
typename
KeyViewType
::
value_type
min
[
3
]
=
{
0
,
0
,
0
};
typename
KeyViewType
::
value_type
max
[
3
]
=
{
100
,
100
,
100
};
typedef
Kokkos
::
SortImpl
::
DefaultBinOp3D
<
KeyViewType
>
BinOp
;
BinOp
bin_op
(
bin_max
,
min
,
max
);
Kokkos
::
BinSort
<
KeyViewType
,
BinOp
>
Sorter
(
keys
,
bin_op
,
false
);
Sorter
.
create_permute_vector
();
Sorter
.
template
sort
<
KeyViewType
>
(
keys
);
Kokkos
::
parallel_reduce
(
keys
.
dimension_0
(),
sum3D
<
ExecutionSpace
,
KeyType
>
(
keys
),
sum_after
);
Kokkos
::
parallel_reduce
(
keys
.
dimension_0
()
-
1
,
bin3d_is_sorted_struct
<
ExecutionSpace
,
KeyType
>
(
keys
,
bin_1d
,
min
[
0
],
max
[
0
]),
sort_fails
);
double
ratio
=
sum_before
/
sum_after
;
double
epsilon
=
1e-10
;
unsigned
int
equal_sum
=
(
ratio
>
(
1.0
-
epsilon
))
&&
(
ratio
<
(
1.0
+
epsilon
))
?
1
:
0
;
printf
(
"3D Sort Sum: %f %f Fails: %u
\n
"
,
sum_before
,
sum_after
,
sort_fails
);
ASSERT_EQ
(
sort_fails
,
0
);
ASSERT_EQ
(
equal_sum
,
1
);
}
template
<
class
ExecutionSpace
,
typename
KeyType
>
void
test_sort
(
unsigned
int
N
)
{
test_1D_sort
<
ExecutionSpace
,
KeyType
>
(
N
*
N
*
N
,
true
);
test_1D_sort
<
ExecutionSpace
,
KeyType
>
(
N
*
N
*
N
,
false
);
test_3D_sort
<
ExecutionSpace
,
KeyType
>
(
N
);
}
}
}
#endif
/* TESTSORT_HPP_ */
Event Timeline
Log In to Comment