Zoltan2
Loading...
Searching...
No Matches
kokkosBlock.cpp
Go to the documentation of this file.
1// @HEADER
2//
3// ***********************************************************************
4//
5// Zoltan2: A package of combinatorial algorithms for scientific computing
6// Copyright 2012 Sandia Corporation
7//
8// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9// the U.S. Government retains certain rights in this software.
10//
11// Redistribution and use in source and binary forms, with or without
12// modification, are permitted provided that the following conditions are
13// met:
14//
15// 1. Redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer.
17//
18// 2. Redistributions in binary form must reproduce the above copyright
19// notice, this list of conditions and the following disclaimer in the
20// documentation and/or other materials provided with the distribution.
21//
22// 3. Neither the name of the Corporation nor the names of the
23// contributors may be used to endorse or promote products derived from
24// this software without specific prior written permission.
25//
26// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37//
38// Questions? Contact Karen Devine (kddevin@sandia.gov)
39// Erik Boman (egboman@sandia.gov)
40// Siva Rajamanickam (srajama@sandia.gov)
41//
42// ***********************************************************************
43//
44// @HEADER
45
50#include <Kokkos_Core.hpp>
51#include <Teuchos_DefaultComm.hpp>
55
56using Teuchos::Comm;
57using Teuchos::RCP;
58
65int main(int narg, char *arg[]) {
66 Tpetra::ScopeGuard tscope(&narg, &arg);
67 Teuchos::RCP<const Teuchos::Comm<int> > comm = Tpetra::getDefaultComm();
68
69 int rank = comm->getRank();
70 int nprocs = comm->getSize();
71
72 // For convenience, we'll use the Tpetra defaults for local/global ID types
73 // Users can substitute their preferred local/global ID types
74 typedef Tpetra::Map<> Map_t;
75 typedef Map_t::local_ordinal_type localId_t;
76 typedef Map_t::global_ordinal_type globalId_t;
77 typedef Tpetra::Details::DefaultTypes::scalar_type scalar_t;
78 typedef Tpetra::Map<>::node_type node_t;
79
81 // Generate some input data.
82
83 int localCount = 40 * (rank + 1);
84 int totalCount = 20 * nprocs * (nprocs + 1);
85 int targetCount = totalCount / nprocs;
86
87 Kokkos::View<globalId_t*, typename node_t::device_type>
88 globalIds(Kokkos::ViewAllocateWithoutInitializing("globalIds"), localCount);
89 auto host_globalIds = Kokkos::create_mirror_view(globalIds);
90
91 if (rank == 0) {
92 for (int i = 0, num = 40; i < nprocs ; i++, num += 40) {
93 std::cout << "Rank " << i << " generates " << num << " ids." << std::endl;
94 }
95 }
96
97 globalId_t offset = 0;
98 for (int i = 1; i <= rank; i++) {
99 offset += 40 * i;
100 }
101
102 for (int i = 0; i < localCount; i++) {
103 host_globalIds(i) = offset++;
104 }
105 Kokkos::deep_copy(globalIds, host_globalIds);
106
108 // Create a Zoltan2 input adapter with no weights
109
112
113 const int nWeights = 1;
114 Kokkos::View<scalar_t **, typename node_t::device_type>
115 weights("weights", localCount, nWeights);
116 auto host_weights = Kokkos::create_mirror_view(weights);
117
118 for (int index = 0; index < localCount; index++) {
119 host_weights(index, 0) = 1; // Error check relies on uniform weights
120 }
121
122 Kokkos::deep_copy(weights, host_weights);
123
124 inputAdapter_t ia(globalIds, weights);
125
127 // Create parameters for a Block problem
128
129 Teuchos::ParameterList params("test params");
130 params.set("debug_level", "basic_status");
131 params.set("debug_procs", "0");
132 params.set("error_check_level", "debug_mode_assertions");
133
134 params.set("algorithm", "block");
135 params.set("imbalance_tolerance", 1.1);
136 params.set("num_global_parts", nprocs);
137
139 // Create a Zoltan2 partitioning problem
140
143
145 // Solve the problem - do the partitioning
146
147 problem->solve();
148
150 // Check and print the solution.
151 // Count number of IDs assigned to each part; compare to targetCount
152
153 Kokkos::View<const globalId_t *, typename node_t::device_type> ids;
154 ia.getIDsKokkosView(ids);
155
156 auto host_ids = Kokkos::create_mirror_view(ids);
157 Kokkos::deep_copy(host_ids, ids);
158
159 Kokkos::View<int*, Kokkos::HostSpace> partCounts("partCounts", nprocs);
160
161 Kokkos::View<int*, Kokkos::HostSpace>
162 globalPartCounts("globalPartCounts", nprocs);
163
164 for (size_t i = 0; i < ia.getLocalNumIDs(); i++) {
165 int pp = problem->getSolution().getPartListView()[i];
166 std::cout << rank << " LID " << i << " GID " << host_ids(i)
167 << " PART " << pp << std::endl;
168 partCounts(pp)++;
169 }
170
171 Teuchos::reduceAll<int, int>(*comm, Teuchos::REDUCE_SUM, nprocs,
172 partCounts.data(), globalPartCounts.data());
173
174 if (rank == 0) {
175 int ierr = 0;
176 for (int i = 0; i < nprocs; i++) {
177 if (globalPartCounts(i) != targetCount) {
178 std::cout << "FAIL: part " << i << " has " << globalPartCounts(i)
179 << " != " << targetCount << "; " << ++ierr << " errors"
180 << std::endl;
181 }
182 }
183 if (ierr == 0) {
184 std::cout << "PASS" << std::endl;
185 }
186 }
187
188 delete problem;
189}
190
Defines the BasicKokkosIdentifierAdapter class.
Defines the PartitioningProblem class.
Defines the PartitioningSolution class.
int main()
This class represents a collection of global Identifiers and their associated weights,...
A simple class that can be the User template argument for an InputAdapter.
PartitioningProblem sets up partitioning problems for the user.
const PartitioningSolution< Adapter > & getSolution()
Get the solution to the problem.
void solve(bool updateInputData=true)
Direct the problem to create a solution.
static ArrayRCP< ArrayRCP< zscalar_t > > weights