Skip to content

Commit 54811d7

Browse files
grospelliergillesgrospelliergilles
authored
Merge pull request #1143 from arcaneframework/dev/gg-cleanup-parallel-reader-and-writer
Cleanup 'ParallelDataWriter' and 'ParallelDataReader'
2 parents bab6903 + 4170c5c commit 54811d7

File tree

4 files changed

+138
-208
lines changed

4 files changed

+138
-208
lines changed

‎arcane/src/arcane/std/ParallelDataReader.cc

+48-97
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
22
//-----------------------------------------------------------------------------
3-
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
3+
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
44
// See the top-level COPYRIGHT file for details.
55
// SPDX-License-Identifier: Apache-2.0
66
//-----------------------------------------------------------------------------
77
/*---------------------------------------------------------------------------*/
8-
/* ParallelDataReader.cc (C) 2000-2022 */
8+
/* ParallelDataReader.cc (C) 2000-2024 */
99
/* */
1010
/* Lecteur de IData en parallèle. */
1111
/*---------------------------------------------------------------------------*/
@@ -15,52 +15,24 @@
1515

1616
#include "arcane/utils/ScopedPtr.h"
1717
#include "arcane/utils/FatalErrorException.h"
18-
19-
#include "arcane/IParallelMng.h"
20-
#include "arcane/IParallelExchanger.h"
21-
#include "arcane/ISerializer.h"
22-
#include "arcane/ISerializeMessage.h"
23-
#include "arcane/SerializeBuffer.h"
24-
#include "arcane/IData.h"
25-
#include "arcane/parallel/BitonicSortT.H"
26-
#include "arcane/ParallelMngUtils.h"
18+
#include "arcane/utils/FixedArray.h"
19+
#include "arcane/utils/CheckedConvert.h"
20+
21+
#include "arcane/core/IParallelMng.h"
22+
#include "arcane/core/IParallelExchanger.h"
23+
#include "arcane/core/ISerializer.h"
24+
#include "arcane/core/ISerializeMessage.h"
25+
#include "arcane/core/SerializeBuffer.h"
26+
#include "arcane/core/IData.h"
27+
#include "arcane/core/parallel/BitonicSortT.H"
28+
#include "arcane/core/ParallelMngUtils.h"
2729

2830
/*---------------------------------------------------------------------------*/
2931
/*---------------------------------------------------------------------------*/
3032

3133
namespace Arcane
3234
{
3335

34-
/*---------------------------------------------------------------------------*/
35-
/*---------------------------------------------------------------------------*/
36-
// Dichotomie
37-
// Les xx doivent etre croissants
38-
template<typename T>
39-
class Bissection
40-
{
41-
public:
42-
static Integer locate(ConstArrayView<T> xx, T x)
43-
{
44-
Integer n = xx.size();
45-
if (x<xx[0] || x>xx[n-1])
46-
return (-1);
47-
if (x==xx[0])
48-
return 0;
49-
if (x==xx[n-1])
50-
return (n-1);
51-
Integer jl = 0;
52-
Integer ju = n;
53-
while (ju-jl > 1) {
54-
Integer jm = (ju+jl) >> 1;
55-
if (x >= xx[jm])
56-
jl = jm;
57-
else
58-
ju = jm;
59-
}
60-
return jl;
61-
}
62-
};
63-
6436
/*---------------------------------------------------------------------------*/
6537
/*---------------------------------------------------------------------------*/
6638
/*!
@@ -84,34 +56,39 @@ class ParallelDataReader::Impl
8456
: public TraceAccessor
8557
{
8658
public:
87-
Impl(IParallelMng* pm);
59+
60+
explicit Impl(IParallelMng* pm);
61+
8862
public:
8963

9064
Int64Array& writtenUniqueIds() { return m_written_unique_ids; }
9165
Int64Array& wantedUniqueIds() { return m_wanted_unique_ids; }
9266

9367
private:
9468

95-
IParallelMng* m_parallel_mng;
69+
IParallelMng* m_parallel_mng = nullptr;
9670

9771
Int32UniqueArray m_data_to_send_ranks;
9872
//TODO ne pas utiliser un tableau dimensionné au commSize()
99-
UniqueArray< SharedArray<Int32> > m_data_to_send_local_indexes;
100-
UniqueArray< SharedArray<Int32> > m_data_to_recv_indexes;
73+
UniqueArray<SharedArray<Int32>> m_data_to_send_local_indexes;
74+
UniqueArray<SharedArray<Int32>> m_data_to_recv_indexes;
10175
Int64UniqueArray m_written_unique_ids;
10276
Int64UniqueArray m_wanted_unique_ids;
10377
Int32UniqueArray m_local_send_indexes;
10478

10579
public:
10680

107-
public:
10881
void sort();
82+
10983
public:
110-
void getSortedValues(IData* written_data,IData* data);
84+
85+
void getSortedValues(IData* written_data, IData* data);
86+
11187
private:
88+
11289
void _searchUniqueIdIndexes(Int64ConstArrayView recv_uids,
11390
Int64ConstArrayView written_unique_ids,
114-
Int32Array& indexes);
91+
Int32Array& indexes) const;
11592
};
11693

11794
/*---------------------------------------------------------------------------*/
@@ -132,20 +109,23 @@ ParallelDataReader::
132109
delete m_p;
133110
}
134111

135-
Int64Array& ParallelDataReader::writtenUniqueIds()
112+
Array<Int64>& ParallelDataReader::
113+
writtenUniqueIds()
136114
{
137115
return m_p->writtenUniqueIds();
138116
}
139-
Int64Array& ParallelDataReader::
117+
Array<Int64>& ParallelDataReader::
140118
wantedUniqueIds()
141119
{
142120
return m_p->wantedUniqueIds();
143121
}
144-
void ParallelDataReader::sort()
122+
void ParallelDataReader::
123+
sort()
145124
{
146125
return m_p->sort();
147126
}
148-
void ParallelDataReader::getSortedValues(IData* written_data,IData* data)
127+
void ParallelDataReader::
128+
getSortedValues(IData* written_data, IData* data)
149129
{
150130
m_p->getSortedValues(written_data,data);
151131
}
@@ -166,14 +146,14 @@ Impl(IParallelMng* pm)
166146
void ParallelDataReader::Impl::
167147
sort()
168148
{
169-
Integer nb_wanted_uid = m_wanted_unique_ids.size();
170-
171-
Integer nb_rank = m_parallel_mng->commSize();
172-
Integer my_rank = m_parallel_mng->commRank();
149+
Int32 nb_wanted_uid = m_wanted_unique_ids.size();
150+
151+
Int32 nb_rank = m_parallel_mng->commSize();
152+
Int32 my_rank = m_parallel_mng->commRank();
173153

174154
Int64UniqueArray global_min_max_uid(nb_rank*2);
175155
{
176-
Int64 min_max_written_uid[2];
156+
FixedArray<Int64, 2> min_max_written_uid;
177157
min_max_written_uid[0] = NULL_ITEM_UNIQUE_ID;
178158
min_max_written_uid[1] = NULL_ITEM_UNIQUE_ID;
179159
Integer nb_written_uid = m_written_unique_ids.size();
@@ -184,18 +164,15 @@ sort()
184164
min_max_written_uid[0] = m_written_unique_ids[0];
185165
min_max_written_uid[1] = m_written_unique_ids[nb_written_uid-1];
186166
}
187-
m_parallel_mng->allGather(Int64ConstArrayView(2,min_max_written_uid),global_min_max_uid);
167+
m_parallel_mng->allGather(min_max_written_uid.view(), global_min_max_uid);
188168
}
189169
for( Integer irank=0; irank<nb_rank; ++irank )
190170
info(5) << "MIN_MAX_UIDS p=" << irank << " min=" << global_min_max_uid[irank*2]
191171
<< " max=" << global_min_max_uid[(irank*2)+1];
192172

193173
m_data_to_recv_indexes.resize(nb_rank);
194-
//Int32UniqueArray senders_rank(nb_rank);
195-
//senders_rank.fill(-1);
196174
{
197175
UniqueArray< SharedArray<Int64> > uids_list(nb_rank);
198-
//Integer current_sender = 0;
199176
auto exchanger { ParallelMngUtils::createExchangerRef(m_parallel_mng) };
200177
for( Integer i=0; i<nb_wanted_uid; ++i ){
201178
Int64 uid = m_wanted_unique_ids[i];
@@ -214,8 +191,6 @@ sort()
214191
if (rank!=my_rank){
215192
if (uids_list[rank].empty()){
216193
exchanger->addSender(rank);
217-
//senders_rank[rank] = current_sender;
218-
//uids_list.add(Int64UniqueArray());
219194
}
220195
uids_list[rank].add(uid);
221196
}
@@ -231,17 +206,10 @@ sort()
231206
ISerializeMessage* send_msg = exchanger->messageToSend(i);
232207
Int32 dest_rank = senders[i];
233208
ISerializer* serializer = send_msg->serializer();
234-
//Integer nb_to_send = uids_list[dest_rank].size();
235-
//indexes_to_recv[i] = own_indexes_list[dest_rank]; //indexes_list[dest_rank];
236-
//ranks_to_recv[i] = dest_rank;
237209
serializer->setMode(ISerializer::ModeReserve);
238-
//serializer->reserveInteger(1);
239-
//serializer->reserve(DT_Int32,nb_to_send);
240210
serializer->reserveArray(uids_list[dest_rank]);
241211
serializer->allocateBuffer();
242212
serializer->setMode(ISerializer::ModePut);
243-
//serializer->putInteger(nb_to_send);
244-
//serializer->put(indexes_list[dest_rank]);
245213
serializer->putArray(uids_list[dest_rank]);
246214
#if 0
247215
for( Integer z=0; z<nb_to_send; ++z ){
@@ -268,15 +236,6 @@ sort()
268236
Int64UniqueArray recv_uids;
269237
serializer->getArray(recv_uids);
270238
Int64 nb_to_recv = recv_uids.largeSize();
271-
//Int32ArrayView own_group_local_ids = own_group.internal()->itemsLocalId();
272-
//info() << " RECEIVE FROM A: NB_TO_RECEIVE " << nb_to_recv << " S2=" << own_group_local_ids.size();
273-
//for( Integer z=0; z<nb_to_recv; ++z ){
274-
//Integer index = recv_indexes[z];
275-
//info() << " RECV Z=" << z << " RANK=" << orig_rank << " index=" << index
276-
// << " index2=" << own_group_local_ids[index];
277-
//recv_indexes[z] = own_group_local_ids[index];
278-
//}
279-
//info() << "READ END RECEIVE FROM A: NB_TO_RECEIVE " << nb_to_recv;
280239

281240
m_data_to_send_local_indexes[i].resize(nb_to_recv);
282241
_searchUniqueIdIndexes(recv_uids,m_written_unique_ids,m_data_to_send_local_indexes[i]);
@@ -285,7 +244,6 @@ sort()
285244

286245
// Traite les données qui sont déjà présentes sur ce processeur.
287246
{
288-
Integer my_rank = m_parallel_mng->commRank();
289247
Int32Array& local_recv_indexes = m_data_to_recv_indexes[my_rank];
290248
Integer nb_local_index = local_recv_indexes.size();
291249
if (nb_local_index>0){
@@ -334,17 +292,9 @@ getSortedValues(IData* written_data,IData* data)
334292
// Traite les données qui sont déjà présente sur ce processeur.
335293
{
336294
Integer my_rank = m_parallel_mng->commRank();
337-
Int32Array& local_recv_indexes = m_data_to_recv_indexes[my_rank];
295+
ConstArrayView<Int32> local_recv_indexes = m_data_to_recv_indexes[my_rank];
338296
Integer nb_local_index = local_recv_indexes.size();
339297
if (nb_local_index>0){
340-
//Int32UniqueArray local_send_indexes(nb_local_index);
341-
//Int64UniqueArray uids(nb_local_index);
342-
343-
//for( Integer i=0; i<nb_local_index; ++i ){
344-
//uids[i] = m_wanted_unique_ids[local_recv_indexes[i]];
345-
//}
346-
//_searchUniqueIdIndexes(uids,m_written_unique_ids,local_send_indexes);
347-
348298
//info() << "SERIALIZE RESERVE";
349299
SerializeBuffer sbuf;
350300
sbuf.setMode(ISerializer::ModeReserve);
@@ -379,20 +329,21 @@ getSortedValues(IData* written_data,IData* data)
379329
void ParallelDataReader::Impl::
380330
_searchUniqueIdIndexes(Int64ConstArrayView recv_uids,
381331
Int64ConstArrayView written_unique_ids,
382-
Int32Array& indexes)
332+
Array<Int32>& indexes) const
383333
{
384334
Integer nb_to_recv = recv_uids.size();
385335
Integer nb_written_uid = written_unique_ids.size();
386336

387337
for( Integer irecv=0; irecv<nb_to_recv; ++irecv ){
388-
//Integer my_index = -1;
389338
Int64 my_uid = recv_uids[irecv];
390-
// Comme les writtent_unique_ids sont triés, on peut utiliser une dichotomie
391-
Integer my_index = Bissection<Int64>::locate(written_unique_ids,my_uid);
392-
//info() << "MY_INDEX=" << my_index << " my_uid=" << my_uid;
393-
if (my_index==(-1))
394-
ARCANE_FATAL("Can not find uid uid={0} (index={1})",my_uid,my_index);
395-
//info() << "MY_INDEX2=" << my_index << " my_uid=" << my_uid;
339+
// Comme les written_unique_ids sont triés, on peut utiliser une dichotomie
340+
auto iter_end = written_unique_ids.end();
341+
auto iter_begin = written_unique_ids.begin();
342+
auto x2 = std::lower_bound(iter_begin, iter_end, my_uid);
343+
if (x2 == iter_end)
344+
ARCANE_FATAL("Can not find uid uid={0} (with binary_search)", my_uid);
345+
Int32 my_index = CheckedConvert::toInt32(x2 - iter_begin);
346+
396347
// Teste si la dichotomie est correcte
397348
if (written_unique_ids[my_index]!=my_uid)
398349
ARCANE_FATAL("INTERNAL: bad index for bissection "

‎arcane/src/arcane/std/ParallelDataReader.h

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
22
//-----------------------------------------------------------------------------
3-
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
3+
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
44
// See the top-level COPYRIGHT file for details.
55
// SPDX-License-Identifier: Apache-2.0
66
//-----------------------------------------------------------------------------
77
/*---------------------------------------------------------------------------*/
8-
/* ParallelDataReader.h (C) 2000-2018 */
8+
/* ParallelDataReader.h (C) 2000-2024 */
99
/* */
1010
/* Lecteur de IData en parallèle. */
1111
/*---------------------------------------------------------------------------*/
@@ -49,14 +49,14 @@ class ParallelDataReader
4949

5050
public:
5151

52-
ParallelDataReader(IParallelMng* pm);
52+
explicit ParallelDataReader(IParallelMng* pm);
5353
ParallelDataReader(const ParallelDataReader& rhs) = delete;
5454
~ParallelDataReader();
5555

5656
public:
5757

58-
Int64Array& writtenUniqueIds();
59-
Int64Array& wantedUniqueIds();
58+
Array<Int64>& writtenUniqueIds();
59+
Array<Int64>& wantedUniqueIds();
6060
void sort();
6161
void getSortedValues(IData* written_data,IData* data);
6262

0 commit comments

Comments
 (0)