Arcane  v3.15.3.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
Fonctions membres publiques | Liste de tous les membres
Référence de la classe Arcane::Accelerator::GenericPartitioner

Algorithme générique de partitionnement d'une liste. Plus de détails...

#include <arcane/accelerator/GenericPartitioner.h>

+ Graphe d'héritage de Arcane::Accelerator::GenericPartitioner:
+ Graphe de collaboration de Arcane::Accelerator::GenericPartitioner:

Fonctions membres publiques

 GenericPartitioner (const RunQueue &queue)
 
template<typename SelectLambda , typename SetterLambda >
void applyWithIndex (Int32 nb_value, const SetterLambda &setter_lambda, const SelectLambda &select_lambda, const TraceInfo &trace_info=TraceInfo())
 Effectue un partitionnement d'une liste en deux parties.
 
template<typename InputIterator , typename OutputIterator , typename SelectLambda >
void applyIf (Int32 nb_value, InputIterator input_iter, OutputIterator output_iter, const SelectLambda &select_lambda, const TraceInfo &trace_info=TraceInfo())
 Effectue un partitionnement d'une liste en deux parties.
 
template<typename Setter1Lambda , typename Setter2Lambda , typename UnselectedSetterLambda , typename Select1Lambda , typename Select2Lambda >
void applyWithIndex (Int32 nb_value, const Setter1Lambda setter1_lambda, const Setter2Lambda setter2_lambda, const UnselectedSetterLambda &unselected_setter_lambda, const Select1Lambda &select1_lambda, const Select2Lambda &select2_lambda, const TraceInfo &trace_info=TraceInfo())
 Effectue un partitionnement d'une liste en trois parties.
 
template<typename InputIterator , typename FirstOutputIterator , typename SecondOutputIterator , typename UnselectedIterator , typename Select1Lambda , typename Select2Lambda >
void applyIf (Int32 nb_value, InputIterator input_iter, FirstOutputIterator first_output_iter, SecondOutputIterator second_output_iter, UnselectedIterator unselected_iter, const Select1Lambda &select1_lambda, const Select2Lambda &select2_lambda, const TraceInfo &trace_info=TraceInfo())
 Effectue un partitionnement d'une liste en trois parties.
 
Int32 nbFirstPart ()
 Nombre d'éléments de la première partie de la liste.
 
SmallSpan< const Int32 > nbParts ()
 Nombre d'éléments de la première et deuxième partie de la liste.
 

Description détaillée

Algorithme générique de partitionnement d'une liste.

Cette classe fournit des algorithmes pour partitionner une liste en deux ou trois parties selon un critère fixé par l'utilisateur.

Définition à la ligne 332 du fichier GenericPartitioner.h.

Documentation des constructeurs et destructeur

◆ GenericPartitioner()

Arcane::Accelerator::GenericPartitioner::GenericPartitioner ( const RunQueue &  queue)
inlineexplicit

Définition à la ligne 337 du fichier GenericPartitioner.h.

Documentation des fonctions membres

◆ applyIf() [1/2]

template<typename InputIterator , typename FirstOutputIterator , typename SecondOutputIterator , typename UnselectedIterator , typename Select1Lambda , typename Select2Lambda >
void Arcane::Accelerator::GenericPartitioner::applyIf ( Int32  nb_value,
InputIterator  input_iter,
FirstOutputIterator  first_output_iter,
SecondOutputIterator  second_output_iter,
UnselectedIterator  unselected_iter,
const Select1Lambda &  select1_lambda,
const Select2Lambda &  select2_lambda,
const TraceInfo &  trace_info = TraceInfo() 
)
inline

Effectue un partitionnement d'une liste en trois parties.

Le nombre de valeurs de la liste est donné par nb_value. Les deux fonctions lambda select1_lambda et select2_lambda permettent de partitionner la liste avec l'algorithme suivant:

  • si select1_lambda() est vrai, la valeur ajoutée first_output_iter,
  • sinon si select2_lambda() est vrai, la valeur sera ajoutée à second_output_iter,
  • sinon la valeur sera ajoutée à unselected_iter.

Les listes en sortie sont dans le même ordre qu'en entrée.

Après exécution, il est possible de récupérer le nombre d'éléments de la première et de la deuxième liste la méthode nbParts().

// Sample to do a partition of an array.
// All elements greater than 2.0 will be put at the beginning of the list
// The remaining elements will be at the end of the list in reverse order
Arcane::Accelerator::RunQueue queue(*subDomain()->acceleratorMng()->defaultQueue());
const Int32 nb_value = 7;
Arcane::NumArray<Real, MDDim1> input(nb_value, { 1.3, 4.5, -1.2, 3.5, 7.0, 4.2, 9.5 });
Arcane::NumArray<Real, MDDim1> output1(nb_value);
Arcane::NumArray<Real, MDDim1> output2(nb_value);
Arcane::NumArray<Real, MDDim1> output_unselected(nb_value);
auto input_values = input.to1DSmallSpan();
auto output1_values = output1.to1DSmallSpan();
auto output2_values = output2.to1DSmallSpan();
auto output_unselected_values = output_unselected.to1DSmallSpan();
auto select1_lambda = [=] ARCCORE_HOST_DEVICE(Real value) {
return value > 6.0;
};
auto select2_lambda = [=] ARCCORE_HOST_DEVICE(Real value) {
return value < 3.0;
};
Arcane::Accelerator::GenericPartitioner partitioner(queue);
partitioner.applyIf(nb_value, input_values.begin(),
output1_values.begin(), output2_values.begin(), output_unselected_values.begin(),
select1_lambda, select2_lambda, A_FUNCINFO);
SmallSpan<const Int32> nb_parts = partitioner.nbParts();
info() << "NbFirstPart = " << nb_parts[0] << " NbSecondPart=" << nb_parts[1];
output1.resize(nb_parts[0]);
output2.resize(nb_parts[1]);
output_unselected.resize(nb_value - (nb_parts[0] + nb_parts[1]));
info() << "Output1=" << output1.to1DSmallSpan();
info() << "Output2=" << output2.to1DSmallSpan();
info() << "UnselectedOutput=" << output_unselected.to1DSmallSpan();
// Expected output :
// NbFirstPart = 2 NbSecondPart=2
// Output1=[0]="7" [1]="9.5"
// Output2=[0]="1.3" [1]="-1.2"
// UnselectedOutput=[0]="4.5" [1]="3.5" [2]="4.2"
Arcane::Accelerator::GenericPartitioner
Algorithme générique de partitionnement d'une liste.
Definition GenericPartitioner.h:334
Arcane::Accelerator::RunQueue
File d'exécution pour un accélérateur.
Definition core/RunQueue.h:52
Arccore::Ref
Référence à une instance.
Definition arccore/src/base/arccore/base/Ref.h:143

Définition à la ligne 460 du fichier GenericPartitioner.h.

◆ applyIf() [2/2]

template<typename InputIterator , typename OutputIterator , typename SelectLambda >
void Arcane::Accelerator::GenericPartitioner::applyIf ( Int32  nb_value,
InputIterator  input_iter,
OutputIterator  output_iter,
const SelectLambda &  select_lambda,
const TraceInfo &  trace_info = TraceInfo() 
)
inline

Effectue un partitionnement d'une liste en deux parties.

Le nombre de valeurs de la liste est donné par nb_value. Les valeurs en entrée sont fournies par l'itérateur input_iter et les valeurs en sorties par l'itérateur output_iterator. La fonction lambda select_lambda permet de sélectionner la partition utilisée : si le retour est true, la valeur sera dans la première partie de la liste, sinon elle sera dans la seconde. En sortie les valeurs de la deuxième partie sont rangées en ordre inverse de la liste d'entrée.

Après exécution, il est possible de récupérer le nombre d'éléments de la première partie de la liste via la méthode nbFirstPart().

// Sample to do a partition of an array.
// All elements greater than 2.0 will be put at the beginning of the list
// The remaining elements will be at the end of the list in reverse order
Arcane::Accelerator::RunQueue queue(*subDomain()->acceleratorMng()->defaultQueue());
const Int32 nb_value = 6;
Arcane::NumArray<Real, MDDim1> input(nb_value, { 1.3, 4.5, -1.2, 3.5, 7.0, 4.2 });
Arcane::NumArray<Real, MDDim1> output(nb_value);
auto input_values = input.to1DSmallSpan();
auto output_values = output.to1DSmallSpan();
auto select_lambda = [=] ARCCORE_HOST_DEVICE(Real value) {
return value > 2.0;
};
Arcane::Accelerator::GenericPartitioner partitioner(queue);
partitioner.applyIf(nb_value, input_values.begin(), output_values.begin(),
select_lambda, A_FUNCINFO);
Int32 nb_first_part = partitioner.nbFirstPart();
info() << "NbFirstPart = " << nb_first_part;
info() << "Output=" << output.to1DSmallSpan();
// Expected nb_first_part = 4
// Expected output : [0]="4.5" [1]="3.5" [2]="7" [3]="4.2" [4]="-1.2" [5]="1.3"

Définition à la ligne 389 du fichier GenericPartitioner.h.

◆ applyWithIndex() [1/2]

template<typename Setter1Lambda , typename Setter2Lambda , typename UnselectedSetterLambda , typename Select1Lambda , typename Select2Lambda >
void Arcane::Accelerator::GenericPartitioner::applyWithIndex ( Int32  nb_value,
const Setter1Lambda  setter1_lambda,
const Setter2Lambda  setter2_lambda,
const UnselectedSetterLambda &  unselected_setter_lambda,
const Select1Lambda &  select1_lambda,
const Select2Lambda &  select2_lambda,
const TraceInfo &  trace_info = TraceInfo() 
)
inline

Effectue un partitionnement d'une liste en trois parties.

Le nombre de valeurs de la liste est donné par nb_value. Les deux fonctions lambda select1_lambda et select2_lambda permettent de partitionner la liste avec l'algorithme suivant:

  • si select1_lambda() est vrai, la valeur sera positionnée via setter1_lambda,
  • sinon si select2_lambda() est vrai, la valeur sera positionnée via setter2_lambda,
  • sinon la valeur sera positionnée via unselected_setter_lambda.

Les listes en sortie sont dans le même ordre qu'en entrée.

Après exécution, il est possible de récupérer le nombre d'éléments de la première et de la deuxième liste la méthode nbParts().

// Sample to do a partition of an array.
// All elements greater than 2.0 will be put at the beginning of the list
// The remaining elements will be at the end of the list in reverse order
Arcane::Accelerator::RunQueue queue(*subDomain()->acceleratorMng()->defaultQueue());
const Int32 nb_value = 7;
Arcane::NumArray<Real, MDDim1> input(nb_value, { 1.3, 4.5, -1.2, 3.5, 7.0, 4.2, 9.5 });
Arcane::NumArray<Real, MDDim1> output1(nb_value);
Arcane::NumArray<Real, MDDim1> output2(nb_value);
Arcane::NumArray<Real, MDDim1> output_unselected(nb_value);
auto input_values = viewIn(queue, input);
auto output1_values = viewOut(queue, output1);
auto output2_values = viewOut(queue, output2);
auto output_unselected_values = viewOut(queue, output_unselected);
auto select1_lambda = [=] ARCCORE_HOST_DEVICE(Int32 input_index) {
return input_values[input_index] > 6.0;
};
auto select2_lambda = [=] ARCCORE_HOST_DEVICE(Int32 input_index) {
return input_values[input_index] < 3.0;
};
auto setter1_lambda = [=] ARCCORE_HOST_DEVICE(Int32 input_index, Int32 output_index) {
output1_values[output_index] = input_values[input_index];
};
auto setter2_lambda = [=] ARCCORE_HOST_DEVICE(Int32 input_index, Int32 output_index) {
output2_values[output_index] = input_values[input_index];
};
auto unselected_setter_lambda = [=] ARCCORE_HOST_DEVICE(Int32 input_index, Int32 output_index) {
output_unselected_values[output_index] = input_values[input_index];
};
Arcane::Accelerator::GenericPartitioner partitioner(queue);
partitioner.applyWithIndex(nb_value, setter1_lambda, setter2_lambda, unselected_setter_lambda,
select1_lambda, select2_lambda, A_FUNCINFO);
SmallSpan<const Int32> nb_parts = partitioner.nbParts();
info() << "NbFirstPart = " << nb_parts[0] << " NbSecondPart=" << nb_parts[1];
output1.resize(nb_parts[0]);
output2.resize(nb_parts[1]);
output_unselected.resize(nb_value - (nb_parts[0] + nb_parts[1]));
info() << "Output1=" << output1.to1DSmallSpan();
info() << "Output2=" << output2.to1DSmallSpan();
info() << "UnselectedOutput=" << output_unselected.to1DSmallSpan();
// Expected output :
// NbFirstPart = 2 NbSecondPart=2
// Output1=[0]="7" [1]="9.5"
// Output2=[0]="1.3" [1]="-1.2"
// UnselectedOutput=[0]="4.5" [1]="3.5" [2]="4.2"
Arcane::Accelerator::viewOut
auto viewOut(const ViewBuildInfo &vbi, CellMaterialVariableScalarRef< DataType > &var)
Vue en écriture pour les variables materiaux scalaire.
Definition MaterialVariableViews.h:179
Arcane::Accelerator::viewIn
auto viewIn(const ViewBuildInfo &vbi, const CellMaterialVariableScalarRef< DataType > &var)
Vue en lecture pour les variables materiaux scalaire.
Definition MaterialVariableViews.h:228

Définition à la ligne 419 du fichier GenericPartitioner.h.

◆ applyWithIndex() [2/2]

template<typename SelectLambda , typename SetterLambda >
void Arcane::Accelerator::GenericPartitioner::applyWithIndex ( Int32  nb_value,
const SetterLambda &  setter_lambda,
const SelectLambda &  select_lambda,
const TraceInfo &  trace_info = TraceInfo() 
)
inline

Effectue un partitionnement d'une liste en deux parties.

Le nombre de valeurs de la liste est donné par nb_value. Les deux fonctions lambda select_lambda et setter_lambda permettent de partitionner et de positionner les valeurs de la liste.

Après exécution, il est possible de récupérer le nombre d'éléments de la première partie de la liste via la méthode nbFirstPart().

// Sample to do a partition of an array.
// All elements greater than 2.0 will be put at the beginning of the list
// The remaining elements will be at the end of the list in reverse order
Arcane::Accelerator::RunQueue queue(*subDomain()->acceleratorMng()->defaultQueue());
const Int32 nb_value = 6;
Arcane::NumArray<Real, MDDim1> input(nb_value, { 1.3, 4.5, -1.2, 3.5, 7.0, 4.2 });
Arcane::NumArray<Real, MDDim1> output(nb_value);
auto input_values = viewIn(queue, input);
auto output_values = viewOut(queue, output);
auto select_lambda = [=] ARCCORE_HOST_DEVICE(Int32 input_index) {
return input_values[input_index] > 2.0;
};
auto setter_lambda = [=] ARCCORE_HOST_DEVICE(Int32 input_index, Int32 output_index) {
output_values[output_index] = input_values[input_index];
};
Arcane::Accelerator::GenericPartitioner partitioner(queue);
partitioner.applyWithIndex(nb_value, setter_lambda, select_lambda, A_FUNCINFO);
Int32 nb_first_part = partitioner.nbFirstPart();
info() << "NbFirstPart = " << nb_first_part;
info() << "Output=" << output.to1DSmallSpan();
// Expected nb_first_part = 4
// Expected output : [0]="4.5" [1]="3.5" [2]="7" [3]="4.2" [4]="-1.2" [5]="1.3"

Définition à la ligne 358 du fichier GenericPartitioner.h.

◆ nbFirstPart()

Int32 Arcane::Accelerator::GenericPartitioner::nbFirstPart ( )
inline

Nombre d'éléments de la première partie de la liste.

Définition à la ligne 480 du fichier GenericPartitioner.h.

◆ nbParts()

SmallSpan< const Int32 > Arcane::Accelerator::GenericPartitioner::nbParts ( )
inline

Nombre d'éléments de la première et deuxième partie de la liste.

Retourne une vue de deux valeurs. La première valeur contient le nombre d'éléments de la première liste et la seconde valeur le nombre d'éléments de la deuxième liste.

Cette méthode n'est valide qu'après avoir appelé une méthode de partitionnement en trois parties.

Définition à la ligne 496 du fichier GenericPartitioner.h.

La documentation de cette classe a été générée à partir du fichier suivant :