10 #ifndef TPETRA_DETAILS_PACKCRSMATRIX_DEF_HPP
11 #define TPETRA_DETAILS_PACKCRSMATRIX_DEF_HPP
13 #include "TpetraCore_config.h"
14 #include "Teuchos_Array.hpp"
15 #include "Teuchos_ArrayView.hpp"
59 namespace PackCrsMatrixImpl {
67 template<
class OutputOffsetsViewType,
69 class InputOffsetsViewType,
70 class InputLocalRowIndicesViewType,
71 class InputLocalRowPidsViewType,
73 #ifdef HAVE_TPETRA_DEBUG
77 #endif // HAVE_TPETRA_DEBUG
81 typedef typename OutputOffsetsViewType::non_const_value_type output_offset_type;
82 typedef typename CountsViewType::non_const_value_type count_type;
83 typedef typename InputOffsetsViewType::non_const_value_type input_offset_type;
84 typedef typename InputLocalRowIndicesViewType::non_const_value_type local_row_index_type;
85 typedef typename InputLocalRowPidsViewType::non_const_value_type local_row_pid_type;
87 typedef typename OutputOffsetsViewType::device_type device_type;
88 static_assert (std::is_same<
typename CountsViewType::device_type::execution_space,
89 typename device_type::execution_space>::value,
90 "OutputOffsetsViewType and CountsViewType must have the same execution space.");
91 static_assert (Kokkos::is_view<OutputOffsetsViewType>::value,
92 "OutputOffsetsViewType must be a Kokkos::View.");
93 static_assert (std::is_same<typename OutputOffsetsViewType::value_type, output_offset_type>::value,
94 "OutputOffsetsViewType must be a nonconst Kokkos::View.");
95 static_assert (std::is_integral<output_offset_type>::value,
96 "The type of each entry of OutputOffsetsViewType must be a built-in integer type.");
97 static_assert (Kokkos::is_view<CountsViewType>::value,
98 "CountsViewType must be a Kokkos::View.");
99 static_assert (std::is_same<typename CountsViewType::value_type, output_offset_type>::value,
100 "CountsViewType must be a nonconst Kokkos::View.");
101 static_assert (std::is_integral<count_type>::value,
102 "The type of each entry of CountsViewType must be a built-in integer type.");
103 static_assert (Kokkos::is_view<InputOffsetsViewType>::value,
104 "InputOffsetsViewType must be a Kokkos::View.");
105 static_assert (std::is_integral<input_offset_type>::value,
106 "The type of each entry of InputOffsetsViewType must be a built-in integer type.");
107 static_assert (Kokkos::is_view<InputLocalRowIndicesViewType>::value,
108 "InputLocalRowIndicesViewType must be a Kokkos::View.");
109 static_assert (std::is_integral<local_row_index_type>::value,
110 "The type of each entry of InputLocalRowIndicesViewType must be a built-in integer type.");
113 const CountsViewType& counts,
114 const InputOffsetsViewType& rowOffsets,
115 const InputLocalRowIndicesViewType& lclRowInds,
116 const InputLocalRowPidsViewType& lclRowPids,
117 const count_type sizeOfLclCount,
118 const count_type sizeOfGblColInd,
119 const count_type sizeOfPid,
120 const count_type sizeOfValue) :
121 outputOffsets_ (outputOffsets),
123 rowOffsets_ (rowOffsets),
124 lclRowInds_ (lclRowInds),
125 lclRowPids_ (lclRowPids),
126 sizeOfLclCount_ (sizeOfLclCount),
127 sizeOfGblColInd_ (sizeOfGblColInd),
128 sizeOfPid_ (sizeOfPid),
129 sizeOfValue_ (sizeOfValue),
133 const size_t numRowsToPack =
static_cast<size_t> (lclRowInds_.extent (0));
135 if (numRowsToPack != static_cast<size_t> (counts_.extent (0))) {
136 std::ostringstream os;
137 os <<
"lclRowInds.extent(0) = " << numRowsToPack
138 <<
" != counts.extent(0) = " << counts_.extent (0)
140 TEUCHOS_TEST_FOR_EXCEPTION(
true, std::invalid_argument, os.str ());
142 if (static_cast<size_t> (numRowsToPack + 1) !=
143 static_cast<size_t> (outputOffsets_.extent (0))) {
144 std::ostringstream os;
145 os <<
"lclRowInds.extent(0) + 1 = " << (numRowsToPack + 1)
146 <<
" != outputOffsets.extent(0) = " << outputOffsets_.extent (0)
148 TEUCHOS_TEST_FOR_EXCEPTION(
true, std::invalid_argument, os.str ());
153 KOKKOS_INLINE_FUNCTION
void
154 operator() (
const local_row_index_type& curInd,
155 output_offset_type& update,
156 const bool final)
const
159 if (curInd < static_cast<local_row_index_type> (0)) {
167 if (curInd >= static_cast<local_row_index_type> (outputOffsets_.extent (0))) {
172 outputOffsets_(curInd) = update;
175 if (curInd < static_cast<local_row_index_type> (counts_.extent (0))) {
176 const auto lclRow = lclRowInds_(curInd);
177 if (static_cast<size_t> (lclRow + 1) >= static_cast<size_t> (rowOffsets_.extent (0)) ||
178 static_cast<local_row_index_type> (lclRow) <
static_cast<local_row_index_type
> (0)) {
186 const count_type count =
187 static_cast<count_type
> (rowOffsets_(lclRow+1) - rowOffsets_(lclRow));
193 const count_type numBytes = (count == 0) ?
194 static_cast<count_type> (0) :
195 sizeOfLclCount_ + count * (sizeOfGblColInd_ +
196 (lclRowPids_.size() > 0 ? sizeOfPid_ : 0) +
200 counts_(curInd) = numBytes;
212 typedef typename device_type::execution_space execution_space;
213 auto error_h = Kokkos::create_mirror_view (error_);
220 OutputOffsetsViewType outputOffsets_;
221 CountsViewType counts_;
222 typename InputOffsetsViewType::const_type rowOffsets_;
223 typename InputLocalRowIndicesViewType::const_type lclRowInds_;
224 typename InputLocalRowPidsViewType::const_type lclRowPids_;
225 count_type sizeOfLclCount_;
226 count_type sizeOfGblColInd_;
227 count_type sizeOfPid_;
228 count_type sizeOfValue_;
229 Kokkos::View<int, device_type> error_;
241 template<
class OutputOffsetsViewType,
242 class CountsViewType,
243 class InputOffsetsViewType,
244 class InputLocalRowIndicesViewType,
245 class InputLocalRowPidsViewType>
246 typename CountsViewType::non_const_value_type
247 computeNumPacketsAndOffsets (
const OutputOffsetsViewType& outputOffsets,
248 const CountsViewType& counts,
249 const InputOffsetsViewType& rowOffsets,
250 const InputLocalRowIndicesViewType& lclRowInds,
251 const InputLocalRowPidsViewType& lclRowPids,
252 const typename CountsViewType::non_const_value_type sizeOfLclCount,
253 const typename CountsViewType::non_const_value_type sizeOfGblColInd,
254 const typename CountsViewType::non_const_value_type sizeOfPid,
255 const typename CountsViewType::non_const_value_type sizeOfValue)
257 typedef NumPacketsAndOffsetsFunctor<OutputOffsetsViewType,
258 CountsViewType,
typename InputOffsetsViewType::const_type,
259 typename InputLocalRowIndicesViewType::const_type,
260 typename InputLocalRowPidsViewType::const_type> functor_type;
261 typedef typename CountsViewType::non_const_value_type count_type;
262 typedef typename OutputOffsetsViewType::size_type size_type;
263 typedef typename OutputOffsetsViewType::execution_space execution_space;
264 typedef typename functor_type::local_row_index_type LO;
265 typedef Kokkos::RangePolicy<execution_space, LO> range_type;
266 const char prefix[] =
"computeNumPacketsAndOffsets: ";
268 count_type count = 0;
269 const count_type numRowsToPack = lclRowInds.extent (0);
271 if (numRowsToPack == 0) {
275 TEUCHOS_TEST_FOR_EXCEPTION
276 (rowOffsets.extent (0) <=
static_cast<size_type
> (1),
277 std::invalid_argument, prefix <<
"There is at least one row to pack, "
278 "but the matrix has no rows. lclRowInds.extent(0) = " <<
279 numRowsToPack <<
", but rowOffsets.extent(0) = " <<
280 rowOffsets.extent (0) <<
" <= 1.");
281 TEUCHOS_TEST_FOR_EXCEPTION
282 (outputOffsets.extent (0) !=
283 static_cast<size_type
> (numRowsToPack + 1), std::invalid_argument,
284 prefix <<
"Output dimension does not match number of rows to pack. "
285 <<
"outputOffsets.extent(0) = " << outputOffsets.extent (0)
286 <<
" != lclRowInds.extent(0) + 1 = "
287 <<
static_cast<size_type
> (numRowsToPack + 1) <<
".");
288 TEUCHOS_TEST_FOR_EXCEPTION
289 (counts.extent (0) != numRowsToPack, std::invalid_argument,
290 prefix <<
"counts.extent(0) = " << counts.extent (0)
291 <<
" != numRowsToPack = " << numRowsToPack <<
".");
293 functor_type f (outputOffsets, counts, rowOffsets,
294 lclRowInds, lclRowPids, sizeOfLclCount,
295 sizeOfGblColInd, sizeOfPid, sizeOfValue);
296 Kokkos::parallel_scan (range_type (0, numRowsToPack + 1), f);
299 const int errCode = f.getError ();
300 TEUCHOS_TEST_FOR_EXCEPTION
301 (errCode != 0, std::runtime_error, prefix <<
"parallel_scan error code "
302 << errCode <<
" != 0.");
306 for (LO k = 0; k < numRowsToPack; ++k) {
309 if (outputOffsets(numRowsToPack) != total) {
310 if (errStr.get () == NULL) {
311 errStr = std::unique_ptr<std::ostringstream> (
new std::ostringstream ());
313 std::ostringstream& os = *errStr;
315 <<
"outputOffsets(numRowsToPack=" << numRowsToPack <<
") "
316 << outputOffsets(numRowsToPack) <<
" != sum of counts = "
317 << total <<
"." << std::endl;
318 if (numRowsToPack != 0) {
320 if (numRowsToPack < static_cast<LO> (10)) {
321 os <<
"outputOffsets: [";
322 for (LO i = 0; i <= numRowsToPack; ++i) {
323 os << outputOffsets(i);
324 if (static_cast<LO> (i + 1) <= numRowsToPack) {
328 os <<
"]" << std::endl;
330 for (LO i = 0; i < numRowsToPack; ++i) {
332 if (static_cast<LO> (i + 1) < numRowsToPack) {
336 os <<
"]" << std::endl;
339 os <<
"outputOffsets(" << (numRowsToPack-1) <<
") = "
340 << outputOffsets(numRowsToPack-1) <<
"." << std::endl;
343 count = outputOffsets(numRowsToPack);
344 return {
false, errStr};
346 #endif // HAVE_TPETRA_DEBUG
350 using Tpetra::Details::getEntryOnHost;
351 return static_cast<count_type
> (getEntryOnHost (outputOffsets,
371 template<
class ST,
class ColumnMap,
class BufferDeviceType>
373 Kokkos::pair<int, size_t>
374 packCrsMatrixRow (
const ColumnMap& col_map,
375 const Kokkos::View<char*, BufferDeviceType>& exports,
376 const typename PackTraits<typename ColumnMap::local_ordinal_type>::input_array_type& lids_in,
378 const typename PackTraits<ST>::input_array_type& vals_in,
380 const size_t num_ent,
381 const size_t num_bytes_per_value,
382 const bool pack_pids)
384 using Kokkos::subview;
385 using LO =
typename ColumnMap::local_ordinal_type;
386 using GO =
typename ColumnMap::global_ordinal_type;
387 using return_type = Kokkos::pair<int, size_t>;
391 return return_type (0, 0);
394 const LO num_ent_LO =
static_cast<LO
> (num_ent);
395 const size_t num_ent_beg = offset;
398 const size_t gids_beg = num_ent_beg + num_ent_len;
401 const size_t pids_beg = gids_beg + gids_len;
402 const size_t pids_len = pack_pids ?
404 static_cast<size_t> (0);
406 const size_t vals_beg = gids_beg + gids_len + pids_len;
407 const size_t vals_len = num_ent * num_bytes_per_value;
409 char*
const num_ent_out = exports.data () + num_ent_beg;
410 char*
const gids_out = exports.data () + gids_beg;
411 char*
const pids_out = pack_pids ? exports.data () + pids_beg : NULL;
412 char*
const vals_out = exports.data () + vals_beg;
414 size_t num_bytes_out = 0;
421 for (
size_t k = 0; k < num_ent; ++k) {
422 const LO lid = lids_in[k];
423 const GO gid = col_map.getGlobalElement (lid);
428 for (
size_t k = 0; k < num_ent; ++k) {
429 const LO lid = lids_in[k];
430 const int pid = pids_in[lid];
436 error_code += p.first;
437 num_bytes_out += p.second;
440 if (error_code != 0) {
441 return return_type (10, num_bytes_out);
444 const size_t expected_num_bytes =
445 num_ent_len + gids_len + pids_len + vals_len;
446 if (num_bytes_out != expected_num_bytes) {
447 return return_type (11, num_bytes_out);
449 return return_type (0, num_bytes_out);
452 template<
class LocalMatrix,
class LocalMap,
class BufferDeviceType>
453 struct PackCrsMatrixFunctor {
454 typedef LocalMatrix local_matrix_device_type;
455 typedef LocalMap local_map_type;
456 typedef typename local_matrix_device_type::value_type ST;
459 typedef typename local_matrix_device_type::device_type DT;
461 typedef Kokkos::View<const size_t*, BufferDeviceType>
462 num_packets_per_lid_view_type;
463 typedef Kokkos::View<const size_t*, BufferDeviceType> offsets_view_type;
464 typedef Kokkos::View<char*, BufferDeviceType> exports_view_type;
468 typedef typename num_packets_per_lid_view_type::non_const_value_type
470 typedef typename offsets_view_type::non_const_value_type
472 typedef Kokkos::pair<int, LO> value_type;
474 static_assert (std::is_same<LO, typename local_matrix_device_type::ordinal_type>::value,
475 "local_map_type::local_ordinal_type and "
476 "local_matrix_device_type::ordinal_type must be the same.");
478 local_matrix_device_type local_matrix;
479 local_map_type local_col_map;
480 exports_view_type exports;
481 num_packets_per_lid_view_type num_packets_per_lid;
482 export_lids_view_type export_lids;
483 source_pids_view_type source_pids;
484 offsets_view_type offsets;
485 size_t num_bytes_per_value;
488 PackCrsMatrixFunctor (
const local_matrix_device_type& local_matrix_in,
489 const local_map_type& local_col_map_in,
490 const exports_view_type& exports_in,
491 const num_packets_per_lid_view_type& num_packets_per_lid_in,
492 const export_lids_view_type& export_lids_in,
493 const source_pids_view_type& source_pids_in,
494 const offsets_view_type& offsets_in,
495 const size_t num_bytes_per_value_in,
496 const bool pack_pids_in) :
497 local_matrix (local_matrix_in),
498 local_col_map (local_col_map_in),
499 exports (exports_in),
500 num_packets_per_lid (num_packets_per_lid_in),
501 export_lids (export_lids_in),
502 source_pids (source_pids_in),
503 offsets (offsets_in),
504 num_bytes_per_value (num_bytes_per_value_in),
505 pack_pids (pack_pids_in)
507 const LO numRows = local_matrix_in.numRows ();
509 static_cast<LO
> (local_matrix.graph.row_map.extent (0));
510 TEUCHOS_TEST_FOR_EXCEPTION
511 (numRows != 0 && rowMapDim != numRows + static_cast<LO> (1),
512 std::logic_error,
"local_matrix.graph.row_map.extent(0) = "
513 << rowMapDim <<
" != numRows (= " << numRows <<
" ) + 1.");
516 KOKKOS_INLINE_FUNCTION
void init (value_type& dst)
const
518 using ::Tpetra::Details::OrdinalTraits;
519 dst = Kokkos::make_pair (0, OrdinalTraits<LO>::invalid ());
522 KOKKOS_INLINE_FUNCTION
void
523 join (value_type& dst,
const value_type& src)
const
527 if (src.first != 0 && dst.first == 0) {
532 KOKKOS_INLINE_FUNCTION
533 void operator() (
const LO i, value_type& dst)
const
535 const size_t offset = offsets[i];
536 const LO export_lid = export_lids[i];
537 const size_t buf_size = exports.size();
538 const size_t num_bytes = num_packets_per_lid(i);
539 const size_t num_ent =
540 static_cast<size_t> (local_matrix.graph.row_map[export_lid+1]
541 - local_matrix.graph.row_map[export_lid]);
551 if (export_lid >= local_matrix.numRows ()) {
552 if (dst.first != 0) {
553 dst = Kokkos::make_pair (1, i);
557 else if ((offset > buf_size || offset + num_bytes > buf_size)) {
558 if (dst.first != 0) {
559 dst = Kokkos::make_pair (2, i);
569 const auto row_beg = local_matrix.graph.row_map[export_lid];
570 const auto row_end = local_matrix.graph.row_map[export_lid + 1];
571 auto vals_in = subview (local_matrix.values,
572 Kokkos::make_pair (row_beg, row_end));
573 auto lids_in = subview (local_matrix.graph.entries,
574 Kokkos::make_pair (row_beg, row_end));
575 typedef local_map_type LMT;
576 typedef BufferDeviceType BDT;
577 auto p = packCrsMatrixRow<ST, LMT, BDT> (local_col_map, exports, lids_in,
578 source_pids, vals_in, offset,
579 num_ent, num_bytes_per_value,
581 int error_code_this_row = p.first;
582 size_t num_bytes_packed_this_row = p.second;
583 if (error_code_this_row != 0) {
584 if (dst.first != 0) {
585 dst = Kokkos::make_pair (error_code_this_row, i);
588 else if (num_bytes_packed_this_row != num_bytes) {
589 if (dst.first != 0) {
590 dst = Kokkos::make_pair (3, i);
603 template<
class LocalMatrix,
class LocalMap,
class BufferDeviceType>
605 do_pack (
const LocalMatrix& local_matrix,
606 const LocalMap& local_map,
607 const Kokkos::View<char*, BufferDeviceType>& exports,
608 const typename PackTraits<size_t>::input_array_type& num_packets_per_lid,
609 const typename PackTraits<typename LocalMap::local_ordinal_type>::input_array_type& export_lids,
611 const Kokkos::View<const size_t*, BufferDeviceType>& offsets,
612 const size_t num_bytes_per_value,
613 const bool pack_pids)
616 using DT =
typename LocalMatrix::device_type;
617 using range_type = Kokkos::RangePolicy<typename DT::execution_space, LO>;
618 const char prefix[] =
"Tpetra::Details::do_pack: ";
620 if (export_lids.extent (0) != 0) {
621 TEUCHOS_TEST_FOR_EXCEPTION
622 (static_cast<size_t> (offsets.extent (0)) !=
623 static_cast<size_t> (export_lids.extent (0) + 1),
624 std::invalid_argument, prefix <<
"offsets.extent(0) = "
625 << offsets.extent (0) <<
" != export_lids.extent(0) (= "
626 << export_lids.extent (0) <<
") + 1.");
627 TEUCHOS_TEST_FOR_EXCEPTION
628 (export_lids.extent (0) != num_packets_per_lid.extent (0),
629 std::invalid_argument, prefix <<
"export_lids.extent(0) = " <<
630 export_lids.extent (0) <<
" != num_packets_per_lid.extent(0) = "
631 << num_packets_per_lid.extent (0) <<
".");
635 TEUCHOS_TEST_FOR_EXCEPTION
636 (pack_pids && exports.extent (0) != 0 &&
637 source_pids.extent (0) == 0, std::invalid_argument, prefix <<
638 "pack_pids is true, and exports.extent(0) = " <<
639 exports.extent (0) <<
" != 0, meaning that we need to pack at "
640 "least one matrix entry, but source_pids.extent(0) = 0.");
643 using pack_functor_type =
644 PackCrsMatrixFunctor<LocalMatrix, LocalMap, BufferDeviceType>;
645 pack_functor_type f (local_matrix, local_map, exports,
646 num_packets_per_lid, export_lids,
647 source_pids, offsets, num_bytes_per_value,
650 typename pack_functor_type::value_type result;
651 range_type range (0, num_packets_per_lid.extent (0));
652 Kokkos::parallel_reduce (range, f, result);
654 if (result.first != 0) {
657 TEUCHOS_TEST_FOR_EXCEPTION
658 (
true, std::runtime_error, prefix <<
"PackCrsMatrixFunctor "
659 "reported error code " << result.first <<
" for the first "
660 "bad row " << result.second <<
".");
693 template<
typename ST,
typename LO,
typename GO,
typename NT,
typename BufferDeviceType>
695 packCrsMatrix (
const CrsMatrix<ST, LO, GO, NT>& sourceMatrix,
696 Kokkos::DualView<char*, BufferDeviceType>& exports,
697 const Kokkos::View<size_t*, BufferDeviceType>& num_packets_per_lid,
698 const Kokkos::View<const LO*, BufferDeviceType>& export_lids,
699 const Kokkos::View<const int*, typename NT::device_type>& export_pids,
700 size_t& constant_num_packets,
701 const bool pack_pids)
704 "Tpetra::Details::PackCrsMatrixImpl::packCrsMatrix",
708 typedef BufferDeviceType DT;
709 typedef Kokkos::DualView<char*, BufferDeviceType> exports_view_type;
710 const char prefix[] =
"Tpetra::Details::PackCrsMatrixImpl::packCrsMatrix: ";
711 constexpr
bool debug =
false;
713 auto local_matrix = sourceMatrix.getLocalMatrixDevice ();
714 auto local_col_map = sourceMatrix.getColMap ()->getLocalMap ();
719 constant_num_packets = 0;
721 const size_t num_export_lids =
722 static_cast<size_t> (export_lids.extent (0));
723 TEUCHOS_TEST_FOR_EXCEPTION
725 static_cast<size_t> (num_packets_per_lid.extent (0)),
726 std::invalid_argument, prefix <<
"num_export_lids.extent(0) = "
727 << num_export_lids <<
" != num_packets_per_lid.extent(0) = "
728 << num_packets_per_lid.extent (0) <<
".");
729 if (num_export_lids != 0) {
730 TEUCHOS_TEST_FOR_EXCEPTION
731 (num_packets_per_lid.data () == NULL, std::invalid_argument,
732 prefix <<
"num_export_lids = "<< num_export_lids <<
" != 0, but "
733 "num_packets_per_lid.data() = "
734 << num_packets_per_lid.data () <<
" == NULL.");
741 size_t num_bytes_per_value = 0;
742 if (PackTraits<ST>::compileTimeSize) {
756 size_t num_bytes_per_value_l = 0;
757 if (local_matrix.values.extent(0) > 0) {
758 const ST& val = local_matrix.values(0);
761 using Teuchos::reduceAll;
762 reduceAll<int, size_t> (* (sourceMatrix.getComm ()),
764 num_bytes_per_value_l,
765 Teuchos::outArg (num_bytes_per_value));
768 if (num_export_lids == 0) {
769 exports = exports_view_type (
"exports", 0);
774 Kokkos::View<size_t*, DT> offsets (
"offsets", num_export_lids + 1);
779 computeNumPacketsAndOffsets (offsets, num_packets_per_lid,
780 local_matrix.graph.row_map, export_lids,
782 num_bytes_per_lid, num_bytes_per_gid,
783 num_bytes_per_pid, num_bytes_per_value);
786 if (count > static_cast<size_t> (exports.extent (0))) {
787 exports = exports_view_type (
"exports", count);
789 std::ostringstream os;
790 os <<
"*** exports resized to " << count << std::endl;
791 std::cerr << os.str ();
795 std::ostringstream os;
796 os <<
"*** count: " << count <<
", exports.extent(0): "
797 << exports.extent (0) << std::endl;
798 std::cerr << os.str ();
804 TEUCHOS_TEST_FOR_EXCEPTION
805 (pack_pids && exports.extent (0) != 0 &&
806 export_pids.extent (0) == 0, std::invalid_argument, prefix <<
807 "pack_pids is true, and exports.extent(0) = " <<
808 exports.extent (0) <<
" != 0, meaning that we need to pack at least "
809 "one matrix entry, but export_pids.extent(0) = 0.");
811 typedef typename std::decay<decltype (local_matrix)>::type
812 local_matrix_device_type;
813 typedef typename std::decay<decltype (local_col_map)>::type
816 exports.modify_device ();
817 auto exports_d = exports.view_device ();
818 do_pack<local_matrix_device_type, local_map_type, DT>
819 (local_matrix, local_col_map, exports_d, num_packets_per_lid,
820 export_lids, export_pids, offsets, num_bytes_per_value,
827 template<
typename ST,
typename LO,
typename GO,
typename NT>
830 Teuchos::Array<char>& exports,
831 const Teuchos::ArrayView<size_t>& numPacketsPerLID,
832 const Teuchos::ArrayView<const LO>& exportLIDs,
833 size_t& constantNumPackets)
838 using host_exec_space =
typename Kokkos::View<size_t*, device_type>::HostMirror::execution_space;
839 using device_exec_space =
typename device_type::execution_space;
840 using host_dev_type = Kokkos::Device<host_exec_space, Kokkos::HostSpace>;
846 Kokkos::View<size_t*, buffer_device_type> num_packets_per_lid_d =
848 numPacketsPerLID.getRawPtr (),
849 numPacketsPerLID.size (),
false,
850 "num_packets_per_lid");
857 Kokkos::View<const LO*, buffer_device_type> export_lids_d =
859 exportLIDs.getRawPtr (),
860 exportLIDs.size (),
true,
863 Kokkos::View<int*, device_type> export_pids_d;
864 Kokkos::DualView<char*, buffer_device_type> exports_dv;
865 constexpr
bool pack_pids =
false;
866 PackCrsMatrixImpl::packCrsMatrix<ST, LO, GO, NT, buffer_device_type> (
867 sourceMatrix, exports_dv, num_packets_per_lid_d, export_lids_d,
868 export_pids_d, constantNumPackets, pack_pids);
872 Kokkos::View<size_t*, host_dev_type> num_packets_per_lid_h
873 (numPacketsPerLID.getRawPtr (),
874 numPacketsPerLID.size ());
876 Kokkos::deep_copy (device_exec_space(), num_packets_per_lid_h, num_packets_per_lid_d);
883 if (static_cast<size_t> (exports.size ()) !=
884 static_cast<size_t> (exports_dv.extent (0))) {
885 exports.resize (exports_dv.extent (0));
887 Kokkos::View<char*, host_dev_type> exports_h (exports.getRawPtr (),
893 template<
typename ST,
typename LO,
typename GO,
typename NT>
900 size_t& constantNumPackets)
906 Kokkos::View<int*, device_type> exportPIDs_d (
"exportPIDs", 0);
907 constexpr
bool pack_pids =
false;
910 auto numPacketsPerLID_nc = numPacketsPerLID;
911 numPacketsPerLID_nc.clear_sync_state ();
912 numPacketsPerLID_nc.modify_device ();
913 auto numPacketsPerLID_d = numPacketsPerLID.view_device ();
916 TEUCHOS_ASSERT( ! exportLIDs.need_sync_device () );
917 auto exportLIDs_d = exportLIDs.view_device ();
920 "Tpetra::Details::packCrsMatrixNew",
923 PackCrsMatrixImpl::packCrsMatrix<ST,LO,GO,NT,buffer_device_type> (
924 sourceMatrix, exports, numPacketsPerLID_d, exportLIDs_d,
925 exportPIDs_d, constantNumPackets, pack_pids);
928 template<
typename ST,
typename LO,
typename GO,
typename NT>
932 const Teuchos::ArrayView<size_t>& numPacketsPerLID,
933 const Teuchos::ArrayView<const LO>& exportLIDs,
934 const Teuchos::ArrayView<const int>& sourcePIDs,
935 size_t& constantNumPackets)
939 typedef typename Kokkos::DualView<char*, buffer_device_type>::t_host::execution_space host_exec_space;
940 typedef Kokkos::Device<host_exec_space, Kokkos::HostSpace> host_dev_type;
942 typename local_matrix_device_type::device_type outputDevice;
943 typedef typename NT::execution_space execution_space;
947 std::unique_ptr<std::string> prefix;
949 const int myRank = [&] () {
950 auto map = sourceMatrix.
getMap ();
951 if (map.get () ==
nullptr) {
954 auto comm = map->getComm ();
955 if (comm.get () ==
nullptr) {
958 return comm->getRank ();
960 std::ostringstream os;
961 os <<
"Proc " << myRank <<
": packCrsMatrixWithOwningPIDs: ";
962 prefix = std::unique_ptr<std::string> (
new std::string (os.str ()));
964 std::ostringstream os2;
965 os2 << *prefix <<
"start" << std::endl;
966 std::cerr << os2.str ();
973 auto num_packets_per_lid_d =
975 numPacketsPerLID.getRawPtr (),
976 numPacketsPerLID.size (),
false,
977 "num_packets_per_lid");
983 exportLIDs.getRawPtr (),
984 exportLIDs.size (),
true,
990 sourcePIDs.getRawPtr (),
991 sourcePIDs.size (),
true,
993 constexpr
bool pack_pids =
true;
996 (sourceMatrix, exports_dv, num_packets_per_lid_d, export_lids_d,
997 export_pids_d, constantNumPackets, pack_pids);
999 catch (std::exception& e) {
1001 std::ostringstream os;
1002 os << *prefix <<
"PackCrsMatrixImpl::packCrsMatrix threw: "
1003 << e.what () << std::endl;
1004 std::cerr << os.str ();
1010 std::ostringstream os;
1011 os << *prefix <<
"PackCrsMatrixImpl::packCrsMatrix threw an exception "
1012 "not a subclass of std::exception" << std::endl;
1013 std::cerr << os.str ();
1018 if (numPacketsPerLID.size () != 0) {
1022 Kokkos::View<size_t*, host_dev_type> num_packets_per_lid_h
1023 (numPacketsPerLID.getRawPtr (), numPacketsPerLID.size ());
1025 Kokkos::deep_copy (execution_space(), num_packets_per_lid_h, num_packets_per_lid_d);
1027 catch (std::exception& e) {
1029 std::ostringstream os;
1030 os << *prefix <<
"Kokkos::deep_copy threw: " << e.what () << std::endl;
1031 std::cerr << os.str ();
1037 std::ostringstream os;
1038 os << *prefix <<
"Kokkos::deep_copy threw an exception not a subclass "
1039 "of std::exception" << std::endl;
1040 std::cerr << os.str ();
1047 std::ostringstream os;
1048 os << *prefix <<
"done" << std::endl;
1049 std::cerr << os.str ();
1056 #define TPETRA_DETAILS_PACKCRSMATRIX_INSTANT( ST, LO, GO, NT ) \
1058 Details::packCrsMatrix<ST, LO, GO, NT> (const CrsMatrix<ST, LO, GO, NT>&, \
1059 Teuchos::Array<char>&, \
1060 const Teuchos::ArrayView<size_t>&, \
1061 const Teuchos::ArrayView<const LO>&, \
1064 Details::packCrsMatrixNew<ST, LO, GO, NT> (const CrsMatrix<ST, LO, GO, NT>&, \
1065 Kokkos::DualView<char*, DistObject<char, LO, GO, NT>::buffer_device_type>&, \
1066 const Kokkos::DualView<size_t*, DistObject<char, LO, GO, NT>::buffer_device_type>&, \
1067 const Kokkos::DualView<const LO*, DistObject<char, LO, GO, NT>::buffer_device_type>&, \
1070 Details::packCrsMatrixWithOwningPIDs<ST, LO, GO, NT> (const CrsMatrix<ST, LO, GO, NT>&, \
1071 Kokkos::DualView<char*, DistObject<char, LO, GO, NT>::buffer_device_type>&, \
1072 const Teuchos::ArrayView<size_t>&, \
1073 const Teuchos::ArrayView<const LO>&, \
1074 const Teuchos::ArrayView<const int>&, \
1077 #endif // TPETRA_DETAILS_PACKCRSMATRIX_DEF_HPP
GlobalOrdinal global_ordinal_type
The type of global indices.
Impl::CreateMirrorViewFromUnmanagedHostArray< ValueType, OutputDeviceType >::output_view_type create_mirror_view_from_raw_host_array(const OutputDeviceType &, ValueType *inPtr, const size_t inSize, const bool copy=true, const char label[]="")
Variant of Kokkos::create_mirror_view that takes a raw host 1-d array as input.
Sparse matrix that presents a row-oriented interface that lets users read or modify entries...
Import KokkosSparse::OrdinalTraits, a traits class for "invalid" (flag) values of integer types...
Declaration of Tpetra::Details::Profiling, a scope guard for Kokkos Profiling.
static KOKKOS_INLINE_FUNCTION Kokkos::pair< int, size_t > packArray(char outBuf[], const value_type inBuf[], const size_t numEnt)
Pack the first numEnt entries of the given input buffer of value_type, into the output buffer of byte...
Declaration of the Tpetra::CrsMatrix class.
Declaration and generic definition of traits class that tells Tpetra::CrsMatrix how to pack and unpac...
KokkosSparse::CrsMatrix< impl_scalar_type, local_ordinal_type, device_type, void, typename local_graph_device_type::size_type > local_matrix_device_type
The specialization of Kokkos::CrsMatrix that represents the part of the sparse matrix on each MPI pro...
int getError() const
Host function for getting the error.
void deep_copy(MultiVector< DS, DL, DG, DN > &dst, const MultiVector< SS, SL, SG, SN > &src)
Copy the contents of the MultiVector src into dst.
static KOKKOS_INLINE_FUNCTION size_t packValue(char outBuf[], const T &inVal)
Pack the given value of type value_type into the given output buffer of bytes (char).
Compute the number of packets and offsets for the pack procedure.
void packCrsMatrixNew(const CrsMatrix< ST, LO, GO, NT > &sourceMatrix, Kokkos::DualView< char *, typename DistObject< char, LO, GO, NT >::buffer_device_type > &exports, const Kokkos::DualView< size_t *, typename DistObject< char, LO, GO, NT >::buffer_device_type > &numPacketsPerLID, const Kokkos::DualView< const LO *, typename DistObject< char, LO, GO, NT >::buffer_device_type > &exportLIDs, size_t &constantNumPackets)
Pack specified entries of the given local sparse matrix for communication, for "new" DistObject inter...
static bool verbose()
Whether Tpetra is in verbose mode.
typename Node::device_type device_type
The Kokkos device type.
void packCrsMatrix(const CrsMatrix< ST, LO, GO, NT > &sourceMatrix, Teuchos::Array< char > &exports, const Teuchos::ArrayView< size_t > &numPacketsPerLID, const Teuchos::ArrayView< const LO > &exportLIDs, size_t &constantNumPackets)
Pack specified entries of the given local sparse matrix for communication.
Kokkos::View< const value_type *, Kokkos::AnonymousSpace > input_array_type
The type of an input array of value_type.
static KOKKOS_INLINE_FUNCTION size_t packValueCount(const T &)
Number of bytes required to pack or unpack the given value of type value_type.
Declaration and definition of Tpetra::Details::castAwayConstDualView, an implementation detail of Tpe...
virtual Teuchos::RCP< const map_type > getMap() const
The Map describing the parallel distribution of this object.
Declaration and definition of Tpetra::Details::getEntryOnHost.
void packCrsMatrixWithOwningPIDs(const CrsMatrix< ST, LO, GO, NT > &sourceMatrix, Kokkos::DualView< char *, typename DistObject< char, LO, GO, NT >::buffer_device_type > &exports_dv, const Teuchos::ArrayView< size_t > &numPacketsPerLID, const Teuchos::ArrayView< const LO > &exportLIDs, const Teuchos::ArrayView< const int > &sourcePIDs, size_t &constantNumPackets)
Pack specified entries of the given local sparse matrix for communication.
Base class for distributed Tpetra objects that support data redistribution.
LocalOrdinal local_ordinal_type
The type of local indices.
Functions that wrap Kokkos::create_mirror_view, in order to avoid deep copies when not necessary...
Declaration of Tpetra::Details::Behavior, a class that describes Tpetra's behavior.