cpp_split_tool.cpp File Reference

#include <list>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <deque>
#include <fstream>
#include <iostream>
#include <limits>
#include <cfloat>
#include <set>
#include <map>
#include <assert.h>

Go to the source code of this file.

Macros
#define	_FCALL
#define	NDEBUG

Typedefs
typedef std::vector< std::unordered_map< int, int > >	Partition
typedef std::vector< std::pair< int, int > >	Candidates
typedef std::vector< std::pair< int, int > * >	VectOfCandPtr
typedef std::vector< std::vector< int > >	Remotes

Functions
void	build_partition (int *cep, int *size, const int nspmd, Partition &partition)
void	cpp_count_candidates (int *nbCand, int *sizeM, int *cepM, int *localIdM, int *candM, int *sizeS, int *cepS, int *localIdS, int *candS, int *nspmd, int *secondaryRemoteCount, int *localIdx)
void _FCALL	CPP_COUNT_CANDIDATES (int *nbCand, int *sizeM, int *cepM, int *localIdM, int *candM, int *sizeS, int *cepS, int *localIdS, int *candS, int *nspmd, int *secondaryRemoteCount, int *localIdx)
void	cpp_count_candidates__ (int *nbCand, int *sizeM, int *cepM, int *localIdM, int *candM, int *sizeS, int *cepS, int *localIdS, int *candS, int *nspmd, int *secondaryRemoteCount, int *localIdx)
void	cpp_count_candidates_ (int *nbCand, int *sizeM, int *cepM, int *localIdM, int *candM, int *sizeS, int *cepS, int *localIdS, int *candS, int *nspmd, int *secondaryRemoteCount, int *localIdx)

Macro Definition Documentation

_FCALL

#define _FCALL

Definition at line 23 of file cpp_split_tool.cpp.

NDEBUG

#define NDEBUG

Definition at line 39 of file cpp_split_tool.cpp.

Typedef Documentation

Candidates

typedef std::vector<std::pair<int,int> > Candidates

Definition at line 50 of file cpp_split_tool.cpp.

Partition

typedef std::vector<std::unordered_map<int,int> > Partition

Definition at line 47 of file cpp_split_tool.cpp.

Remotes

typedef std::vector<std::vector<int> > Remotes

Definition at line 55 of file cpp_split_tool.cpp.

VectOfCandPtr

typedef std::vector<std::pair<int,int>*> VectOfCandPtr

Definition at line 53 of file cpp_split_tool.cpp.

Function Documentation

build_partition()

void build_partition	(	int *	cep,
		int *	size,
		const int	nspmd,
		Partition &	partition )

Definition at line 57 of file cpp_split_tool.cpp.

{ // partition element according to the CEP
 
// create a vector of size nspmd initialized at 0
        std::vector<int> count(nspmd,0);
        partition.reserve(nspmd);
        for(int i = 0 ; i < *size ; i++)
        {
                assert( cep[i] >= 0);
                assert( cep[i] < nspmd);
                partition[cep[i]][i]=count[cep[i]];
                count[cep[i]]++; 
        }
}

CPP_COUNT_CANDIDATES()

void _FCALL CPP_COUNT_CANDIDATES	(	int *	nbCand,
		int *	sizeM,
		int *	cepM,
		int *	localIdM,
		int *	candM,
		int *	sizeS,
		int *	cepS,
		int *	localIdS,
		int *	candS,
		int *	nspmd,
		int *	secondaryRemoteCount,
		int *	localIdx )

Definition at line 222 of file cpp_split_tool.cpp.

{
     cpp_count_candidates(nbCand, sizeM, cepM, localIdM, candM, sizeS, cepS, localIdS,  candS,  nspmd, secondaryRemoteCount, localIdx);
}

cpp_count_candidates()

void cpp_count_candidates	(	int *	nbCand,
		int *	sizeM,
		int *	cepM,
		int *	localIdM,
		int *	candM,
		int *	sizeS,
		int *	cepS,
		int *	localIdS,
		int *	candS,
		int *	nspmd,
		int *	secondaryRemoteCount,
		int *	localIdx )

Definition at line 77 of file cpp_split_tool.cpp.

{
        // nbCand: 
        //      IN: number of candidates
        // sizeM: 
        //      IN: number of Main objects
        // cepM: 
        //      IN: domain of main objects, starts at 0
        // LocalIdM
        //      IN: local ID of the main object on its owner domain
        // candM
        //      IN: global  id of main object
        //      OUT: id of main object local to domain
        // sizeS: number of Main objects
        // cepS: 
        //      IN: secondary of main objects, starts at 0
        // LocalIdM
        //      IN: local ID of the main object on its owner domain
        // candS
        //      IN: global  id of secondary object, starts at 1
        //      OUT: id of secondary object: 
        //              if CandS[i] > 0 => CandS[i] is the local ID on domain CepM[i]
        //              if CandS[i] < 0 => -CandS[i] is the ID in the remote (FI) structure
        //              indexes starts at 1
        // nspmd:
        //      IN: number of domains
        // secondaryRemoteCount:
        //      OUT: array of size nspmd*nspmd that contains the number of remotes per pairs of processors
        // localIdx: 
        //      OUT: array of size nbCand, localIdx[i] = local index of the CandS[i] in the domain CepS[i] 
        //
        // Description:
        // split based on the domains of the main and the secondary element
 
 
        const int nspmd2 = (*nspmd)*(*nspmd);
        std::vector<Candidates> candidates(nspmd2, std::vector<std::pair<int,int>>());
        Remotes secondaryRemotes(nspmd2, std::vector<int>());
 
        for(int i = 0 ; i < *nbCand ; i++)
        {
                // Fortran indexes start at 1
                const int currentM = candM[i] - 1;
                const int currentS = candS[i] - 1;
                assert(currentM < *sizeM);
                assert(currentM >= 0 );
                assert(currentS < *sizeS);
                assert(currentS >= 0 );
                const int domainM = cepM[currentM];
                const int domainS = cepS[currentS];
                const int oneD = domainM * (*nspmd) + domainS;
 
//                const auto itrS = partitionS[domainS].find(currentS);
//                const auto itrM = partitionM[domainM].find(currentM);
//                const int localIdS = itrS->second;
//                const int localIdM = itrM->second;
//                const int localIdS = std::distance(partitionM[domainM].begin(),itrM) + 1; //idx starts at 1 (back to Fortran)
//                const int localIdM = std::distance(partitionS[domainS].begin(),itrS) + 1;
 
                //DEBUG 
                assert(domainM >= 0);
                assert(domainM < *nspmd);
                assert(domainS >=0);
                assert(domainS < *nspmd);
                if(domainS != domainM)
                { 
                      //  candidates[oneD].push_back(std::make_pair(localIdM[currentM],localIdS[currentS]));
                        candidates[oneD].push_back(std::make_pair(i,localIdS[currentS]));
 
                }
                //replace candidates global id by local ids
                candM[i] = localIdM[currentM];
                candS[i] = localIdS[currentS];    // if remote, will be replace by id in FI
                localIdx[i] = localIdS[currentS]; // keep local ID on owner domain
 
        }
 
        for(int domainM = 0 ; domainM < *nspmd ; domainM++)
        {
                int offset = 0 ;
                for(int domainS = 0 ; domainS < *nspmd ; domainS++)
                {
                        // 2D to 1D index
                        const int oneD = domainM * (*nspmd) + domainS;
                        secondaryRemoteCount[oneD] = 0;
                        secondaryRemotes[oneD] = {} ;
                        if(domainS != domainM)
                        {
                                //  SecondaryToCand[ global secondary id] => vector of pointers to candidates that 
                                //  have that secondary object
                                std::map<int,VectOfCandPtr> secondaryToCand; 
 
                                // Sets automatically exclude duplicates
                                std::set<int> secondarySet;
 
                                // Find all remote secondary objects
                                // They may be duplicated,multiple candidate pairs having the same secondary objects
                                // SecondaryToCand keep tracks of those candidates pairs
                                for(auto & c : candidates[oneD])
                                {
                                        auto it = secondarySet.insert(c.second);
                                        secondaryToCand[c.second].push_back(&(c));
                                }
                                // convert set into vector 
                                secondaryRemotes[oneD].assign(secondarySet.begin(),secondarySet.end());
                                // sort the vector - not needed since set is automatically sorted
                                // would be needed if set was replaced by unordered_set
                                // std::sort(secondaryRemotes[oneD].begin(),secondaryRemotes[oneD].end();
                                secondaryRemoteCount[oneD] = secondaryRemotes[oneD].size();
                                int idxInFi = offset; // index in Fi structure
                
                                // For remote candidate, convert:
                                // id of the secondary object (local to the owner domain)  => index in the FI structure 
                                for(auto & sc : secondaryToCand)
                                {
                                        idxInFi++;
                                        for(auto & ptr : sc.second)
                                        {
                                                // ptr = ptr to the pair of candidates
                                                (*ptr).second = -( idxInFi); // index starts at 1 
                                             //   std::cout<<"candS["<<(*ptr).first<<"]="<< -(idxInFi) << std::endl;   
                                                candS[(*ptr).first] = -(idxInFi);
                                        }
                                }
 
                        } else
                        {
                                secondaryRemoteCount[oneD] = 0;
                        }
                        offset+= secondaryRemoteCount[oneD];
                }
        }
 
//        for(int domainM = 0 ; domainM < *nspmd ; domainM++)
//        {
//                for(int domainS = 0 ; domainS < *nspmd ; domainS++)
//                {
//                        const int oneD = domainM * (*nspmd) + domainS;
//                        std::cout<<secondaryRemoteCount[oneD]<<" ";
//                }
//                std::cout<<std::endl;
//        }
}

cpp_count_candidates_()

void cpp_count_candidates_	(	int *	nbCand,
		int *	sizeM,
		int *	cepM,
		int *	localIdM,
		int *	candM,
		int *	sizeS,
		int *	cepS,
		int *	localIdS,
		int *	candS,
		int *	nspmd,
		int *	secondaryRemoteCount,
		int *	localIdx )

Definition at line 230 of file cpp_split_tool.cpp.

{
     cpp_count_candidates(nbCand, sizeM, cepM, localIdM, candM, sizeS, cepS, localIdS,  candS,  nspmd, secondaryRemoteCount, localIdx);
}

cpp_count_candidates__()

void cpp_count_candidates__	(	int *	nbCand,
		int *	sizeM,
		int *	cepM,
		int *	localIdM,
		int *	candM,
		int *	sizeS,
		int *	cepS,
		int *	localIdS,
		int *	candS,
		int *	nspmd,
		int *	secondaryRemoteCount,
		int *	localIdx )

Definition at line 226 of file cpp_split_tool.cpp.

{
     cpp_count_candidates(nbCand, sizeM, cepM, localIdM, candM, sizeS, cepS, localIdS,  candS,  nspmd, secondaryRemoteCount, localIdx);
}