From 584f23454c5ab0883e85c04ee73b751ff09bb2af Mon Sep 17 00:00:00 2001 From: Lingda Li Date: Thu, 1 Aug 2019 13:17:34 -0400 Subject: [PATCH] Readd miniVite --- miniVite | 1 - miniVite/FAQS | 270 ++ miniVite/LICENSE | 29 + miniVite/Makefile | 33 + miniVite/README | 138 + miniVite/dspl.hpp | 1392 +++++++++ miniVite/dspl_gpu.hpp | 1409 +++++++++ miniVite/dspl_gpu_kernel.hpp | 1447 +++++++++ miniVite/err | 8 + miniVite/graph.hpp | 1053 +++++++ miniVite/log | 518 ++++ miniVite/log1 | 598 ++++ miniVite/logcmpl | 5666 ++++++++++++++++++++++++++++++++++ miniVite/logcmplll | 5651 +++++++++++++++++++++++++++++++++ miniVite/main.cpp | 252 ++ miniVite/miniVite | Bin 0 -> 1338400 bytes miniVite/miniVite_alloc | Bin 0 -> 1338400 bytes miniVite/miniVite_noalloc | Bin 0 -> 1338352 bytes miniVite/run | 15 + miniVite/run.sh | 32 + miniVite/run2.sh | 21 + miniVite/stats | 2 + miniVite/submit.sh | 23 + miniVite/utils.hpp | 328 ++ 24 files changed, 18885 insertions(+), 1 deletion(-) delete mode 160000 miniVite create mode 100644 miniVite/FAQS create mode 100644 miniVite/LICENSE create mode 100644 miniVite/Makefile create mode 100644 miniVite/README create mode 100644 miniVite/dspl.hpp create mode 100644 miniVite/dspl_gpu.hpp create mode 100644 miniVite/dspl_gpu_kernel.hpp create mode 100644 miniVite/err create mode 100644 miniVite/graph.hpp create mode 100644 miniVite/log create mode 100644 miniVite/log1 create mode 100644 miniVite/logcmpl create mode 100644 miniVite/logcmplll create mode 100644 miniVite/main.cpp create mode 100755 miniVite/miniVite create mode 100755 miniVite/miniVite_alloc create mode 100755 miniVite/miniVite_noalloc create mode 100644 miniVite/run create mode 100644 miniVite/run.sh create mode 100644 miniVite/run2.sh create mode 100644 miniVite/stats create mode 100644 miniVite/submit.sh create mode 100644 miniVite/utils.hpp diff --git a/miniVite b/miniVite deleted file mode 160000 index f4367f1..0000000 --- a/miniVite +++ /dev/null @@ -1 +0,0 @@ -Subproject commit f4367f1c5d64034a3ee09c4de5397767c25eafb2 diff --git a/miniVite/FAQS b/miniVite/FAQS new file mode 100644 index 0000000..11b66fe --- /dev/null +++ b/miniVite/FAQS @@ -0,0 +1,270 @@ +***************** +* miniVite FAQs * +***************** +---------------------------------------------------- +FYI, typical "How to run" queries are addressed Q5 +onward. + +Please send your suggestions for improving this FAQ +to zsayanz at gmail dot com OR hala at pnnl dot gov. +---------------------------------------------------- + +------------------------------------------------------------------------- +Q1. What is graph community detection? +------------------------------------------------------------------------- + +A1. In most real-world graphs/networks, the nodes/vertices tend to be +organized into tightly-knit modules known as communities or clusters, +such that nodes within a community are more likely to be "related" to +one another than they are to the rest of the network. The goodness of +partitioning into communities is typically measured using a metric +called modularity. Community detection is the method of identifying +these clusters or communities in graphs. + +[References] + +Fortunato, Santo. "Community detection in graphs." Physics reports +486.3-5 (2010): 75-174. https://arxiv.org/pdf/0906.0612.pdf + +-------------------------------------------------------------------------- +Q2. What is miniVite? +-------------------------------------------------------------------------- + +A2. miniVite is a distributed-memory code (or mini application) that +performs partial graph community detection using the Louvain method. +Louvain method is a multi-phase, iterative heuristic that performs +modularity optimization for graph community detection. miniVite only +performs the first phase of Louvain method. + +[Code] + +https://github.com/Exa-Graph/miniVite +http://hpc.pnl.gov/people/hala/grappolo.html + +[References] + +Blondel, Vincent D., et al. "Fast unfolding of communities in large +networks." Journal of statistical mechanics: theory and experiment +2008.10 (2008): P10008. + +Ghosh S, Halappanavar M, Tumeo A, Kalyanaraman A, Gebremedhin AH. +miniVite: A Graph Analytics Benchmarking Tool for Massively Parallel +Systems. + +--------------------------------------------------------------------------- +Q3. What is the parent application of miniVite? How are they different? +--------------------------------------------------------------------------- + +A3. miniVite is derived from Vite, which implements the multi-phase +Louvain method. Apart from a parallel baseline version, Vite provides +a number of heuristics (such as early termination, threshold cycling and +incomplete coloring) that can improve the scalability and quality of +community detection. In contrast, miniVite just provides a parallel +baseline version, and, has option to select different MPI communication +methods (such as send/recv, collectives and RMA) for one of the most +communication intensive portions of the code. miniVite also includes an +in-memory random geometric graph generator, making it convenient for +users to run miniVite without any external files. Vite can also convert +graphs from different native formats (like matrix market, SNAP, edge +list, DIMACS, etc) to the binary format that both Vite and miniVite +requires. + +[Code] + +http://hpc.pnl.gov/people/hala/grappolo.html + +[References] + +Ghosh S, Halappanavar M, Tumeo A, Kalyanaraman A, Lu H, Chavarria-Miranda D, +Khan A, Gebremedhin A. Distributed louvain algorithm for graph community +detection. In 2018 IEEE International Parallel and Distributed Processing +Symposium (IPDPS) 2018 May 21 (pp. 885-895). IEEE. + +Ghosh S, Halappanavar M, Tumeo A, Kalyanaraman A, Gebremedhin AH. +Scalable Distributed Memory Community Detection Using Vite. +In 2018 IEEE High Performance extreme Computing Conference (HPEC) 2018 +Sep 25 (pp. 1-7). IEEE. + +----------------------------------------------------------------------------- +Q4. Is there a shared-memory equivalent of Vite/miniVite? +----------------------------------------------------------------------------- + +A4. Yes, Grappolo performs shared-memory community detection using Louvain +method. Apart from community detection, Grappolo has routines for matrix +reordering as well. + +[Code] + +http://hpc.pnl.gov/people/hala/grappolo.html + +[References] + +Lu H, Halappanavar M, Kalyanaraman A. Parallel heuristics for scalable +community detection. Parallel Computing. 2015 Aug 1;47:19-37. + +Halappanavar M, Lu H, Kalyanaraman A, Tumeo A. Scalable static and dynamic +community detection using grappolo. In High Performance Extreme Computing +Conference (HPEC), 2017 IEEE 2017 Sep 12 (pp. 1-6). IEEE. + +------------------------------------------------------------------------------ +Q5. How does one perform strong scaling analysis using miniVite? How to +determine 'good' candidates (input graphs) that can be used for strong +scaling runs? How much time is approximately spent in performing I/O? +------------------------------------------------------------------------------ + +A5. Use a large graph as an input, preferably over a billion edges. Not all +large graphs have a good community structure. You should be able to identify +one that serves your purpose, hopefully after few trials. Graphs can be +obtained various websites serving as repositories, such as Sparse TAMU +collection[1], SNAP repository[2] and MIT Graph Challenge website[3], to name +a few of the prominent ones. You can convert graphs from their native format to +the binary format that miniVite requires, using the converters in Vite (please +see README). If your graph is in Webgraph[4] format, you can easily convert it +to an edge list first (example code snippet below), before passing it on to Vite +for subsequent binary conversion. + +#include "offline_edge_iterator.hpp" +... +using namespace webgraph::ascii_graph; + +// read in input/output file +std::ofstream ofile(argv[2]); +offline_edge_iterator itor(argv[1]), end; + +// read edges +while( itor != end ) { + ofile << itor->first << " " << itor->second << std::endl; + ++itor; +} +ofile.close(); +... + +Due to its simple vertex-based distribution, miniVite takes about 2-4s to read a 55GB +binary file if you use Burst buffer (Cray DataWarp) or Lustre striping (about 25 OSTs, +default 1M blocks). Hence, the overall I/O time that we have observed in most cases is +within 1/2% of the overall execution time. + +[1] https://sparse.tamu.edu/ +[2] http://snap.stanford.edu/data +[3] http://graphchallenge.mit.edu/data-sets +[4] http://webgraph.di.unimi.it/ + +----------------------------------------------------------------------------------- +Q6. How does one perform weak scaling analysis using miniVite? How does one scale +the graphs with processes? +----------------------------------------------------------------------------------- + +A6. miniVite has an in-memory random geometric graph generator (please see +README) that can be used for weak-scaling analysis. An n-D random geometric graph +(RGG), is generated by randomly placing N vertices in an n-D space and connecting +pairs of vertices whose Euclidean distance is less than or equal to d. We only +consider 2D RGGs contained within a unit square, [0,1]^2. We distribute the domain +such that each process receives N/p vertices (where p is the total +number of processes). + +Each process owns (1 * 1/p) portion of the unit square and d is computed as (please +refer to Section 4 of miniVite paper for details): + +d = (dc + dt)/2; +where, dc = sqrt(ln(N) / pi*N); dt = sqrt(2.0736 / pi*N) + +Therefore, the number of vertices (N) passed during miniVite execution on p +processes must satisfy the condition -- 1/p > d. + +Please note, the default distribution of graph generated from the in-built random +geometric graph generator causes a process to only communicate with its two +immediate neighbors. If you want to increase the communication intensity for +generated graphs, please use the "-p" option to specify an extra percentage of edges +that will be generated, linking random vertices. As a side-effect, this option +significantly increases the time required to generate the graph. + +------------------------------------------------------------------------------ +Q7. Does Vite (the parent application to miniVite) have an in-built graph +generator? +------------------------------------------------------------------------------ + +A7. At present, Vite does not have an in-built graph generator that we have in +miniVite, so we rely on users providing external graphs for Vite (strong/weak +scaling) analysis. However, Vite has bindings to NetworKit[5], and users can use +those bindings to generate graphs of their choice from Vite (refer to the +README). Generating large graphs in this manner can take a lot of time, since +there are intermediate copies and the graph generators themselves may be serial +or may use threads on a shared-memory system. We do not plan on supporting the +NetworKit bindings in future. + +[5] https://networkit.github.io/ + +------------------------------------------------------------------------------ +Q8. Does providing a larger input graph translate to comparatively larger +execution times? Is it possible to control the execution time for a particular +graph? +------------------------------------------------------------------------------ + +A8. No. A relatively small graph can run for many iterations, as compared to +a larger graph that runs for a few iterations to convergence. Since miniVite is +iterative, the final number of iterations to convergence (and hence, execution +time) depends on the structure of the graph. It is however possible to exit +early by passing a larger threshold (using the "-t <...>" option, the default +threshold or tolerance is 1.0E-06, a larger threshold can be passed, for e.g, +"-t 1.0E-03"), that should reduce the overall execution time for all graphs in +general (at least w.r.t miniVite, which only executes the first phase of Louvain +method). + +------------------------------------------------------------------------------ +Q9. Is there an option to add some noise in the generated random geometric +graphs? +------------------------------------------------------------------------------ + +A9. Yes, the "-p " option allows extra edges to be added between +random vertices (see README). This increases the overall communication, but +affects the structure of communities in the generated graph (lowers the +modularity). Therefore, adding extra edges in the generated graph will +most probably reduce the global modularity, and the number of iterations to +convergence shall decrease. +The maximum number of edges that can be added is bounded by INT_MAX, at +present, we do not handle data ranges more than INT_MAX. + +------------------------------------------------------------------------------ +Q10. What are the steps required for using real-world graphs as an input to +miniVite? +------------------------------------------------------------------------------ + +A10. First, please download Vite (parent application of miniVite) from: +http://hpc.pnl.gov/people/hala/grappolo.html + +Graphs/Sparse matrices come in several native formats (matrix market, SNAP, +DIMACS, etc.) Vite has several options to convert graphs from native to the +binary format that miniVite requires (please take a look at Vite README). + +As an example, you can download the Friendster file from: +https://sparse.tamu.edu/SNAP/com-Friendster +The option to convert Friendster to binary using Vite's converter is as follows +(please note, this part is serial): + +$VITE_BIN_PATH/bin/./fileConvertDist -f $INPUT_PATH/com-Friendster.mtx + -m -o $OUTPUT_PATH/com-Friendster.bin + +After the conversion, you can run miniVite with the binary file obtained +from the previous step: + +mpiexec -n <...> $MINIVITE_PATH/./dspl -r + -f $FILE_PATH/com-Friendster.bin + +-------------------------------------------------------------------------------- +Q11. miniVite is scalable for a particular input graph, but not for another +similar sized graph, why is that? +-------------------------------------------------------------------------------- + +A11. Presently, our distribution is vertex-based. That means a process owns N/p +vertices and all the edges connected to those N/p vertices (including ghost +vertices). Load imbalances are very probable in this type of distribution, +depending on the graph structure. + +As an example, lets say there is a large (real-world) graph, and its structure +is such that only a few processes end up owning a majority of edges, as per +miniVite graph data distribution. Also, lets assume that the graph has either a +very poor community structure (modularity closer to 0) or very stable community +structure (modularity close to 1 after a few iterations, that means not many +vertices are migrating to neighboring communities). In both these cases, +community detection in miniVite will run for relatively less number of +iterations, which may affect the overall scalability. diff --git a/miniVite/LICENSE b/miniVite/LICENSE new file mode 100644 index 0000000..4959d64 --- /dev/null +++ b/miniVite/LICENSE @@ -0,0 +1,29 @@ +BSD 3-Clause License + +Copyright (c) 2018, Battelle Memorial Institute +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/miniVite/Makefile b/miniVite/Makefile new file mode 100644 index 0000000..a5e51f4 --- /dev/null +++ b/miniVite/Makefile @@ -0,0 +1,33 @@ +CXX = mpicxx +# use -xmic-avx512 instead of -xHost for Intel Xeon Phi platforms +PLUGIN_FLAG = -Xclang -load -Xclang ~/git/unifiedmem/code/llvm-pass/build/uvm/libOMPPass.so +#OPTFLAGS = -O3 -xHost -qopenmp -DCHECK_NUM_EDGES #-DPRINT_EXTRA_NEDGES #-DPRINT_DIST_STATS #-DUSE_MPI_RMA -DUSE_MPI_ACCUMULATE #-DUSE_32_BIT_GRAPH #-DDEBUG_PRINTF #-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_LOHI_RANDOM_NUMBERS#-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_RANDOM_NUMBERS #-DPRINT_RANDOM_XY_COORD +OPTFLAGS = -O3 -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda -DOMP_GPU -DOMP_GPU_ALLOC -DCHECK_NUM_EDGES #-DPRINT_EXTRA_NEDGES #-DPRINT_DIST_STATS #-DUSE_MPI_RMA -DUSE_MPI_ACCUMULATE #-DUSE_32_BIT_GRAPH #-DDEBUG_PRINTF #-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_LOHI_RANDOM_NUMBERS#-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_RANDOM_NUMBERS #-DPRINT_RANDOM_XY_COORD +#OPTFLAGS = -O3 -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda -DOMP_GPU -DCHECK_NUM_EDGES #-DPRINT_EXTRA_NEDGES #-DPRINT_DIST_STATS #-DUSE_MPI_RMA -DUSE_MPI_ACCUMULATE #-DUSE_32_BIT_GRAPH #-DDEBUG_PRINTF #-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_LOHI_RANDOM_NUMBERS#-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_RANDOM_NUMBERS #-DPRINT_RANDOM_XY_COORD +#OPTFLAGS = -O3 -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda -DOMP_GPU -DCHECK_NUM_EDGES -DDEBUG_PRINTF #-DPRINT_EXTRA_NEDGES #-DPRINT_DIST_STATS #-DUSE_MPI_RMA -DUSE_MPI_ACCUMULATE #-DUSE_32_BIT_GRAPH #-DDEBUG_PRINTF #-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_LOHI_RANDOM_NUMBERS#-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_RANDOM_NUMBERS #-DPRINT_RANDOM_XY_COORD +#OPTFLAGS = -O3 -fopenmp -DOMP_GPU -DCHECK_NUM_EDGES -DDEBUG_PRINTF #-DPRINT_EXTRA_NEDGES #-DPRINT_DIST_STATS #-DUSE_MPI_RMA -DUSE_MPI_ACCUMULATE #-DUSE_32_BIT_GRAPH #-DDEBUG_PRINTF #-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_LOHI_RANDOM_NUMBERS#-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_RANDOM_NUMBERS #-DPRINT_RANDOM_XY_COORD +#OPTFLAGS = -O3 -fopenmp -DCHECK_NUM_EDGES -DDEBUG_PRINTF #-DPRINT_EXTRA_NEDGES #-DPRINT_DIST_STATS #-DUSE_MPI_RMA -DUSE_MPI_ACCUMULATE #-DUSE_32_BIT_GRAPH #-DDEBUG_PRINTF #-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_LOHI_RANDOM_NUMBERS#-DUSE_MPI_RMA #-DPRINT_LCG_DOUBLE_RANDOM_NUMBERS #-DPRINT_RANDOM_XY_COORD +#-DUSE_MPI_SENDRECV +#-DUSE_MPI_COLLECTIVES +# use export ASAN_OPTIONS=verbosity=1 to check ASAN output +SNTFLAGS = -std=c++11 -fopenmp -fsanitize=address -O1 -fno-omit-frame-pointer +CXXFLAGS = -std=c++11 -g $(OPTFLAGS) + +OBJ = main.o +TARGET = miniVite + +all: $(TARGET) + +%.o: %.cpp + $(CXX) $(CXXFLAGS) $(PLUGIN_FLAG) -c -o $@ $^ + +%.ll: %.cpp + $(CXX) $(CXXFLAGS) $(PLUGIN_FLAG) -emit-llvm -S -c -o $@ $^ + +$(TARGET): $(OBJ) + $(CXX) $^ $(OPTFLAGS) -o $@ + +.PHONY: clean + +clean: + rm -rf *~ $(OBJ) $(TARGET) *.ll diff --git a/miniVite/README b/miniVite/README new file mode 100644 index 0000000..f320dec --- /dev/null +++ b/miniVite/README @@ -0,0 +1,138 @@ +************************ +miniVite (/mini/ˈviːte/) + +Version: 1.0 +************************ + +******* +------- + ABOUT +------- +******* +miniVite is a proxy app that implements a single phase of Louvain +method in distributed memory for graph community detection. Please +refer to the following paper for a detailed discussion on +distributed memory Louvain method implementation: +https://ieeexplore.ieee.org/abstract/document/8425242/ + +Apart from real world graphs, users can use specific options +to generate a Random Geometric Graph (RGG) in parallel. +RGGs have been known to have good community structure: +https://arxiv.org/pdf/1604.03993.pdf + +The way we have implemented a parallel RGG generator, vertices +owned by a process will only have cross edges with its logical +neighboring processes (each process owning 1x1/p chunk of the +1x1 unit square). If MPI process mapping is such that consecutive +processes (for e.g., p and p+1) are physically close to each other, +then there is not much communication stress in the application. +Therefore, we allow an option to add extra edges between randomly +chosen vertices, whose owners may be physically far apart. + +We require the total number of processes to be a power of 2 and +total number of vertices to be perfectly divisible by the number of +processes when parallel RGG generation options are used. +This constraint does not apply to real world graphs passed to miniVite. + +We also allow users to pass any real world graph as input. However, +we expect an input graph to be in a certain binary format, which +we have observed to be more efficient than reading ASCII format +files. The code for binary conversion (from a variety of common +graph formats) is packaged separately with Vite, which is our +full implementation of Louvain method in distributed memory. +Please follow instructions in Vite README for binary file +conversion. + +Vite could be downloaded from: +http://hpc.pnl.gov/people/hala/grappolo.html + +Unlike Vite, we do not implement any heuristics to improve the +performance of Louvain method. miniVite is a baseline parallel +version, implementing only the first phase of Louvain method. + +This code requires an MPI library (preferably MPI-3 compatible) +and C++11 compliant compiler for building. + +Please contact the following for any queries or support: + +Sayan Ghosh, WSU (zsayanz at gmail dot com) +Mahantesh Halappanavar, PNNL (hala at pnnl dot gov) + +************* +------------- + COMPILATION +------------- +************* +Please update the Makefile with compiler flags and use a C++11 compliant +compiler of your choice. Invoke `make clean; make` after setting paths +to MPI for generating the binary. Use `mpirun` or `mpiexec` or `srun` +to execute the code with specific runtime arguments mentioned in the +next section. + +Pass -DPRINT_DIST_STATS for printing distributed graph +characteristics. + +Pass -DDEBUG_PRINTF if detailed diagonostics is required along +program run. This program requires OpenMP and C++11 support, +so pass -fopenmp (for g++)/-qopenmp (for icpc) and -std=c++11/ +-std=c++0x. + +Pass -DUSE_32_BIT_GRAPH if number of nodes in the graph are +within 32-bit range (2 x 10^9), else 64-bit range is assumed. + +Pass -DOMP_SCHEDULE_RUNTIME if you want to set OMP_SCHEDULE +for all parallel regions at runtime. If -DOMP_SCHEDULE_RUNTIME +is passed, and OMP_SCHEDULE is not set, then the default schedule will +be chosen (which is most probably "static" or "guided" for most of +the OpenMP regions). + +Communicating vertex-community information (per iteration) +is the most expensive step of our distributed Louvain +implementation. We use the one of the following MPI communication +primitives for communicating vertex-community during a Louvain +iteration, that could be enabled by passing predefined +macros at compile time: + +1. MPI Collectives: -DUSE_MPI_COLLECTIVES +2. MPI Send-Receive: -DUSE_MPI_SENDRECV +3. MPI RMA: -DUSE_MPI_RMA (using -DUSE_MPI_ACCUMULATE + additionally ensures atomic put) +4. Default: Uses MPI point-to-point nonblocking API. + +Apart from these, we use MPI (blocking) collectives, mostly +MPI_Alltoall. + +There are other predefined macros in the code as well for printing +intermediate results or checking correctness or using a particular +C++ data structure. + +*********************** +----------------------- + EXECUTING THE PROGRAM +----------------------- +*********************** + +E.g.: +mpiexec -n 2 bin/./minivite -f karate.bin +mpiexec -n 2 bin/./minivite -l -n 100 +mpiexec -n 2 bin/./minivite -n 100 +mpiexec -n 2 bin/./minivite -p 2 -n 100 + +Possible options (can be combined): + +1. -f : Specify input binary file after this argument. +2. -n : Pass total number of vertices of the generated graph. +3. -l : Use distributed LCG for randomly choosing edges. If this option + is not used, we will use C++ random number generator (using + std::default_random_engine). +4. -p : Specify percent of overall edges to be randomly generated between + processes. +5. -t : Specify threshold quantity (default: 1.0E-06) used to determine the + exit criteria in an iteration of Louvain method. +6. -w : Use Euclidean distance as edge weight. If this option is not used, + edge weights are considered as 1.0. Generate edge weight uniformly + between (0,1) if Euclidean distance is not available (applicable to + randomly generated edges). +7. -r : This is used to control the number of aggregators in MPI I/O and is + meaningful when an input binary graph file is passed with option "-f". + naggr := (nranks > 1) ? (nprocs/nranks) : nranks; diff --git a/miniVite/dspl.hpp b/miniVite/dspl.hpp new file mode 100644 index 0000000..f86ae90 --- /dev/null +++ b/miniVite/dspl.hpp @@ -0,0 +1,1392 @@ +// *********************************************************************** +// +// miniVite +// +// *********************************************************************** +// +// Copyright (2018) Battelle Memorial Institute +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// ************************************************************************ + +#pragma once +#ifndef DSPL_HPP +#define DSPL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "graph.hpp" +#include "utils.hpp" + +struct Comm { + GraphElem size; + GraphWeight degree; + + Comm() : size(0), degree(0.0) {}; +}; + +struct CommInfo { + GraphElem community; + GraphElem size; + GraphWeight degree; +}; + +const int SizeTag = 1; +const int VertexTag = 2; +const int CommunityTag = 3; +const int CommunitySizeTag = 4; +const int CommunityDataTag = 5; + +static MPI_Datatype commType; + +void distSumVertexDegree(const Graph &g, std::vector &vDegree, std::vector &localCinfo) +{ + const GraphElem nv = g.get_lnv(); + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(g, vDegree, localCinfo), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(g, vDegree, localCinfo), schedule(guided) +#endif + for (GraphElem i = 0; i < nv; i++) { + GraphElem e0, e1; + GraphWeight tw = 0.0; + + g.edge_range(i, e0, e1); + + for (GraphElem k = e0; k < e1; k++) { + const Edge &edge = g.get_edge(k); + tw += edge.weight_; + } + + vDegree[i] = tw; + + localCinfo[i].degree = tw; + localCinfo[i].size = 1L; + } +} // distSumVertexDegree + +GraphWeight distCalcConstantForSecondTerm(const std::vector &vDegree, MPI_Comm gcomm) +{ + GraphWeight totalEdgeWeightTwice = 0.0; + GraphWeight localWeight = 0.0; + int me = -1; + + const size_t vsz = vDegree.size(); + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(vDegree), reduction(+: localWeight) schedule(runtime) +#else +#pragma omp parallel for default(none), shared(vDegree), reduction(+: localWeight) schedule(static) +#endif + for (GraphElem i = 0; i < vsz; i++) + localWeight += vDegree[i]; // Local reduction + + // Global reduction + MPI_Allreduce(&localWeight, &totalEdgeWeightTwice, 1, + MPI_WEIGHT_TYPE, MPI_SUM, gcomm); + + return (1.0 / static_cast(totalEdgeWeightTwice)); +} // distCalcConstantForSecondTerm + +void distInitComm(std::vector &pastComm, std::vector &currComm, const GraphElem base) +{ + const size_t csz = currComm.size(); + +#ifdef DEBUG_PRINTF + assert(csz == pastComm.size()); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(pastComm, currComm), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(pastComm, currComm), schedule(static) +#endif + for (GraphElem i = 0L; i < csz; i++) { + pastComm[i] = i + base; + currComm[i] = i + base; + } +} // distInitComm + +void distInitLouvain(const Graph &dg, std::vector &pastComm, + std::vector &currComm, std::vector &vDegree, + std::vector &clusterWeight, std::vector &localCinfo, + std::vector &localCupdate, GraphWeight &constantForSecondTerm, + const int me) +{ + const GraphElem base = dg.get_base(me); + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + + vDegree.resize(nv); + pastComm.resize(nv); + currComm.resize(nv); + clusterWeight.resize(nv); + localCinfo.resize(nv); + localCupdate.resize(nv); + + distSumVertexDegree(dg, vDegree, localCinfo); + constantForSecondTerm = distCalcConstantForSecondTerm(vDegree, gcomm); + + distInitComm(pastComm, currComm, base); +} // distInitLouvain + +GraphElem distGetMaxIndex(const std::unordered_map &clmap, const std::vector &counter, + const GraphWeight selfLoop, const std::vector &localCinfo, + const std::map &remoteCinfo, const GraphWeight vDegree, + const GraphElem currSize, const GraphWeight currDegree, const GraphElem currComm, + const GraphElem base, const GraphElem bound, const GraphWeight constant) +{ + std::unordered_map::const_iterator storedAlready; + GraphElem maxIndex = currComm; + GraphWeight curGain = 0.0, maxGain = 0.0; + GraphWeight eix = static_cast(counter[0]) - static_cast(selfLoop); + + GraphWeight ax = currDegree - vDegree; + GraphWeight eiy = 0.0, ay = 0.0; + + GraphElem maxSize = currSize; + GraphElem size = 0; + + storedAlready = clmap.begin(); +#ifdef DEBUG_PRINTF + assert(storedAlready != clmap.end()); +#endif + do { + if (currComm != storedAlready->first) { + + // is_local, direct access local info + if ((storedAlready->first >= base) && (storedAlready->first < bound)) { + ay = localCinfo[storedAlready->first-base].degree; + size = localCinfo[storedAlready->first - base].size; + } + else { + // is_remote, lookup map + std::map::const_iterator citer = remoteCinfo.find(storedAlready->first); + ay = citer->second.degree; + size = citer->second.size; + } + + eiy = counter[storedAlready->second]; + + curGain = 2.0 * (eiy - eix) - 2.0 * vDegree * (ay - ax) * constant; + + if ((curGain > maxGain) || + ((curGain == maxGain) && (curGain != 0.0) && (storedAlready->first < maxIndex))) { + maxGain = curGain; + maxIndex = storedAlready->first; + maxSize = size; + } + } + storedAlready++; + } while (storedAlready != clmap.end()); + + if ((maxSize == 1) && (currSize == 1) && (maxIndex > currComm)) + maxIndex = currComm; + + return maxIndex; +} // distGetMaxIndex + +GraphWeight distBuildLocalMapCounter(const GraphElem e0, const GraphElem e1, std::unordered_map &clmap, + std::vector &counter, const Graph &g, + const std::vector &currComm, + const std::unordered_map &remoteComm, + const GraphElem vertex, const GraphElem base, const GraphElem bound) +{ + GraphElem numUniqueClusters = 1L; + GraphWeight selfLoop = 0; + std::unordered_map::const_iterator storedAlready; + + for (GraphElem j = e0; j < e1; j++) { + + const Edge &edge = g.get_edge(j); + const GraphElem &tail_ = edge.tail_; + const GraphWeight &weight = edge.weight_; + GraphElem tcomm; + + if (tail_ == vertex + base) + selfLoop += weight; + + // is_local, direct access local std::vector + if ((tail_ >= base) && (tail_ < bound)) + tcomm = currComm[tail_ - base]; + else { // is_remote, lookup map + std::unordered_map::const_iterator iter = remoteComm.find(tail_); + +#ifdef DEBUG_PRINTF + assert(iter != remoteComm.end()); +#endif + tcomm = iter->second; + } + + storedAlready = clmap.find(tcomm); + + if (storedAlready != clmap.end()) + counter[storedAlready->second] += weight; + else { + clmap.insert(std::unordered_map::value_type(tcomm, numUniqueClusters)); + counter.push_back(weight); + numUniqueClusters++; + } + } + + return selfLoop; +} // distBuildLocalMapCounter + +void distExecuteLouvainIteration(const GraphElem i, const Graph &dg, const std::vector &currComm, + std::vector &targetComm, const std::vector &vDegree, + std::vector &localCinfo, std::vector &localCupdate, + const std::unordered_map &remoteComm, + const std::map &remoteCinfo, + std::map &remoteCupdate, const GraphWeight constantForSecondTerm, + std::vector &clusterWeight, const int me) +{ + GraphElem localTarget = -1; + GraphElem e0, e1, selfLoop = 0; + std::unordered_map clmap; + std::vector counter; + + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + const GraphElem cc = currComm[i]; + GraphWeight ccDegree; + GraphElem ccSize; + bool currCommIsLocal = false; + bool targetCommIsLocal = false; + + // Current Community is local + if (cc >= base && cc < bound) { + ccDegree=localCinfo[cc-base].degree; + ccSize=localCinfo[cc-base].size; + currCommIsLocal=true; + } else { + // is remote + std::map::const_iterator citer = remoteCinfo.find(cc); + ccDegree = citer->second.degree; + ccSize = citer->second.size; + currCommIsLocal=false; + } + + dg.edge_range(i, e0, e1); + + if (e0 != e1) { + clmap.insert(std::unordered_map::value_type(cc, 0)); + counter.push_back(0.0); + + selfLoop = distBuildLocalMapCounter(e0, e1, clmap, counter, dg, + currComm, remoteComm, i, base, bound); + + clusterWeight[i] += counter[0]; + + localTarget = distGetMaxIndex(clmap, counter, selfLoop, localCinfo, remoteCinfo, + vDegree[i], ccSize, ccDegree, cc, base, bound, constantForSecondTerm); + } + else + localTarget = cc; + + // is the Target Local? + if (localTarget >= base && localTarget < bound) + targetCommIsLocal = true; + + // current and target comm are local - atomic updates to vectors + if ((localTarget != cc) && (localTarget != -1) && currCommIsLocal && targetCommIsLocal) { + +#ifdef DEBUG_PRINTF + assert( base < localTarget < bound); + assert( base < cc < bound); + assert( cc - base < localCupdate.size()); + assert( localTarget - base < localCupdate.size()); +#endif + #pragma omp atomic update + localCupdate[localTarget-base].degree += vDegree[i]; + #pragma omp atomic update + localCupdate[localTarget-base].size++; + #pragma omp atomic update + localCupdate[cc-base].degree -= vDegree[i]; + #pragma omp atomic update + localCupdate[cc-base].size--; + } + + // current is local, target is not - do atomic on local, accumulate in Maps for remote + if ((localTarget != cc) && (localTarget != -1) && currCommIsLocal && !targetCommIsLocal) { + #pragma omp atomic update + localCupdate[cc-base].degree -= vDegree[i]; + #pragma omp atomic update + localCupdate[cc-base].size--; + + // search target! + std::map::iterator iter=remoteCupdate.find(localTarget); + + #pragma omp atomic update + iter->second.degree += vDegree[i]; + #pragma omp atomic update + iter->second.size++; + } + + // current is remote, target is local - accumulate for current, atomic on local + if ((localTarget != cc) && (localTarget != -1) && !currCommIsLocal && targetCommIsLocal) { + #pragma omp atomic update + localCupdate[localTarget-base].degree += vDegree[i]; + #pragma omp atomic update + localCupdate[localTarget-base].size++; + + // search current + std::map::iterator iter=remoteCupdate.find(cc); + + #pragma omp atomic update + iter->second.degree -= vDegree[i]; + #pragma omp atomic update + iter->second.size--; + } + + // current and target are remote - accumulate for both + if ((localTarget != cc) && (localTarget != -1) && !currCommIsLocal && !targetCommIsLocal) { + + // search current + std::map::iterator iter = remoteCupdate.find(cc); + + #pragma omp atomic update + iter->second.degree -= vDegree[i]; + #pragma omp atomic update + iter->second.size--; + + // search target + iter=remoteCupdate.find(localTarget); + + #pragma omp atomic update + iter->second.degree += vDegree[i]; + #pragma omp atomic update + iter->second.size++; + } + +#ifdef DEBUG_PRINTF + assert(localTarget != -1); +#endif + targetComm[i] = localTarget; +} // distExecuteLouvainIteration + +GraphWeight distComputeModularity(const Graph &g, std::vector &localCinfo, + const std::vector &clusterWeight, + const GraphWeight constantForSecondTerm, + const int me) +{ + const GraphElem nv = g.get_lnv(); + MPI_Comm gcomm = g.get_comm(); + + GraphWeight le_la_xx[2]; + GraphWeight e_a_xx[2] = {0.0, 0.0}; + GraphWeight le_xx = 0.0, la2_x = 0.0; + +#ifdef DEBUG_PRINTF + assert((clusterWeight.size() == nv)); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(clusterWeight, localCinfo), \ + reduction(+: le_xx), reduction(+: la2_x) schedule(runtime) +#else +#pragma omp parallel for default(none), shared(clusterWeight, localCinfo), \ + reduction(+: le_xx), reduction(+: la2_x) schedule(static) +#endif + for (GraphElem i = 0L; i < nv; i++) { + le_xx += clusterWeight[i]; + la2_x += static_cast(localCinfo[i].degree) * static_cast(localCinfo[i].degree); + } + le_la_xx[0] = le_xx; + le_la_xx[1] = la2_x; + +#ifdef DEBUG_PRINTF + const double t0 = MPI_Wtime(); +#endif + + MPI_Allreduce(le_la_xx, e_a_xx, 2, MPI_WEIGHT_TYPE, MPI_SUM, gcomm); + +#ifdef DEBUG_PRINTF + const double t1 = MPI_Wtime(); +#endif + + GraphWeight currMod = (e_a_xx[0] * constantForSecondTerm) - + (e_a_xx[1] * constantForSecondTerm * constantForSecondTerm); +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]le_xx: " << le_xx << ", la2_x: " << la2_x << std::endl; + std::cout << "[" << me << "]e_xx: " << e_a_xx[0] << ", a2_x: " << e_a_xx[1] << ", currMod: " << currMod << std::endl; + std::cout << "[" << me << "]Reduction time: " << (t1 - t0) << std::endl; +#endif + + return currMod; +} // distComputeModularity + +void distUpdateLocalCinfo(std::vector &localCinfo, const std::vector &localCupdate) +{ + size_t csz = localCinfo.size(); + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(static) +#endif + for (GraphElem i = 0L; i < csz; i++) { + localCinfo[i].size += localCupdate[i].size; + localCinfo[i].degree += localCupdate[i].degree; + } +} + +void distCleanCWandCU(const GraphElem nv, std::vector &clusterWeight, + std::vector &localCupdate) +{ +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(static) +#endif + for (GraphElem i = 0L; i < nv; i++) { + clusterWeight[i] = 0; + localCupdate[i].degree = 0; + localCupdate[i].size = 0; + } +} // distCleanCWandCU + +#if defined(USE_MPI_RMA) +void fillRemoteCommunities(const Graph &dg, const int me, const int nprocs, + const size_t &ssz, const size_t &rsz, const std::vector &ssizes, + const std::vector &rsizes, const std::vector &svdata, + const std::vector &rvdata, const std::vector &currComm, + const std::vector &localCinfo, std::map &remoteCinfo, + std::unordered_map &remoteComm, std::map &remoteCupdate, + const MPI_Win &commwin, const std::vector &disp) +#else +void fillRemoteCommunities(const Graph &dg, const int me, const int nprocs, + const size_t &ssz, const size_t &rsz, const std::vector &ssizes, + const std::vector &rsizes, const std::vector &svdata, + const std::vector &rvdata, const std::vector &currComm, + const std::vector &localCinfo, std::map &remoteCinfo, + std::unordered_map &remoteComm, std::map &remoteCupdate) +#endif +{ +#if defined(USE_MPI_RMA) + std::vector scdata(ssz); +#else + std::vector rcdata(rsz), scdata(ssz); +#endif + GraphElem spos, rpos; +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + std::vector< std::vector< GraphElem > > rcinfo(nprocs); +#else + std::vector > rcinfo(nprocs); +#endif + +#if defined(USE_MPI_SENDRECV) +#else + std::vector rreqs(nprocs), sreqs(nprocs); +#endif + +#ifdef DEBUG_PRINTF + double t0, t1, ta = 0.0; +#endif + + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + + // Collects Communities of local vertices for remote nodes +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(svdata, scdata, currComm) schedule(runtime) +#else +#pragma omp parallel for shared(svdata, scdata, currComm) schedule(static) +#endif + for (GraphElem i = 0; i < ssz; i++) { + const GraphElem vertex = svdata[i]; +#ifdef DEBUG_PRINTF + assert((vertex >= base) && (vertex < bound)); +#endif + const GraphElem comm = currComm[vertex - base]; + scdata[i] = comm; + } + + std::vector rcsizes(nprocs), scsizes(nprocs); + std::vector sinfo, rinfo; + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + spos = 0; + rpos = 0; +#if defined(USE_MPI_COLLECTIVES) + std::vector scnts(nprocs), rcnts(nprocs), sdispls(nprocs), rdispls(nprocs); + for (int i = 0; i < nprocs; i++) { + scnts[i] = ssizes[i]; + rcnts[i] = rsizes[i]; + sdispls[i] = spos; + rdispls[i] = rpos; + spos += scnts[i]; + rpos += rcnts[i]; + } + scnts[me] = 0; + rcnts[me] = 0; + MPI_Alltoallv(scdata.data(), scnts.data(), sdispls.data(), + MPI_GRAPH_TYPE, rcdata.data(), rcnts.data(), rdispls.data(), + MPI_GRAPH_TYPE, gcomm); +#elif defined(USE_MPI_RMA) + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#if defined(USE_MPI_ACCUMULATE) + MPI_Accumulate(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, + disp[i], ssizes[i], MPI_GRAPH_TYPE, MPI_REPLACE, commwin); +#else + MPI_Put(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, + disp[i], ssizes[i], MPI_GRAPH_TYPE, commwin); +#endif + } + spos += ssizes[i]; + rpos += rsizes[i]; + } +#elif defined(USE_MPI_SENDRECV) + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Sendrecv(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + rcdata.data() + rpos, rsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + gcomm, MPI_STATUSES_IGNORE); + + spos += ssizes[i]; + rpos += rsizes[i]; + } +#else + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Irecv(rcdata.data() + rpos, rsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &rreqs[i]); + else + rreqs[i] = MPI_REQUEST_NULL; + + rpos += rsizes[i]; + } + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Isend(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &sreqs[i]); + else + sreqs[i] = MPI_REQUEST_NULL; + + spos += ssizes[i]; + } + + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + ta += (t1 - t0); +#endif + + // reserve vectors +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + for (GraphElem i = 0; i < nprocs; i++) { + rcinfo[i].reserve(rpos); + } +#endif + + // fetch baseptr from MPI window +#if defined(USE_MPI_RMA) + MPI_Win_flush_all(commwin); + MPI_Barrier(gcomm); + + GraphElem *rcbuf = nullptr; + int flag = 0; + MPI_Win_get_attr(commwin, MPI_WIN_BASE, &rcbuf, &flag); +#endif + + remoteComm.clear(); + for (GraphElem i = 0; i < rpos; i++) { + +#if defined(USE_MPI_RMA) + const GraphElem comm = rcbuf[i]; +#else + const GraphElem comm = rcdata[i]; +#endif + + remoteComm.insert(std::unordered_map::value_type(rvdata[i], comm)); + const int tproc = dg.get_owner(comm); + + if (tproc != me) +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + rcinfo[tproc].emplace_back(comm); +#else + rcinfo[tproc].insert(comm); +#endif + } + + for (GraphElem i = 0; i < nv; i++) { + const GraphElem comm = currComm[i]; + const int tproc = dg.get_owner(comm); + + if (tproc != me) +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + rcinfo[tproc].emplace_back(comm); +#else + rcinfo[tproc].insert(comm); +#endif + } + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + GraphElem stcsz = 0, rtcsz = 0; + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(scsizes, rcinfo) \ + reduction(+:stcsz) schedule(runtime) +#else +#pragma omp parallel for shared(scsizes, rcinfo) \ + reduction(+:stcsz) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + scsizes[i] = rcinfo[i].size(); + stcsz += scsizes[i]; + } + + MPI_Alltoall(scsizes.data(), 1, MPI_GRAPH_TYPE, rcsizes.data(), + 1, MPI_GRAPH_TYPE, gcomm); + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + ta += (t1 - t0); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(rcsizes) \ + reduction(+:rtcsz) schedule(runtime) +#else +#pragma omp parallel for shared(rcsizes) \ + reduction(+:rtcsz) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + rtcsz += rcsizes[i]; + } + +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]Total communities to receive: " << rtcsz << std::endl; +#endif +#if defined(USE_MPI_COLLECTIVES) + std::vector rcomms(rtcsz), scomms(stcsz); +#else +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + std::vector rcomms(rtcsz); +#else + std::vector rcomms(rtcsz), scomms(stcsz); +#endif +#endif + sinfo.resize(rtcsz); + rinfo.resize(stcsz); + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + spos = 0; + rpos = 0; +#if defined(USE_MPI_COLLECTIVES) + for (int i = 0; i < nprocs; i++) { + if (i != me) { + std::copy(rcinfo[i].begin(), rcinfo[i].end(), scomms.data() + spos); + } + scnts[i] = scsizes[i]; + rcnts[i] = rcsizes[i]; + sdispls[i] = spos; + rdispls[i] = rpos; + spos += scnts[i]; + rpos += rcnts[i]; + } + scnts[me] = 0; + rcnts[me] = 0; + MPI_Alltoallv(scomms.data(), scnts.data(), sdispls.data(), + MPI_GRAPH_TYPE, rcomms.data(), rcnts.data(), rdispls.data(), + MPI_GRAPH_TYPE, gcomm); + + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo, rdispls), \ + firstprivate(i), schedule(runtime) /*, if(rcsizes[i] >= 1000) */ +#else +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo, rdispls), \ + firstprivate(i), schedule(guided) /*, if(rcsizes[i] >= 1000) */ +#endif + for (GraphElem j = 0; j < rcsizes[i]; j++) { + const GraphElem comm = rcomms[rdispls[i] + j]; + sinfo[rdispls[i] + j] = {comm, localCinfo[comm-base].size, localCinfo[comm-base].degree}; + } + } + } + + MPI_Alltoallv(sinfo.data(), rcnts.data(), rdispls.data(), + commType, rinfo.data(), scnts.data(), sdispls.data(), + commType, gcomm); +#else +#if !defined(USE_MPI_SENDRECV) + std::vector rcreqs(nprocs); +#endif + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#if defined(USE_MPI_SENDRECV) +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + MPI_Sendrecv(rcinfo[i].data(), scsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + rcomms.data() + rpos, rcsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + gcomm, MPI_STATUSES_IGNORE); +#else + std::copy(rcinfo[i].begin(), rcinfo[i].end(), scomms.data() + spos); + MPI_Sendrecv(scomms.data() + spos, scsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + rcomms.data() + rpos, rcsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + gcomm, MPI_STATUSES_IGNORE); +#endif +#else + MPI_Irecv(rcomms.data() + rpos, rcsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &rreqs[i]); +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + MPI_Isend(rcinfo[i].data(), scsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &sreqs[i]); +#else + std::copy(rcinfo[i].begin(), rcinfo[i].end(), scomms.data() + spos); + MPI_Isend(scomms.data() + spos, scsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &sreqs[i]); +#endif +#endif + } + else { +#if !defined(USE_MPI_SENDRECV) + rreqs[i] = MPI_REQUEST_NULL; + sreqs[i] = MPI_REQUEST_NULL; +#endif + } + rpos += rcsizes[i]; + spos += scsizes[i]; + } + + spos = 0; + rpos = 0; + + // poke progress on last isend/irecvs +#if !defined(USE_MPI_COLLECTIVES) && !defined(USE_MPI_SENDRECV) && defined(POKE_PROGRESS_FOR_COMMUNITY_SENDRECV_IN_LOOP) + int tf = 0, id = 0; + MPI_Testany(nprocs, sreqs.data(), &id, &tf, MPI_STATUS_IGNORE); +#endif + +#if !defined(USE_MPI_COLLECTIVES) && !defined(USE_MPI_SENDRECV) && !defined(POKE_PROGRESS_FOR_COMMUNITY_SENDRECV_IN_LOOP) + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif + + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#if defined(USE_MPI_SENDRECV) +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(guided) +#endif + for (GraphElem j = 0; j < rcsizes[i]; j++) { + const GraphElem comm = rcomms[rpos + j]; + sinfo[rpos + j] = {comm, localCinfo[comm-base].size, localCinfo[comm-base].degree}; + } + + MPI_Sendrecv(sinfo.data() + rpos, rcsizes[i], commType, i, CommunityDataTag, + rinfo.data() + spos, scsizes[i], commType, i, CommunityDataTag, + gcomm, MPI_STATUSES_IGNORE); +#else + MPI_Irecv(rinfo.data() + spos, scsizes[i], commType, i, CommunityDataTag, + gcomm, &rcreqs[i]); + + // poke progress on last isend/irecvs +#if defined(POKE_PROGRESS_FOR_COMMUNITY_SENDRECV_IN_LOOP) + int flag = 0, done = 0; + while (!done) { + MPI_Test(&sreqs[i], &flag, MPI_STATUS_IGNORE); + MPI_Test(&rreqs[i], &flag, MPI_STATUS_IGNORE); + if (flag) + done = 1; + } +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(guided) +#endif + for (GraphElem j = 0; j < rcsizes[i]; j++) { + const GraphElem comm = rcomms[rpos + j]; + sinfo[rpos + j] = {comm, localCinfo[comm-base].size, localCinfo[comm-base].degree}; + } + + MPI_Isend(sinfo.data() + rpos, rcsizes[i], commType, i, + CommunityDataTag, gcomm, &sreqs[i]); +#endif + } + else { +#if !defined(USE_MPI_SENDRECV) + rcreqs[i] = MPI_REQUEST_NULL; + sreqs[i] = MPI_REQUEST_NULL; +#endif + } + rpos += rcsizes[i]; + spos += scsizes[i]; + } + +#if !defined(USE_MPI_SENDRECV) + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rcreqs.data(), MPI_STATUSES_IGNORE); +#endif + +#endif + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + ta += (t1 - t0); +#endif + + remoteCinfo.clear(); + remoteCupdate.clear(); + + for (GraphElem i = 0; i < stcsz; i++) { + const GraphElem ccomm = rinfo[i].community; + + Comm comm; + + comm.size = rinfo[i].size; + comm.degree = rinfo[i].degree; + + remoteCinfo.insert(std::map::value_type(ccomm, comm)); + remoteCupdate.insert(std::map::value_type(ccomm, Comm())); + } +} // end fillRemoteCommunities + +void createCommunityMPIType() +{ + CommInfo cinfo; + + MPI_Aint begin, community, size, degree; + + MPI_Get_address(&cinfo, &begin); + MPI_Get_address(&cinfo.community, &community); + MPI_Get_address(&cinfo.size, &size); + MPI_Get_address(&cinfo.degree, °ree); + + int blens[] = { 1, 1, 1 }; + MPI_Aint displ[] = { community - begin, size - begin, degree - begin }; + MPI_Datatype types[] = { MPI_GRAPH_TYPE, MPI_GRAPH_TYPE, MPI_WEIGHT_TYPE }; + + MPI_Type_create_struct(3, blens, displ, types, &commType); + MPI_Type_commit(&commType); +} // createCommunityMPIType + +void destroyCommunityMPIType() +{ + MPI_Type_free(&commType); +} // destroyCommunityMPIType + +void updateRemoteCommunities(const Graph &dg, std::vector &localCinfo, + const std::map &remoteCupdate, + const int me, const int nprocs) +{ + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + std::vector> remoteArray(nprocs); + MPI_Comm gcomm = dg.get_comm(); + + // FIXME TODO can we use TBB::concurrent_vector instead, + // to make this parallel; first we have to get rid of maps + for (std::map::const_iterator iter = remoteCupdate.begin(); iter != remoteCupdate.end(); iter++) { + const GraphElem i = iter->first; + const Comm &curr = iter->second; + + const int tproc = dg.get_owner(i); + +#ifdef DEBUG_PRINTF + assert(tproc != me); +#endif + CommInfo rcinfo; + + rcinfo.community = i; + rcinfo.size = curr.size; + rcinfo.degree = curr.degree; + + remoteArray[tproc].push_back(rcinfo); + } + + std::vector send_sz(nprocs), recv_sz(nprocs); + +#ifdef DEBUG_PRINTF + GraphWeight tc = 0.0; + const double t0 = MPI_Wtime(); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for schedule(runtime) +#else +#pragma omp parallel for schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + send_sz[i] = remoteArray[i].size(); + } + + MPI_Alltoall(send_sz.data(), 1, MPI_GRAPH_TYPE, recv_sz.data(), + 1, MPI_GRAPH_TYPE, gcomm); + +#ifdef DEBUG_PRINTF + const double t1 = MPI_Wtime(); + tc += (t1 - t0); +#endif + + GraphElem rcnt = 0, scnt = 0; +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(recv_sz, send_sz) \ + reduction(+:rcnt, scnt) schedule(runtime) +#else +#pragma omp parallel for shared(recv_sz, send_sz) \ + reduction(+:rcnt, scnt) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + rcnt += recv_sz[i]; + scnt += send_sz[i]; + } +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]Total number of remote communities to update: " << scnt << std::endl; +#endif + + GraphElem currPos = 0; + std::vector rdata(rcnt); + +#ifdef DEBUG_PRINTF + const double t2 = MPI_Wtime(); +#endif +#if defined(USE_MPI_SENDRECV) + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Sendrecv(remoteArray[i].data(), send_sz[i], commType, i, CommunityDataTag, + rdata.data() + currPos, recv_sz[i], commType, i, CommunityDataTag, + gcomm, MPI_STATUSES_IGNORE); + + currPos += recv_sz[i]; + } +#else + std::vector sreqs(nprocs), rreqs(nprocs); + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Irecv(rdata.data() + currPos, recv_sz[i], commType, i, + CommunityDataTag, gcomm, &rreqs[i]); + else + rreqs[i] = MPI_REQUEST_NULL; + + currPos += recv_sz[i]; + } + + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Isend(remoteArray[i].data(), send_sz[i], commType, i, + CommunityDataTag, gcomm, &sreqs[i]); + else + sreqs[i] = MPI_REQUEST_NULL; + } + + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif +#ifdef DEBUG_PRINTF + const double t3 = MPI_Wtime(); + std::cout << "[" << me << "]Update remote community MPI time: " << (t3 - t2) << std::endl; +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(rdata, localCinfo) schedule(runtime) +#else +#pragma omp parallel for shared(rdata, localCinfo) schedule(dynamic) +#endif + for (GraphElem i = 0; i < rcnt; i++) { + const CommInfo &curr = rdata[i]; + +#ifdef DEBUG_PRINTF + assert(dg.get_owner(curr.community) == me); +#endif + localCinfo[curr.community-base].size += curr.size; + localCinfo[curr.community-base].degree += curr.degree; + } +} // updateRemoteCommunities + +// initial setup before Louvain iteration begins +#if defined(USE_MPI_RMA) +void exchangeVertexReqs(const Graph &dg, size_t &ssz, size_t &rsz, + std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, + const int me, const int nprocs, MPI_Win &commwin) +#else +void exchangeVertexReqs(const Graph &dg, size_t &ssz, size_t &rsz, + std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, + const int me, const int nprocs) +#endif +{ + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + +#ifdef USE_OPENMP_LOCK + std::vector locks(nprocs); + for (int i = 0; i < nprocs; i++) + omp_init_lock(&locks[i]); +#endif + std::vector> parray(nprocs); + +#ifdef USE_OPENMP_LOCK +#pragma omp parallel default(none), shared(dg, locks, parray) +#else +#pragma omp parallel default(none), shared(dg, parray) +#endif + { +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(guided) +#endif + for (GraphElem i = 0; i < nv; i++) { + GraphElem e0, e1; + + dg.edge_range(i, e0, e1); + + for (GraphElem j = e0; j < e1; j++) { + const Edge &edge = dg.get_edge(j); + const int tproc = dg.get_owner(edge.tail_); + + if (tproc != me) { +#ifdef USE_OPENMP_LOCK + omp_set_lock(&locks[tproc]); +#else + lock(); +#endif + parray[tproc].insert(edge.tail_); +#ifdef USE_OPENMP_LOCK + omp_unset_lock(&locks[tproc]); +#else + unlock(); +#endif + } + } + } + } + +#ifdef USE_OPENMP_LOCK + for (int i = 0; i < nprocs; i++) { + omp_destroy_lock(&locks[i]); + } +#endif + + rsizes.resize(nprocs); + ssizes.resize(nprocs); + ssz = 0, rsz = 0; + + int pproc = 0; + // TODO FIXME parallelize this loop + for (std::vector>::const_iterator iter = parray.begin(); iter != parray.end(); iter++) { + ssz += iter->size(); + ssizes[pproc] = iter->size(); + pproc++; + } + + MPI_Alltoall(ssizes.data(), 1, MPI_GRAPH_TYPE, rsizes.data(), + 1, MPI_GRAPH_TYPE, gcomm); + + GraphElem rsz_r = 0; +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(rsizes) \ + reduction(+:rsz_r) schedule(runtime) +#else +#pragma omp parallel for shared(rsizes) \ + reduction(+:rsz_r) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) + rsz_r += rsizes[i]; + rsz = rsz_r; + + svdata.resize(ssz); + rvdata.resize(rsz); + + GraphElem cpos = 0, rpos = 0; + pproc = 0; + +#if defined(USE_MPI_COLLECTIVES) + std::vector scnts(nprocs), rcnts(nprocs), sdispls(nprocs), rdispls(nprocs); + + for (std::vector>::const_iterator iter = parray.begin(); iter != parray.end(); iter++) { + std::copy(iter->begin(), iter->end(), svdata.begin() + cpos); + + scnts[pproc] = iter->size(); + rcnts[pproc] = rsizes[pproc]; + sdispls[pproc] = cpos; + rdispls[pproc] = rpos; + cpos += iter->size(); + rpos += rcnts[pproc]; + + pproc++; + } + + scnts[me] = 0; + rcnts[me] = 0; + MPI_Alltoallv(svdata.data(), scnts.data(), sdispls.data(), + MPI_GRAPH_TYPE, rvdata.data(), rcnts.data(), rdispls.data(), + MPI_GRAPH_TYPE, gcomm); +#else + std::vector rreqs(nprocs), sreqs(nprocs); + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Irecv(rvdata.data() + rpos, rsizes[i], MPI_GRAPH_TYPE, i, + VertexTag, gcomm, &rreqs[i]); + else + rreqs[i] = MPI_REQUEST_NULL; + + rpos += rsizes[i]; + } + + for (std::vector>::const_iterator iter = parray.begin(); iter != parray.end(); iter++) { + std::copy(iter->begin(), iter->end(), svdata.begin() + cpos); + + if (me != pproc) + MPI_Isend(svdata.data() + cpos, iter->size(), MPI_GRAPH_TYPE, pproc, + VertexTag, gcomm, &sreqs[pproc]); + else + sreqs[pproc] = MPI_REQUEST_NULL; + + cpos += iter->size(); + pproc++; + } + + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif + + std::swap(svdata, rvdata); + std::swap(ssizes, rsizes); + std::swap(ssz, rsz); + + // create MPI window for communities +#if defined(USE_MPI_RMA) + GraphElem *ptr = nullptr; + MPI_Info info = MPI_INFO_NULL; +#if defined(USE_MPI_ACCUMULATE) + MPI_Info_create(&info); + MPI_Info_set(info, "accumulate_ordering", "none"); + MPI_Info_set(info, "accumulate_ops", "same_op"); +#endif + MPI_Win_allocate(rsz*sizeof(GraphElem), sizeof(GraphElem), + info, gcomm, &ptr, &commwin); + MPI_Win_lock_all(MPI_MODE_NOCHECK, commwin); +#endif +} // exchangeVertexReqs + +#if defined(USE_MPI_RMA) +GraphWeight distLouvainMethod(const int me, const int nprocs, const Graph &dg, + size_t &ssz, size_t &rsz, std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, const GraphWeight lower, + const GraphWeight thresh, int &iters, MPI_Win &commwin) +#else +GraphWeight distLouvainMethod(const int me, const int nprocs, const Graph &dg, + size_t &ssz, size_t &rsz, std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, const GraphWeight lower, + const GraphWeight thresh, int &iters) +#endif +{ + std::vector pastComm, currComm, targetComm; + std::vector vDegree; + std::vector clusterWeight; + std::vector localCinfo, localCupdate; + + std::unordered_map remoteComm; + std::map remoteCinfo, remoteCupdate; + + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + + GraphWeight constantForSecondTerm; + GraphWeight prevMod = lower; + GraphWeight currMod = -1.0; + int numIters = 0; + + distInitLouvain(dg, pastComm, currComm, vDegree, clusterWeight, localCinfo, + localCupdate, constantForSecondTerm, me); + targetComm.resize(nv); + +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]constantForSecondTerm: " << constantForSecondTerm << std::endl; + if (me == 0) + std::cout << "Threshold: " << thresh << std::endl; +#endif + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + +#ifdef DEBUG_PRINTF + double t0, t1; + t0 = MPI_Wtime(); +#endif + + // setup vertices and communities +#if defined(USE_MPI_RMA) + exchangeVertexReqs(dg, ssz, rsz, ssizes, rsizes, + svdata, rvdata, me, nprocs, commwin); + + // store the remote displacements + std::vector disp(nprocs); + MPI_Exscan(ssizes.data(), (GraphElem*)disp.data(), nprocs, MPI_GRAPH_TYPE, + MPI_SUM, gcomm); +#else + exchangeVertexReqs(dg, ssz, rsz, ssizes, rsizes, + svdata, rvdata, me, nprocs); +#endif + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + std::cout << "[" << me << "]Initial communication setup time before Louvain iteration (in s): " << (t1 - t0) << std::endl; +#endif + + // start Louvain iteration + while(true) { +#ifdef DEBUG_PRINTF + const double t2 = MPI_Wtime(); + if (me == 0) + std::cout << "Starting Louvain iteration: " << numIters << std::endl; +#endif + numIters++; + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + +#if defined(USE_MPI_RMA) + fillRemoteCommunities(dg, me, nprocs, ssz, rsz, ssizes, + rsizes, svdata, rvdata, currComm, localCinfo, + remoteCinfo, remoteComm, remoteCupdate, + commwin, disp); +#else + fillRemoteCommunities(dg, me, nprocs, ssz, rsz, ssizes, + rsizes, svdata, rvdata, currComm, localCinfo, + remoteCinfo, remoteComm, remoteCupdate); +#endif + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + std::cout << "[" << me << "]Remote community map size: " << remoteComm.size() << std::endl; + std::cout << "[" << me << "]Iteration communication time: " << (t1 - t0) << std::endl; +#endif + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + +#pragma omp parallel default(none), shared(clusterWeight, localCupdate, currComm, targetComm, \ + vDegree, localCinfo, remoteCinfo, remoteComm, pastComm, dg, remoteCupdate), \ + firstprivate(constantForSecondTerm) + { + distCleanCWandCU(nv, clusterWeight, localCupdate); + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(guided) +#endif + for (GraphElem i = 0; i < nv; i++) { + distExecuteLouvainIteration(i, dg, currComm, targetComm, vDegree, localCinfo, + localCupdate, remoteComm, remoteCinfo, remoteCupdate, + constantForSecondTerm, clusterWeight, me); + } + } + +#pragma omp parallel default(none), shared(localCinfo, localCupdate) + { + distUpdateLocalCinfo(localCinfo, localCupdate); + } + + // communicate remote communities + updateRemoteCommunities(dg, localCinfo, remoteCupdate, me, nprocs); + + // compute modularity + currMod = distComputeModularity(dg, localCinfo, clusterWeight, constantForSecondTerm, me); + + // exit criteria + if (currMod - prevMod < thresh) + break; + + prevMod = currMod; + if (prevMod < lower) + prevMod = lower; + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none) \ + shared(pastComm, currComm, targetComm) \ + schedule(runtime) +#else +#pragma omp parallel for default(none) \ + shared(pastComm, currComm, targetComm) \ + schedule(static) +#endif + for (GraphElem i = 0; i < nv; i++) { + GraphElem tmp = pastComm[i]; + pastComm[i] = currComm[i]; + currComm[i] = targetComm[i]; + targetComm[i] = tmp; + } + } // end of Louvain iteration + +#if defined(USE_MPI_RMA) + MPI_Win_unlock_all(commwin); + MPI_Win_free(&commwin); +#endif + + iters = numIters; + + vDegree.clear(); + pastComm.clear(); + currComm.clear(); + targetComm.clear(); + clusterWeight.clear(); + localCinfo.clear(); + localCupdate.clear(); + + return prevMod; +} // distLouvainMethod plain + +#endif // __DSPL diff --git a/miniVite/dspl_gpu.hpp b/miniVite/dspl_gpu.hpp new file mode 100644 index 0000000..601a382 --- /dev/null +++ b/miniVite/dspl_gpu.hpp @@ -0,0 +1,1409 @@ +// *********************************************************************** +// +// miniVite +// +// *********************************************************************** +// +// Copyright (2018) Battelle Memorial Institute +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// ************************************************************************ + +#pragma once +#ifndef DSPL_HPP +#define DSPL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "graph.hpp" +#include "utils.hpp" + +struct Comm { + GraphElem size; + GraphWeight degree; + + Comm() : size(0), degree(0.0) {}; +}; + +struct CommInfo { + GraphElem community; + GraphElem size; + GraphWeight degree; +}; + +const int SizeTag = 1; +const int VertexTag = 2; +const int CommunityTag = 3; +const int CommunitySizeTag = 4; +const int CommunityDataTag = 5; + +static MPI_Datatype commType; + +void distSumVertexDegree(const Graph &g, std::vector &vDegree, std::vector &localCinfo) +{ + const GraphElem nv = g.get_lnv(); + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(g, vDegree, localCinfo), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(g, vDegree, localCinfo), schedule(guided) +#endif + for (GraphElem i = 0; i < nv; i++) { + GraphElem e0, e1; + GraphWeight tw = 0.0; + + g.edge_range(i, e0, e1); + + for (GraphElem k = e0; k < e1; k++) { + const Edge &edge = g.get_edge(k); + tw += edge.weight_; + } + + vDegree[i] = tw; + + localCinfo[i].degree = tw; + localCinfo[i].size = 1L; + } +} // distSumVertexDegree + +GraphWeight distCalcConstantForSecondTerm(const std::vector &vDegree, MPI_Comm gcomm) +{ + GraphWeight totalEdgeWeightTwice = 0.0; + GraphWeight localWeight = 0.0; + int me = -1; + + const size_t vsz = vDegree.size(); + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(vDegree), reduction(+: localWeight) schedule(runtime) +#else +#pragma omp parallel for default(none), shared(vDegree), reduction(+: localWeight) schedule(static) +#endif + for (GraphElem i = 0; i < vsz; i++) + localWeight += vDegree[i]; // Local reduction + + // Global reduction + MPI_Allreduce(&localWeight, &totalEdgeWeightTwice, 1, + MPI_WEIGHT_TYPE, MPI_SUM, gcomm); + + return (1.0 / static_cast(totalEdgeWeightTwice)); +} // distCalcConstantForSecondTerm + +void distInitComm(std::vector &pastComm, std::vector &currComm, const GraphElem base) +{ + const size_t csz = currComm.size(); + +#ifdef DEBUG_PRINTF + assert(csz == pastComm.size()); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(pastComm, currComm), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(pastComm, currComm), schedule(static) +#endif + for (GraphElem i = 0L; i < csz; i++) { + pastComm[i] = i + base; + currComm[i] = i + base; + } +} // distInitComm + +void distInitLouvain(const Graph &dg, std::vector &pastComm, + std::vector &currComm, std::vector &vDegree, + std::vector &clusterWeight, std::vector &localCinfo, + std::vector &localCupdate, GraphWeight &constantForSecondTerm, + const int me) +{ + const GraphElem base = dg.get_base(me); + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + + vDegree.resize(nv); + pastComm.resize(nv); + currComm.resize(nv); + clusterWeight.resize(nv); + localCinfo.resize(nv); + localCupdate.resize(nv); + + distSumVertexDegree(dg, vDegree, localCinfo); + constantForSecondTerm = distCalcConstantForSecondTerm(vDegree, gcomm); + + distInitComm(pastComm, currComm, base); +} // distInitLouvain + +GraphElem distGetMaxIndex(const std::unordered_map &clmap, const std::vector &counter, + const GraphWeight selfLoop, const std::vector &localCinfo, + const std::map &remoteCinfo, const GraphWeight vDegree, + const GraphElem currSize, const GraphWeight currDegree, const GraphElem currComm, + const GraphElem base, const GraphElem bound, const GraphWeight constant) +{ + std::unordered_map::const_iterator storedAlready; + GraphElem maxIndex = currComm; + GraphWeight curGain = 0.0, maxGain = 0.0; + GraphWeight eix = static_cast(counter[0]) - static_cast(selfLoop); + + GraphWeight ax = currDegree - vDegree; + GraphWeight eiy = 0.0, ay = 0.0; + + GraphElem maxSize = currSize; + GraphElem size = 0; + + storedAlready = clmap.begin(); +#ifdef DEBUG_PRINTF + assert(storedAlready != clmap.end()); +#endif + do { + if (currComm != storedAlready->first) { + + // is_local, direct access local info + if ((storedAlready->first >= base) && (storedAlready->first < bound)) { + ay = localCinfo[storedAlready->first-base].degree; + size = localCinfo[storedAlready->first - base].size; + } + else { + // is_remote, lookup map + std::map::const_iterator citer = remoteCinfo.find(storedAlready->first); + ay = citer->second.degree; + size = citer->second.size; + } + + eiy = counter[storedAlready->second]; + + curGain = 2.0 * (eiy - eix) - 2.0 * vDegree * (ay - ax) * constant; + + if ((curGain > maxGain) || + ((curGain == maxGain) && (curGain != 0.0) && (storedAlready->first < maxIndex))) { + maxGain = curGain; + maxIndex = storedAlready->first; + maxSize = size; + } + } + storedAlready++; + } while (storedAlready != clmap.end()); + + if ((maxSize == 1) && (currSize == 1) && (maxIndex > currComm)) + maxIndex = currComm; + + return maxIndex; +} // distGetMaxIndex + +GraphWeight distBuildLocalMapCounter(const GraphElem e0, const GraphElem e1, std::unordered_map &clmap, + std::vector &counter, const Graph &g, + const std::vector &currComm, + const std::unordered_map &remoteComm, + const GraphElem vertex, const GraphElem base, const GraphElem bound) +{ + GraphElem numUniqueClusters = 1L; + GraphWeight selfLoop = 0; + std::unordered_map::const_iterator storedAlready; + + for (GraphElem j = e0; j < e1; j++) { + + const Edge &edge = g.get_edge(j); + const GraphElem &tail_ = edge.tail_; + const GraphWeight &weight = edge.weight_; + GraphElem tcomm; + + if (tail_ == vertex + base) + selfLoop += weight; + + // is_local, direct access local std::vector + if ((tail_ >= base) && (tail_ < bound)) + tcomm = currComm[tail_ - base]; + else { // is_remote, lookup map + std::unordered_map::const_iterator iter = remoteComm.find(tail_); + +#ifdef DEBUG_PRINTF + assert(iter != remoteComm.end()); +#endif + tcomm = iter->second; + } + + storedAlready = clmap.find(tcomm); + + if (storedAlready != clmap.end()) + counter[storedAlready->second] += weight; + else { + clmap.insert(std::unordered_map::value_type(tcomm, numUniqueClusters)); + counter.push_back(weight); + numUniqueClusters++; + } + } + + return selfLoop; +} // distBuildLocalMapCounter + +void distExecuteLouvainIteration(const GraphElem i, const Graph &dg, const std::vector &currComm, + std::vector &targetComm, const std::vector &vDegree, + std::vector &localCinfo, std::vector &localCupdate, + const std::unordered_map &remoteComm, + const std::map &remoteCinfo, + std::map &remoteCupdate, const GraphWeight constantForSecondTerm, + std::vector &clusterWeight, const int me) +{ + GraphElem localTarget = -1; + GraphElem e0, e1, selfLoop = 0; + std::unordered_map clmap; + std::vector counter; + + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + const GraphElem cc = currComm[i]; + GraphWeight ccDegree; + GraphElem ccSize; + bool currCommIsLocal = false; + bool targetCommIsLocal = false; + + // Current Community is local + if (cc >= base && cc < bound) { + ccDegree=localCinfo[cc-base].degree; + ccSize=localCinfo[cc-base].size; + currCommIsLocal=true; + } else { + // is remote + std::map::const_iterator citer = remoteCinfo.find(cc); + ccDegree = citer->second.degree; + ccSize = citer->second.size; + currCommIsLocal=false; + } + + dg.edge_range(i, e0, e1); + + if (e0 != e1) { + clmap.insert(std::unordered_map::value_type(cc, 0)); + counter.push_back(0.0); + + selfLoop = distBuildLocalMapCounter(e0, e1, clmap, counter, dg, + currComm, remoteComm, i, base, bound); + + clusterWeight[i] += counter[0]; + + localTarget = distGetMaxIndex(clmap, counter, selfLoop, localCinfo, remoteCinfo, + vDegree[i], ccSize, ccDegree, cc, base, bound, constantForSecondTerm); + } + else + localTarget = cc; + + // is the Target Local? + if (localTarget >= base && localTarget < bound) + targetCommIsLocal = true; + + // current and target comm are local - atomic updates to vectors + if ((localTarget != cc) && (localTarget != -1) && currCommIsLocal && targetCommIsLocal) { + +#ifdef DEBUG_PRINTF + assert( base < localTarget < bound); + assert( base < cc < bound); + assert( cc - base < localCupdate.size()); + assert( localTarget - base < localCupdate.size()); +#endif + #pragma omp atomic update + localCupdate[localTarget-base].degree += vDegree[i]; + #pragma omp atomic update + localCupdate[localTarget-base].size++; + #pragma omp atomic update + localCupdate[cc-base].degree -= vDegree[i]; + #pragma omp atomic update + localCupdate[cc-base].size--; + } + + // current is local, target is not - do atomic on local, accumulate in Maps for remote + if ((localTarget != cc) && (localTarget != -1) && currCommIsLocal && !targetCommIsLocal) { + #pragma omp atomic update + localCupdate[cc-base].degree -= vDegree[i]; + #pragma omp atomic update + localCupdate[cc-base].size--; + + // search target! + std::map::iterator iter=remoteCupdate.find(localTarget); + + #pragma omp atomic update + iter->second.degree += vDegree[i]; + #pragma omp atomic update + iter->second.size++; + } + + // current is remote, target is local - accumulate for current, atomic on local + if ((localTarget != cc) && (localTarget != -1) && !currCommIsLocal && targetCommIsLocal) { + #pragma omp atomic update + localCupdate[localTarget-base].degree += vDegree[i]; + #pragma omp atomic update + localCupdate[localTarget-base].size++; + + // search current + std::map::iterator iter=remoteCupdate.find(cc); + + #pragma omp atomic update + iter->second.degree -= vDegree[i]; + #pragma omp atomic update + iter->second.size--; + } + + // current and target are remote - accumulate for both + if ((localTarget != cc) && (localTarget != -1) && !currCommIsLocal && !targetCommIsLocal) { + + // search current + std::map::iterator iter = remoteCupdate.find(cc); + + #pragma omp atomic update + iter->second.degree -= vDegree[i]; + #pragma omp atomic update + iter->second.size--; + + // search target + iter=remoteCupdate.find(localTarget); + + #pragma omp atomic update + iter->second.degree += vDegree[i]; + #pragma omp atomic update + iter->second.size++; + } + +#ifdef DEBUG_PRINTF + assert(localTarget != -1); +#endif + targetComm[i] = localTarget; +} // distExecuteLouvainIteration + +GraphWeight distComputeModularity(const Graph &g, std::vector &localCinfo, + const std::vector &clusterWeight, + const GraphWeight constantForSecondTerm, + const int me) +{ + const GraphElem nv = g.get_lnv(); + MPI_Comm gcomm = g.get_comm(); + + GraphWeight le_la_xx[2]; + GraphWeight e_a_xx[2] = {0.0, 0.0}; + GraphWeight le_xx = 0.0, la2_x = 0.0; + +#ifdef DEBUG_PRINTF + assert((clusterWeight.size() == nv)); +#endif + +#if defined(OMP_GPU) +#pragma omp target teams distribute parallel for map(to: clusterWeight, localCinfo) reduction(+: le_xx), reduction(+: la2_x) +#elif defined(OMP_SCHEDULE_RUNTIME) +#pragma omp parallel for default(none), shared(clusterWeight, localCinfo), \ + reduction(+: le_xx), reduction(+: la2_x) schedule(runtime) +#else +#pragma omp parallel for default(none), shared(clusterWeight, localCinfo), \ + reduction(+: le_xx), reduction(+: la2_x) schedule(static) +#endif + for (GraphElem i = 0L; i < nv; i++) { + le_xx += clusterWeight[i]; + la2_x += static_cast(localCinfo[i].degree) * static_cast(localCinfo[i].degree); + } + le_la_xx[0] = le_xx; + le_la_xx[1] = la2_x; + +#ifdef DEBUG_PRINTF + const double t0 = MPI_Wtime(); +#endif + + MPI_Allreduce(le_la_xx, e_a_xx, 2, MPI_WEIGHT_TYPE, MPI_SUM, gcomm); + +#ifdef DEBUG_PRINTF + const double t1 = MPI_Wtime(); +#endif + + GraphWeight currMod = (e_a_xx[0] * constantForSecondTerm) - + (e_a_xx[1] * constantForSecondTerm * constantForSecondTerm); +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]le_xx: " << le_xx << ", la2_x: " << la2_x << std::endl; + std::cout << "[" << me << "]e_xx: " << e_a_xx[0] << ", a2_x: " << e_a_xx[1] << ", currMod: " << currMod << std::endl; + std::cout << "[" << me << "]Reduction time: " << (t1 - t0) << std::endl; +#endif + + return currMod; +} // distComputeModularity + +void distUpdateLocalCinfo(std::vector &localCinfo, const std::vector &localCupdate) +{ + size_t csz = localCinfo.size(); + +#if defined(OMP_GPU) +#pragma omp target teams distribute parallel for +#elif defined(OMP_SCHEDULE_RUNTIME) +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(static) +#endif + for (GraphElem i = 0L; i < csz; i++) { + localCinfo[i].size += localCupdate[i].size; + localCinfo[i].degree += localCupdate[i].degree; + } +} + +void distCleanCWandCU(const GraphElem nv, std::vector &clusterWeight, + std::vector &localCupdate) +{ +#if defined(OMP_GPU) +#pragma omp target teams distribute parallel for +#elif defined(OMP_SCHEDULE_RUNTIME) +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(static) +#endif + for (GraphElem i = 0L; i < nv; i++) { + clusterWeight[i] = 0; + localCupdate[i].degree = 0; + localCupdate[i].size = 0; + } +} // distCleanCWandCU + +#if defined(USE_MPI_RMA) +void fillRemoteCommunities(const Graph &dg, const int me, const int nprocs, + const size_t &ssz, const size_t &rsz, const std::vector &ssizes, + const std::vector &rsizes, const std::vector &svdata, + const std::vector &rvdata, const std::vector &currComm, + const std::vector &localCinfo, std::map &remoteCinfo, + std::unordered_map &remoteComm, std::map &remoteCupdate, + const MPI_Win &commwin, const std::vector &disp) +#else +void fillRemoteCommunities(const Graph &dg, const int me, const int nprocs, + const size_t &ssz, const size_t &rsz, const std::vector &ssizes, + const std::vector &rsizes, const std::vector &svdata, + const std::vector &rvdata, const std::vector &currComm, + const std::vector &localCinfo, std::map &remoteCinfo, + std::unordered_map &remoteComm, std::map &remoteCupdate) +#endif +{ +#if defined(USE_MPI_RMA) + std::vector scdata(ssz); +#else + std::vector rcdata(rsz), scdata(ssz); +#endif + GraphElem spos, rpos; +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + std::vector< std::vector< GraphElem > > rcinfo(nprocs); +#else + std::vector > rcinfo(nprocs); +#endif + +#if defined(USE_MPI_SENDRECV) +#else + std::vector rreqs(nprocs), sreqs(nprocs); +#endif + +#ifdef DEBUG_PRINTF + double t0, t1, ta = 0.0; +#endif + + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + + // Collects Communities of local vertices for remote nodes +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(svdata, scdata, currComm) schedule(runtime) +#else +#pragma omp parallel for shared(svdata, scdata, currComm) schedule(static) +#endif + for (GraphElem i = 0; i < ssz; i++) { + const GraphElem vertex = svdata[i]; +#ifdef DEBUG_PRINTF + assert((vertex >= base) && (vertex < bound)); +#endif + const GraphElem comm = currComm[vertex - base]; + scdata[i] = comm; + } + + std::vector rcsizes(nprocs), scsizes(nprocs); + std::vector sinfo, rinfo; + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + spos = 0; + rpos = 0; +#if defined(USE_MPI_COLLECTIVES) + std::vector scnts(nprocs), rcnts(nprocs), sdispls(nprocs), rdispls(nprocs); + for (int i = 0; i < nprocs; i++) { + scnts[i] = ssizes[i]; + rcnts[i] = rsizes[i]; + sdispls[i] = spos; + rdispls[i] = rpos; + spos += scnts[i]; + rpos += rcnts[i]; + } + scnts[me] = 0; + rcnts[me] = 0; + MPI_Alltoallv(scdata.data(), scnts.data(), sdispls.data(), + MPI_GRAPH_TYPE, rcdata.data(), rcnts.data(), rdispls.data(), + MPI_GRAPH_TYPE, gcomm); +#elif defined(USE_MPI_RMA) + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#if defined(USE_MPI_ACCUMULATE) + MPI_Accumulate(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, + disp[i], ssizes[i], MPI_GRAPH_TYPE, MPI_REPLACE, commwin); +#else + MPI_Put(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, + disp[i], ssizes[i], MPI_GRAPH_TYPE, commwin); +#endif + } + spos += ssizes[i]; + rpos += rsizes[i]; + } +#elif defined(USE_MPI_SENDRECV) + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Sendrecv(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + rcdata.data() + rpos, rsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + gcomm, MPI_STATUSES_IGNORE); + + spos += ssizes[i]; + rpos += rsizes[i]; + } +#else + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Irecv(rcdata.data() + rpos, rsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &rreqs[i]); + else + rreqs[i] = MPI_REQUEST_NULL; + + rpos += rsizes[i]; + } + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Isend(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &sreqs[i]); + else + sreqs[i] = MPI_REQUEST_NULL; + + spos += ssizes[i]; + } + + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + ta += (t1 - t0); +#endif + + // reserve vectors +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + for (GraphElem i = 0; i < nprocs; i++) { + rcinfo[i].reserve(rpos); + } +#endif + + // fetch baseptr from MPI window +#if defined(USE_MPI_RMA) + MPI_Win_flush_all(commwin); + MPI_Barrier(gcomm); + + GraphElem *rcbuf = nullptr; + int flag = 0; + MPI_Win_get_attr(commwin, MPI_WIN_BASE, &rcbuf, &flag); +#endif + + remoteComm.clear(); + for (GraphElem i = 0; i < rpos; i++) { + +#if defined(USE_MPI_RMA) + const GraphElem comm = rcbuf[i]; +#else + const GraphElem comm = rcdata[i]; +#endif + + remoteComm.insert(std::unordered_map::value_type(rvdata[i], comm)); + const int tproc = dg.get_owner(comm); + + if (tproc != me) +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + rcinfo[tproc].emplace_back(comm); +#else + rcinfo[tproc].insert(comm); +#endif + } + + for (GraphElem i = 0; i < nv; i++) { + const GraphElem comm = currComm[i]; + const int tproc = dg.get_owner(comm); + + if (tproc != me) +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + rcinfo[tproc].emplace_back(comm); +#else + rcinfo[tproc].insert(comm); +#endif + } + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + GraphElem stcsz = 0, rtcsz = 0; + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(scsizes, rcinfo) \ + reduction(+:stcsz) schedule(runtime) +#else +#pragma omp parallel for shared(scsizes, rcinfo) \ + reduction(+:stcsz) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + scsizes[i] = rcinfo[i].size(); + stcsz += scsizes[i]; + } + + MPI_Alltoall(scsizes.data(), 1, MPI_GRAPH_TYPE, rcsizes.data(), + 1, MPI_GRAPH_TYPE, gcomm); + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + ta += (t1 - t0); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(rcsizes) \ + reduction(+:rtcsz) schedule(runtime) +#else +#pragma omp parallel for shared(rcsizes) \ + reduction(+:rtcsz) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + rtcsz += rcsizes[i]; + } + +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]Total communities to receive: " << rtcsz << std::endl; +#endif +#if defined(USE_MPI_COLLECTIVES) + std::vector rcomms(rtcsz), scomms(stcsz); +#else +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + std::vector rcomms(rtcsz); +#else + std::vector rcomms(rtcsz), scomms(stcsz); +#endif +#endif + sinfo.resize(rtcsz); + rinfo.resize(stcsz); + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + spos = 0; + rpos = 0; +#if defined(USE_MPI_COLLECTIVES) + for (int i = 0; i < nprocs; i++) { + if (i != me) { + std::copy(rcinfo[i].begin(), rcinfo[i].end(), scomms.data() + spos); + } + scnts[i] = scsizes[i]; + rcnts[i] = rcsizes[i]; + sdispls[i] = spos; + rdispls[i] = rpos; + spos += scnts[i]; + rpos += rcnts[i]; + } + scnts[me] = 0; + rcnts[me] = 0; + MPI_Alltoallv(scomms.data(), scnts.data(), sdispls.data(), + MPI_GRAPH_TYPE, rcomms.data(), rcnts.data(), rdispls.data(), + MPI_GRAPH_TYPE, gcomm); + + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo, rdispls), \ + firstprivate(i), schedule(runtime) /*, if(rcsizes[i] >= 1000) */ +#else +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo, rdispls), \ + firstprivate(i), schedule(guided) /*, if(rcsizes[i] >= 1000) */ +#endif + for (GraphElem j = 0; j < rcsizes[i]; j++) { + const GraphElem comm = rcomms[rdispls[i] + j]; + sinfo[rdispls[i] + j] = {comm, localCinfo[comm-base].size, localCinfo[comm-base].degree}; + } + } + } + + MPI_Alltoallv(sinfo.data(), rcnts.data(), rdispls.data(), + commType, rinfo.data(), scnts.data(), sdispls.data(), + commType, gcomm); +#else +#if !defined(USE_MPI_SENDRECV) + std::vector rcreqs(nprocs); +#endif + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#if defined(USE_MPI_SENDRECV) +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + MPI_Sendrecv(rcinfo[i].data(), scsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + rcomms.data() + rpos, rcsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + gcomm, MPI_STATUSES_IGNORE); +#else + std::copy(rcinfo[i].begin(), rcinfo[i].end(), scomms.data() + spos); + MPI_Sendrecv(scomms.data() + spos, scsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + rcomms.data() + rpos, rcsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + gcomm, MPI_STATUSES_IGNORE); +#endif +#else + MPI_Irecv(rcomms.data() + rpos, rcsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &rreqs[i]); +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + MPI_Isend(rcinfo[i].data(), scsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &sreqs[i]); +#else + std::copy(rcinfo[i].begin(), rcinfo[i].end(), scomms.data() + spos); + MPI_Isend(scomms.data() + spos, scsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &sreqs[i]); +#endif +#endif + } + else { +#if !defined(USE_MPI_SENDRECV) + rreqs[i] = MPI_REQUEST_NULL; + sreqs[i] = MPI_REQUEST_NULL; +#endif + } + rpos += rcsizes[i]; + spos += scsizes[i]; + } + + spos = 0; + rpos = 0; + + // poke progress on last isend/irecvs +#if !defined(USE_MPI_COLLECTIVES) && !defined(USE_MPI_SENDRECV) && defined(POKE_PROGRESS_FOR_COMMUNITY_SENDRECV_IN_LOOP) + int tf = 0, id = 0; + MPI_Testany(nprocs, sreqs.data(), &id, &tf, MPI_STATUS_IGNORE); +#endif + +#if !defined(USE_MPI_COLLECTIVES) && !defined(USE_MPI_SENDRECV) && !defined(POKE_PROGRESS_FOR_COMMUNITY_SENDRECV_IN_LOOP) + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif + + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#if defined(USE_MPI_SENDRECV) +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(guided) +#endif + for (GraphElem j = 0; j < rcsizes[i]; j++) { + const GraphElem comm = rcomms[rpos + j]; + sinfo[rpos + j] = {comm, localCinfo[comm-base].size, localCinfo[comm-base].degree}; + } + + MPI_Sendrecv(sinfo.data() + rpos, rcsizes[i], commType, i, CommunityDataTag, + rinfo.data() + spos, scsizes[i], commType, i, CommunityDataTag, + gcomm, MPI_STATUSES_IGNORE); +#else + MPI_Irecv(rinfo.data() + spos, scsizes[i], commType, i, CommunityDataTag, + gcomm, &rcreqs[i]); + + // poke progress on last isend/irecvs +#if defined(POKE_PROGRESS_FOR_COMMUNITY_SENDRECV_IN_LOOP) + int flag = 0, done = 0; + while (!done) { + MPI_Test(&sreqs[i], &flag, MPI_STATUS_IGNORE); + MPI_Test(&rreqs[i], &flag, MPI_STATUS_IGNORE); + if (flag) + done = 1; + } +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(guided) +#endif + for (GraphElem j = 0; j < rcsizes[i]; j++) { + const GraphElem comm = rcomms[rpos + j]; + sinfo[rpos + j] = {comm, localCinfo[comm-base].size, localCinfo[comm-base].degree}; + } + + MPI_Isend(sinfo.data() + rpos, rcsizes[i], commType, i, + CommunityDataTag, gcomm, &sreqs[i]); +#endif + } + else { +#if !defined(USE_MPI_SENDRECV) + rcreqs[i] = MPI_REQUEST_NULL; + sreqs[i] = MPI_REQUEST_NULL; +#endif + } + rpos += rcsizes[i]; + spos += scsizes[i]; + } + +#if !defined(USE_MPI_SENDRECV) + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rcreqs.data(), MPI_STATUSES_IGNORE); +#endif + +#endif + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + ta += (t1 - t0); +#endif + + remoteCinfo.clear(); + remoteCupdate.clear(); + + for (GraphElem i = 0; i < stcsz; i++) { + const GraphElem ccomm = rinfo[i].community; + + Comm comm; + + comm.size = rinfo[i].size; + comm.degree = rinfo[i].degree; + + remoteCinfo.insert(std::map::value_type(ccomm, comm)); + remoteCupdate.insert(std::map::value_type(ccomm, Comm())); + } +} // end fillRemoteCommunities + +void createCommunityMPIType() +{ + CommInfo cinfo; + + MPI_Aint begin, community, size, degree; + + MPI_Get_address(&cinfo, &begin); + MPI_Get_address(&cinfo.community, &community); + MPI_Get_address(&cinfo.size, &size); + MPI_Get_address(&cinfo.degree, °ree); + + int blens[] = { 1, 1, 1 }; + MPI_Aint displ[] = { community - begin, size - begin, degree - begin }; + MPI_Datatype types[] = { MPI_GRAPH_TYPE, MPI_GRAPH_TYPE, MPI_WEIGHT_TYPE }; + + MPI_Type_create_struct(3, blens, displ, types, &commType); + MPI_Type_commit(&commType); +} // createCommunityMPIType + +void destroyCommunityMPIType() +{ + MPI_Type_free(&commType); +} // destroyCommunityMPIType + +void updateRemoteCommunities(const Graph &dg, std::vector &localCinfo, + const std::map &remoteCupdate, + const int me, const int nprocs) +{ + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + std::vector> remoteArray(nprocs); + MPI_Comm gcomm = dg.get_comm(); + + // FIXME TODO can we use TBB::concurrent_vector instead, + // to make this parallel; first we have to get rid of maps + for (std::map::const_iterator iter = remoteCupdate.begin(); iter != remoteCupdate.end(); iter++) { + const GraphElem i = iter->first; + const Comm &curr = iter->second; + + const int tproc = dg.get_owner(i); + +#ifdef DEBUG_PRINTF + assert(tproc != me); +#endif + CommInfo rcinfo; + + rcinfo.community = i; + rcinfo.size = curr.size; + rcinfo.degree = curr.degree; + + remoteArray[tproc].push_back(rcinfo); + } + + std::vector send_sz(nprocs), recv_sz(nprocs); + +#ifdef DEBUG_PRINTF + GraphWeight tc = 0.0; + const double t0 = MPI_Wtime(); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for schedule(runtime) +#else +#pragma omp parallel for schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + send_sz[i] = remoteArray[i].size(); + } + + MPI_Alltoall(send_sz.data(), 1, MPI_GRAPH_TYPE, recv_sz.data(), + 1, MPI_GRAPH_TYPE, gcomm); + +#ifdef DEBUG_PRINTF + const double t1 = MPI_Wtime(); + tc += (t1 - t0); +#endif + + GraphElem rcnt = 0, scnt = 0; +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(recv_sz, send_sz) \ + reduction(+:rcnt, scnt) schedule(runtime) +#else +#pragma omp parallel for shared(recv_sz, send_sz) \ + reduction(+:rcnt, scnt) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + rcnt += recv_sz[i]; + scnt += send_sz[i]; + } +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]Total number of remote communities to update: " << scnt << std::endl; +#endif + + GraphElem currPos = 0; + std::vector rdata(rcnt); + +#ifdef DEBUG_PRINTF + const double t2 = MPI_Wtime(); +#endif +#if defined(USE_MPI_SENDRECV) + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Sendrecv(remoteArray[i].data(), send_sz[i], commType, i, CommunityDataTag, + rdata.data() + currPos, recv_sz[i], commType, i, CommunityDataTag, + gcomm, MPI_STATUSES_IGNORE); + + currPos += recv_sz[i]; + } +#else + std::vector sreqs(nprocs), rreqs(nprocs); + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Irecv(rdata.data() + currPos, recv_sz[i], commType, i, + CommunityDataTag, gcomm, &rreqs[i]); + else + rreqs[i] = MPI_REQUEST_NULL; + + currPos += recv_sz[i]; + } + + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Isend(remoteArray[i].data(), send_sz[i], commType, i, + CommunityDataTag, gcomm, &sreqs[i]); + else + sreqs[i] = MPI_REQUEST_NULL; + } + + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif +#ifdef DEBUG_PRINTF + const double t3 = MPI_Wtime(); + std::cout << "[" << me << "]Update remote community MPI time: " << (t3 - t2) << std::endl; +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(rdata, localCinfo) schedule(runtime) +#else +#pragma omp parallel for shared(rdata, localCinfo) schedule(dynamic) +#endif + for (GraphElem i = 0; i < rcnt; i++) { + const CommInfo &curr = rdata[i]; + +#ifdef DEBUG_PRINTF + assert(dg.get_owner(curr.community) == me); +#endif + localCinfo[curr.community-base].size += curr.size; + localCinfo[curr.community-base].degree += curr.degree; + } +} // updateRemoteCommunities + +// initial setup before Louvain iteration begins +#if defined(USE_MPI_RMA) +void exchangeVertexReqs(const Graph &dg, size_t &ssz, size_t &rsz, + std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, + const int me, const int nprocs, MPI_Win &commwin) +#else +void exchangeVertexReqs(const Graph &dg, size_t &ssz, size_t &rsz, + std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, + const int me, const int nprocs) +#endif +{ + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + +#ifdef USE_OPENMP_LOCK + std::vector locks(nprocs); + for (int i = 0; i < nprocs; i++) + omp_init_lock(&locks[i]); +#endif + std::vector> parray(nprocs); + +#ifdef USE_OPENMP_LOCK +#pragma omp parallel default(none), shared(dg, locks, parray) +#else +#pragma omp parallel default(none), shared(dg, parray) +#endif + { +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(guided) +#endif + for (GraphElem i = 0; i < nv; i++) { + GraphElem e0, e1; + + dg.edge_range(i, e0, e1); + + for (GraphElem j = e0; j < e1; j++) { + const Edge &edge = dg.get_edge(j); + const int tproc = dg.get_owner(edge.tail_); + + if (tproc != me) { +#ifdef USE_OPENMP_LOCK + omp_set_lock(&locks[tproc]); +#else + lock(); +#endif + parray[tproc].insert(edge.tail_); +#ifdef USE_OPENMP_LOCK + omp_unset_lock(&locks[tproc]); +#else + unlock(); +#endif + } + } + } + } + +#ifdef USE_OPENMP_LOCK + for (int i = 0; i < nprocs; i++) { + omp_destroy_lock(&locks[i]); + } +#endif + + rsizes.resize(nprocs); + ssizes.resize(nprocs); + ssz = 0, rsz = 0; + + int pproc = 0; + // TODO FIXME parallelize this loop + for (std::vector>::const_iterator iter = parray.begin(); iter != parray.end(); iter++) { + ssz += iter->size(); + ssizes[pproc] = iter->size(); + pproc++; + } + + MPI_Alltoall(ssizes.data(), 1, MPI_GRAPH_TYPE, rsizes.data(), + 1, MPI_GRAPH_TYPE, gcomm); + + GraphElem rsz_r = 0; +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(rsizes) \ + reduction(+:rsz_r) schedule(runtime) +#else +#pragma omp parallel for shared(rsizes) \ + reduction(+:rsz_r) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) + rsz_r += rsizes[i]; + rsz = rsz_r; + + svdata.resize(ssz); + rvdata.resize(rsz); + + GraphElem cpos = 0, rpos = 0; + pproc = 0; + +#if defined(USE_MPI_COLLECTIVES) + std::vector scnts(nprocs), rcnts(nprocs), sdispls(nprocs), rdispls(nprocs); + + for (std::vector>::const_iterator iter = parray.begin(); iter != parray.end(); iter++) { + std::copy(iter->begin(), iter->end(), svdata.begin() + cpos); + + scnts[pproc] = iter->size(); + rcnts[pproc] = rsizes[pproc]; + sdispls[pproc] = cpos; + rdispls[pproc] = rpos; + cpos += iter->size(); + rpos += rcnts[pproc]; + + pproc++; + } + + scnts[me] = 0; + rcnts[me] = 0; + MPI_Alltoallv(svdata.data(), scnts.data(), sdispls.data(), + MPI_GRAPH_TYPE, rvdata.data(), rcnts.data(), rdispls.data(), + MPI_GRAPH_TYPE, gcomm); +#else + std::vector rreqs(nprocs), sreqs(nprocs); + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Irecv(rvdata.data() + rpos, rsizes[i], MPI_GRAPH_TYPE, i, + VertexTag, gcomm, &rreqs[i]); + else + rreqs[i] = MPI_REQUEST_NULL; + + rpos += rsizes[i]; + } + + for (std::vector>::const_iterator iter = parray.begin(); iter != parray.end(); iter++) { + std::copy(iter->begin(), iter->end(), svdata.begin() + cpos); + + if (me != pproc) + MPI_Isend(svdata.data() + cpos, iter->size(), MPI_GRAPH_TYPE, pproc, + VertexTag, gcomm, &sreqs[pproc]); + else + sreqs[pproc] = MPI_REQUEST_NULL; + + cpos += iter->size(); + pproc++; + } + + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif + + std::swap(svdata, rvdata); + std::swap(ssizes, rsizes); + std::swap(ssz, rsz); + + // create MPI window for communities +#if defined(USE_MPI_RMA) + GraphElem *ptr = nullptr; + MPI_Info info = MPI_INFO_NULL; +#if defined(USE_MPI_ACCUMULATE) + MPI_Info_create(&info); + MPI_Info_set(info, "accumulate_ordering", "none"); + MPI_Info_set(info, "accumulate_ops", "same_op"); +#endif + MPI_Win_allocate(rsz*sizeof(GraphElem), sizeof(GraphElem), + info, gcomm, &ptr, &commwin); + MPI_Win_lock_all(MPI_MODE_NOCHECK, commwin); +#endif +} // exchangeVertexReqs + +#if defined(USE_MPI_RMA) +GraphWeight distLouvainMethod(const int me, const int nprocs, const Graph &dg, + size_t &ssz, size_t &rsz, std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, const GraphWeight lower, + const GraphWeight thresh, int &iters, MPI_Win &commwin) +#else +GraphWeight distLouvainMethod(const int me, const int nprocs, const Graph &dg, + size_t &ssz, size_t &rsz, std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, const GraphWeight lower, + const GraphWeight thresh, int &iters) +#endif +{ + std::vector pastComm, currComm, targetComm; + std::vector vDegree; + std::vector clusterWeight; + std::vector localCinfo, localCupdate; + + std::unordered_map remoteComm; + std::map remoteCinfo, remoteCupdate; + + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + + GraphWeight constantForSecondTerm; + GraphWeight prevMod = lower; + GraphWeight currMod = -1.0; + int numIters = 0; + + distInitLouvain(dg, pastComm, currComm, vDegree, clusterWeight, localCinfo, + localCupdate, constantForSecondTerm, me); + targetComm.resize(nv); + +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]constantForSecondTerm: " << constantForSecondTerm << std::endl; + if (me == 0) + std::cout << "Threshold: " << thresh << std::endl; +#endif + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + +#ifdef DEBUG_PRINTF + double t0, t1; + t0 = MPI_Wtime(); +#endif + + // setup vertices and communities +#if defined(USE_MPI_RMA) + exchangeVertexReqs(dg, ssz, rsz, ssizes, rsizes, + svdata, rvdata, me, nprocs, commwin); + + // store the remote displacements + std::vector disp(nprocs); + MPI_Exscan(ssizes.data(), (GraphElem*)disp.data(), nprocs, MPI_GRAPH_TYPE, + MPI_SUM, gcomm); +#else + exchangeVertexReqs(dg, ssz, rsz, ssizes, rsizes, + svdata, rvdata, me, nprocs); +#endif + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + std::cout << "[" << me << "]Initial communication setup time before Louvain iteration (in s): " << (t1 - t0) << std::endl; +#endif + + // start Louvain iteration + while(true) { +#ifdef DEBUG_PRINTF + const double t2 = MPI_Wtime(); + if (me == 0) + std::cout << "Starting Louvain iteration: " << numIters << std::endl; +#endif + numIters++; + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + +#if defined(USE_MPI_RMA) + fillRemoteCommunities(dg, me, nprocs, ssz, rsz, ssizes, + rsizes, svdata, rvdata, currComm, localCinfo, + remoteCinfo, remoteComm, remoteCupdate, + commwin, disp); +#else + fillRemoteCommunities(dg, me, nprocs, ssz, rsz, ssizes, + rsizes, svdata, rvdata, currComm, localCinfo, + remoteCinfo, remoteComm, remoteCupdate); +#endif + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + std::cout << "[" << me << "]Remote community map size: " << remoteComm.size() << std::endl; + std::cout << "[" << me << "]Iteration communication time: " << (t1 - t0) << std::endl; +#endif + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + +#if defined(OMP_GPU) +#pragma omp target data map(from: clusterWeight, localCupdate, targetComm) map(to: dg, currComm, vDegree) \ + map(to: localCinfo, remoteCinfo, remoteComm, remoteCupdate) +#else +#pragma omp parallel default(none), shared(clusterWeight, localCupdate, currComm, targetComm, \ + vDegree, localCinfo, remoteCinfo, remoteComm, pastComm, dg, remoteCupdate), \ + firstprivate(constantForSecondTerm) +#endif + { + distCleanCWandCU(nv, clusterWeight, localCupdate); + +#if defined(OMP_GPU) +#pragma omp target teams distribute parallel for +#elif defined(OMP_SCHEDULE_RUNTIME) +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(guided) +#endif + for (GraphElem i = 0; i < nv; i++) { + distExecuteLouvainIteration(i, dg, currComm, targetComm, vDegree, localCinfo, + localCupdate, remoteComm, remoteCinfo, remoteCupdate, + constantForSecondTerm, clusterWeight, me); + } + } + +#if defined(OMP_GPU) +#pragma omp target data map(to: localCinfo, localCupdate) +#else +#pragma omp parallel default(none), shared(localCinfo, localCupdate) +#endif + { + distUpdateLocalCinfo(localCinfo, localCupdate); + } + + // communicate remote communities + updateRemoteCommunities(dg, localCinfo, remoteCupdate, me, nprocs); + + // compute modularity + currMod = distComputeModularity(dg, localCinfo, clusterWeight, constantForSecondTerm, me); + + // exit criteria + if (currMod - prevMod < thresh) + break; + + prevMod = currMod; + if (prevMod < lower) + prevMod = lower; + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none) \ + shared(pastComm, currComm, targetComm) \ + schedule(runtime) +#else +#pragma omp parallel for default(none) \ + shared(pastComm, currComm, targetComm) \ + schedule(static) +#endif + for (GraphElem i = 0; i < nv; i++) { + GraphElem tmp = pastComm[i]; + pastComm[i] = currComm[i]; + currComm[i] = targetComm[i]; + targetComm[i] = tmp; + } + } // end of Louvain iteration + +#if defined(USE_MPI_RMA) + MPI_Win_unlock_all(commwin); + MPI_Win_free(&commwin); +#endif + + iters = numIters; + + vDegree.clear(); + pastComm.clear(); + currComm.clear(); + targetComm.clear(); + clusterWeight.clear(); + localCinfo.clear(); + localCupdate.clear(); + + return prevMod; +} // distLouvainMethod plain + +#endif // __DSPL diff --git a/miniVite/dspl_gpu_kernel.hpp b/miniVite/dspl_gpu_kernel.hpp new file mode 100644 index 0000000..1cf9c70 --- /dev/null +++ b/miniVite/dspl_gpu_kernel.hpp @@ -0,0 +1,1447 @@ +// *********************************************************************** +// +// miniVite +// +// *********************************************************************** +// +// Copyright (2018) Battelle Memorial Institute +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// ************************************************************************ + +#pragma once +#ifndef DSPL_HPP +#define DSPL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "graph.hpp" +#include "utils.hpp" + +struct Comm { + GraphElem size; + GraphWeight degree; + + Comm() : size(0), degree(0.0) {}; +}; + +struct CommInfo { + GraphElem community; + GraphElem size; + GraphWeight degree; +}; + +const int SizeTag = 1; +const int VertexTag = 2; +const int CommunityTag = 3; +const int CommunitySizeTag = 4; +const int CommunityDataTag = 5; + +static MPI_Datatype commType; + +void distSumVertexDegree(const Graph &g, std::vector &vDegree, std::vector &localCinfo) +{ + const GraphElem nv = g.get_lnv(); + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(g, vDegree, localCinfo), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(g, vDegree, localCinfo), firstprivate(nv) schedule(guided) +#endif + for (GraphElem i = 0; i < nv; i++) { + GraphElem e0, e1; + GraphWeight tw = 0.0; + + g.edge_range(i, e0, e1); + + for (GraphElem k = e0; k < e1; k++) { + const Edge &edge = g.get_edge(k); + tw += edge.weight_; + } + + vDegree[i] = tw; + + localCinfo[i].degree = tw; + localCinfo[i].size = 1L; + } +} // distSumVertexDegree + +GraphWeight distCalcConstantForSecondTerm(const std::vector &vDegree, MPI_Comm gcomm) +{ + GraphWeight totalEdgeWeightTwice = 0.0; + GraphWeight localWeight = 0.0; + int me = -1; + + const size_t vsz = vDegree.size(); + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(vDegree), reduction(+: localWeight) schedule(runtime) +#else +#pragma omp parallel for default(none), shared(vDegree), firstprivate(vsz), reduction(+: localWeight) schedule(static) +#endif + for (GraphElem i = 0; i < vsz; i++) + localWeight += vDegree[i]; // Local reduction + + // Global reduction + MPI_Allreduce(&localWeight, &totalEdgeWeightTwice, 1, + MPI_WEIGHT_TYPE, MPI_SUM, gcomm); + + return (1.0 / static_cast(totalEdgeWeightTwice)); +} // distCalcConstantForSecondTerm + +void distInitComm(std::vector &pastComm, std::vector &currComm, const GraphElem base) +{ + const size_t csz = currComm.size(); + +#ifdef DEBUG_PRINTF + assert(csz == pastComm.size()); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(pastComm, currComm), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(pastComm, currComm), firstprivate(csz, base), schedule(static) +#endif + for (GraphElem i = 0L; i < csz; i++) { + pastComm[i] = i + base; + currComm[i] = i + base; + } +} // distInitComm + +void distInitLouvain(const Graph &dg, std::vector &pastComm, + std::vector &currComm, std::vector &vDegree, + std::vector &clusterWeight, std::vector &localCinfo, + std::vector &localCupdate, GraphWeight &constantForSecondTerm, + const int me) +{ + const GraphElem base = dg.get_base(me); + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + + vDegree.resize(nv); + pastComm.resize(nv); + currComm.resize(nv); + clusterWeight.resize(nv); + localCinfo.resize(nv); + localCupdate.resize(nv); + + distSumVertexDegree(dg, vDegree, localCinfo); + constantForSecondTerm = distCalcConstantForSecondTerm(vDegree, gcomm); + + distInitComm(pastComm, currComm, base); +} // distInitLouvain + +struct clmap_t { + GraphElem f; + GraphElem s; +}; +#define CLMAP_MAX_NUM 32 +#define COUNT_MAX_NUM 32 + +GraphElem distGetMaxIndex(clmap_t *clmap, int &clmap_size, GraphWeight *counter, int &counter_size, + const GraphWeight selfLoop, const Comm *localCinfo, + const GraphWeight vDegree, + const GraphElem currSize, const GraphWeight currDegree, const GraphElem currComm, + const GraphElem base, const GraphElem bound, const GraphWeight constant) +{ + //std::unordered_map::const_iterator storedAlready; + clmap_t *storedAlready; + GraphElem maxIndex = currComm; + GraphWeight curGain = 0.0, maxGain = 0.0; + //GraphWeight eix = static_cast(counter[0]) - static_cast(selfLoop); + GraphWeight eix = counter[0] - selfLoop; + + GraphWeight ax = currDegree - vDegree; + GraphWeight eiy = 0.0, ay = 0.0; + + GraphElem maxSize = currSize; + GraphElem size = 0; + + //storedAlready = clmap.begin(); + storedAlready = clmap; +#ifdef DEBUG_PRINTF + //assert(storedAlready != clmap.end()); +#endif + do { + //if (currComm != storedAlready->first) { + if (currComm != storedAlready->f) { + + // is_local, direct access local info + //assert((storedAlready->first >= base) && (storedAlready->first < bound)); + //ay = localCinfo[storedAlready->first-base].degree; + //size = localCinfo[storedAlready->first - base].size; + //assert((storedAlready->f >= base) && (storedAlready->f < bound)); + ay = localCinfo[storedAlready->f-base].degree; + size = localCinfo[storedAlready->f - base].size; + + //eiy = counter[storedAlready->second]; + if (storedAlready->s < counter_size) + eiy = counter[storedAlready->s]; + + curGain = 2.0 * (eiy - eix) - 2.0 * vDegree * (ay - ax) * constant; + + if ((curGain > maxGain) || + //((curGain == maxGain) && (curGain != 0.0) && (storedAlready->first < maxIndex))) { + ((curGain == maxGain) && (curGain != 0.0) && (storedAlready->f < maxIndex))) { + maxGain = curGain; + //maxIndex = storedAlready->first; + maxIndex = storedAlready->f; + maxSize = size; + } + } + storedAlready++; + //} while (storedAlready != clmap.end()); + } while (storedAlready != clmap + clmap_size); + + if ((maxSize == 1) && (currSize == 1) && (maxIndex > currComm)) + maxIndex = currComm; + + return maxIndex; +} // distGetMaxIndex + +GraphWeight distBuildLocalMapCounter(const GraphElem e0, const GraphElem e1, clmap_t *clmap, int &clmap_size, + GraphWeight *counter, int &counter_size, const Edge *edge_list, + const GraphElem *currComm, + const GraphElem vertex, const GraphElem base, const GraphElem bound) +{ + GraphElem numUniqueClusters = 1L; + GraphWeight selfLoop = 0; + //std::unordered_map::const_iterator storedAlready; + clmap_t *storedAlready; + + for (GraphElem j = e0; j < e1; j++) { + + const Edge &edge = edge_list[j]; + const GraphElem &tail_ = edge.tail_; + const GraphWeight &weight = edge.weight_; + GraphElem tcomm; + + if (tail_ == vertex + base) + selfLoop += weight; + + // is_local, direct access local std::vector + tcomm = currComm[tail_ - base]; + + //storedAlready = clmap.find(tcomm); + storedAlready = clmap; + for (int i = 0; i < clmap_size; i++, storedAlready++) { + if (clmap[i].f == tcomm) + break; + } + + //if (storedAlready != clmap.end()) + // counter[storedAlready->second] += weight; + if (storedAlready != clmap + clmap_size && storedAlready->s < counter_size) + counter[storedAlready->s] += weight; + else { + //clmap.insert(std::unordered_map::value_type(tcomm, numUniqueClusters)); + if (clmap_size < CLMAP_MAX_NUM) { + clmap[clmap_size].f = tcomm; + clmap[clmap_size].s = numUniqueClusters; + clmap_size++; + } + //counter.push_back(weight); + if (counter_size < COUNT_MAX_NUM) { + counter[counter_size] = weight; + counter_size++; + } + numUniqueClusters++; + } + } + + return selfLoop; +} // distBuildLocalMapCounter + +void distExecuteLouvainIteration(const GraphElem i, const GraphElem *edge_indices, + const GraphElem *parts, const Edge *edge_list, + const GraphElem *currComm, + GraphElem *targetComm, const GraphWeight *vDegree, + Comm *localCinfo, Comm *localCupdate, + const GraphWeight constantForSecondTerm, + GraphWeight *clusterWeight, const int me) +{ + GraphElem localTarget = -1; + GraphElem e0, e1, selfLoop = 0; + //std::unordered_map clmap; + clmap_t clmap[CLMAP_MAX_NUM]; + int clmap_size = 0; + //std::vector counter; + GraphWeight counter[COUNT_MAX_NUM]; + int counter_size = 0; + + const GraphElem base = parts[me], bound = parts[me+1]; + const GraphElem cc = currComm[i]; + GraphWeight ccDegree; + GraphElem ccSize; + bool currCommIsLocal = false; + bool targetCommIsLocal = false; + + // Current Community is local +#ifdef DEBUG_PRINTF + assert(cc >= base && cc < bound); +#endif + ccDegree=localCinfo[cc-base].degree; + ccSize=localCinfo[cc-base].size; + currCommIsLocal=true; + + e0 = edge_indices[i]; + e1 = edge_indices[i+1]; + + if (e0 != e1) { + //clmap.insert(std::unordered_map::value_type(cc, 0)); + clmap[0].f = cc; + clmap[0].s = 0; + clmap_size++; + //counter.push_back(0.0); + counter[0] = 0.0; + counter_size++; + + selfLoop = distBuildLocalMapCounter(e0, e1, clmap, clmap_size, counter, counter_size, edge_list, + currComm, i, base, bound); + + clusterWeight[i] += counter[0]; + + localTarget = distGetMaxIndex(clmap, clmap_size, counter, counter_size, selfLoop, localCinfo, + vDegree[i], ccSize, ccDegree, cc, base, bound, constantForSecondTerm); + } + else + localTarget = cc; + + // is the Target Local? + //assert(localTarget >= base && localTarget < bound); + targetCommIsLocal = true; + + // current and target comm are local - atomic updates to vectors + if ((localTarget != cc) && (localTarget != -1) && currCommIsLocal && targetCommIsLocal) { + +#ifdef DEBUG_PRINTF + assert( base < localTarget < bound); + assert( base < cc < bound); + //assert( cc - base < localCupdate.size()); + //assert( localTarget - base < localCupdate.size()); +#endif + #pragma omp atomic update + localCupdate[localTarget-base].degree += vDegree[i]; + #pragma omp atomic update + localCupdate[localTarget-base].size++; + #pragma omp atomic update + localCupdate[cc-base].degree -= vDegree[i]; + #pragma omp atomic update + localCupdate[cc-base].size--; + } + +#ifdef DEBUG_PRINTF + assert(localTarget != -1); +#endif + targetComm[i] = localTarget; +} // distExecuteLouvainIteration + +GraphWeight distComputeModularity(const Graph &g, Comm *localCinfo, + const GraphWeight *clusterWeight, + const GraphWeight constantForSecondTerm, + const int me) +{ + const GraphElem nv = g.get_lnv(); + MPI_Comm gcomm = g.get_comm(); + + GraphWeight le_la_xx[2]; + GraphWeight e_a_xx[2] = {0.0, 0.0}; + GraphWeight le_xx = 0.0, la2_x = 0.0; + +#ifdef DEBUG_PRINTF + //assert((clusterWeight.size() == nv)); +#endif + +#if defined(OMP_GPU) +#pragma omp target teams distribute parallel for map(to: clusterWeight[0:nv], localCinfo[0:nv]) reduction(+: le_xx), reduction(+: la2_x) +#elif defined(OMP_SCHEDULE_RUNTIME) +#pragma omp parallel for default(none), shared(clusterWeight, localCinfo), \ + reduction(+: le_xx), reduction(+: la2_x) schedule(runtime) +#else +#pragma omp parallel for default(none), shared(clusterWeight, localCinfo), \ + reduction(+: le_xx), reduction(+: la2_x) schedule(static) +#endif + for (GraphElem i = 0L; i < nv; i++) { + le_xx += clusterWeight[i]; + //la2_x += static_cast(localCinfo[i].degree) * static_cast(localCinfo[i].degree); + la2_x += localCinfo[i].degree * localCinfo[i].degree; + } + le_la_xx[0] = le_xx; + le_la_xx[1] = la2_x; + +#ifdef DEBUG_PRINTF + const double t0 = MPI_Wtime(); +#endif + + MPI_Allreduce(le_la_xx, e_a_xx, 2, MPI_WEIGHT_TYPE, MPI_SUM, gcomm); + +#ifdef DEBUG_PRINTF + const double t1 = MPI_Wtime(); +#endif + + GraphWeight currMod = (e_a_xx[0] * constantForSecondTerm) - + (e_a_xx[1] * constantForSecondTerm * constantForSecondTerm); +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]le_xx: " << le_xx << ", la2_x: " << la2_x << std::endl; + std::cout << "[" << me << "]e_xx: " << e_a_xx[0] << ", a2_x: " << e_a_xx[1] << ", currMod: " << currMod << std::endl; + std::cout << "[" << me << "]Reduction time: " << (t1 - t0) << std::endl; +#endif + + return currMod; +} // distComputeModularity + +void distUpdateLocalCinfo(const GraphElem nv, Comm *localCinfo, const Comm *localCupdate) +{ +#if defined(OMP_GPU) +#pragma omp target teams distribute parallel for map(to \ + : localCupdate [0:nv]) \ + map(tofrom \ + : localCinfo [0:nv]) +#elif defined(OMP_SCHEDULE_RUNTIME) +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(static) +#endif + for (GraphElem i = 0L; i < nv; i++) { + localCinfo[i].size += localCupdate[i].size; + localCinfo[i].degree += localCupdate[i].degree; + } +} + +void distCleanCWandCU(const GraphElem nv, GraphWeight *clusterWeight, + Comm *localCupdate) +{ +#if defined(OMP_GPU) +#pragma omp target teams distribute parallel for map(from \ + : clusterWeight [0:nv], \ + localCupdate [0:nv]) +#elif defined(OMP_SCHEDULE_RUNTIME) +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(static) +#endif + for (GraphElem i = 0L; i < nv; i++) { + clusterWeight[i] = 0; + localCupdate[i].degree = 0; + localCupdate[i].size = 0; + } +} // distCleanCWandCU + +#if defined(USE_MPI_RMA) +void fillRemoteCommunities(const Graph &dg, const int me, const int nprocs, + const size_t &ssz, const size_t &rsz, const std::vector &ssizes, + const std::vector &rsizes, const std::vector &svdata, + const std::vector &rvdata, const std::vector &currComm, + const std::vector &localCinfo, std::map &remoteCinfo, + std::unordered_map &remoteComm, std::map &remoteCupdate, + const MPI_Win &commwin, const std::vector &disp) +#else +void fillRemoteCommunities(const Graph &dg, const int me, const int nprocs, + const size_t &ssz, const size_t &rsz, const std::vector &ssizes, + const std::vector &rsizes, const std::vector &svdata, + const std::vector &rvdata, const std::vector &currComm, + const std::vector &localCinfo, std::map &remoteCinfo, + std::unordered_map &remoteComm, std::map &remoteCupdate) +#endif +{ +#if defined(USE_MPI_RMA) + std::vector scdata(ssz); +#else + std::vector rcdata(rsz), scdata(ssz); +#endif + GraphElem spos, rpos; +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + std::vector< std::vector< GraphElem > > rcinfo(nprocs); +#else + std::vector > rcinfo(nprocs); +#endif + +#if defined(USE_MPI_SENDRECV) +#else + std::vector rreqs(nprocs), sreqs(nprocs); +#endif + +#ifdef DEBUG_PRINTF + double t0, t1, ta = 0.0; +#endif + + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + + // Collects Communities of local vertices for remote nodes +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(svdata, scdata, currComm) schedule(runtime) +#else +#pragma omp parallel for shared(svdata, scdata, currComm) schedule(static) +#endif + for (GraphElem i = 0; i < ssz; i++) { + const GraphElem vertex = svdata[i]; +#ifdef DEBUG_PRINTF + assert((vertex >= base) && (vertex < bound)); +#endif + const GraphElem comm = currComm[vertex - base]; + scdata[i] = comm; + } + + std::vector rcsizes(nprocs), scsizes(nprocs); + std::vector sinfo, rinfo; + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + spos = 0; + rpos = 0; +#if defined(USE_MPI_COLLECTIVES) + std::vector scnts(nprocs), rcnts(nprocs), sdispls(nprocs), rdispls(nprocs); + for (int i = 0; i < nprocs; i++) { + scnts[i] = ssizes[i]; + rcnts[i] = rsizes[i]; + sdispls[i] = spos; + rdispls[i] = rpos; + spos += scnts[i]; + rpos += rcnts[i]; + } + scnts[me] = 0; + rcnts[me] = 0; + MPI_Alltoallv(scdata.data(), scnts.data(), sdispls.data(), + MPI_GRAPH_TYPE, rcdata.data(), rcnts.data(), rdispls.data(), + MPI_GRAPH_TYPE, gcomm); +#elif defined(USE_MPI_RMA) + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#if defined(USE_MPI_ACCUMULATE) + MPI_Accumulate(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, + disp[i], ssizes[i], MPI_GRAPH_TYPE, MPI_REPLACE, commwin); +#else + MPI_Put(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, + disp[i], ssizes[i], MPI_GRAPH_TYPE, commwin); +#endif + } + spos += ssizes[i]; + rpos += rsizes[i]; + } +#elif defined(USE_MPI_SENDRECV) + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Sendrecv(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + rcdata.data() + rpos, rsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + gcomm, MPI_STATUSES_IGNORE); + + spos += ssizes[i]; + rpos += rsizes[i]; + } +#else + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Irecv(rcdata.data() + rpos, rsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &rreqs[i]); + else + rreqs[i] = MPI_REQUEST_NULL; + + rpos += rsizes[i]; + } + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Isend(scdata.data() + spos, ssizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &sreqs[i]); + else + sreqs[i] = MPI_REQUEST_NULL; + + spos += ssizes[i]; + } + + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + ta += (t1 - t0); +#endif + + // reserve vectors +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + for (GraphElem i = 0; i < nprocs; i++) { + rcinfo[i].reserve(rpos); + } +#endif + + // fetch baseptr from MPI window +#if defined(USE_MPI_RMA) + MPI_Win_flush_all(commwin); + MPI_Barrier(gcomm); + + GraphElem *rcbuf = nullptr; + int flag = 0; + MPI_Win_get_attr(commwin, MPI_WIN_BASE, &rcbuf, &flag); +#endif + + remoteComm.clear(); + for (GraphElem i = 0; i < rpos; i++) { + +#if defined(USE_MPI_RMA) + const GraphElem comm = rcbuf[i]; +#else + const GraphElem comm = rcdata[i]; +#endif + + remoteComm.insert(std::unordered_map::value_type(rvdata[i], comm)); + const int tproc = dg.get_owner(comm); + + if (tproc != me) +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + rcinfo[tproc].emplace_back(comm); +#else + rcinfo[tproc].insert(comm); +#endif + } + + for (GraphElem i = 0; i < nv; i++) { + const GraphElem comm = currComm[i]; + const int tproc = dg.get_owner(comm); + + if (tproc != me) +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + rcinfo[tproc].emplace_back(comm); +#else + rcinfo[tproc].insert(comm); +#endif + } + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + GraphElem stcsz = 0, rtcsz = 0; + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(scsizes, rcinfo) \ + reduction(+:stcsz) schedule(runtime) +#else +#pragma omp parallel for shared(scsizes, rcinfo) \ + reduction(+:stcsz) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + scsizes[i] = rcinfo[i].size(); + stcsz += scsizes[i]; + } + + MPI_Alltoall(scsizes.data(), 1, MPI_GRAPH_TYPE, rcsizes.data(), + 1, MPI_GRAPH_TYPE, gcomm); + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + ta += (t1 - t0); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(rcsizes) \ + reduction(+:rtcsz) schedule(runtime) +#else +#pragma omp parallel for shared(rcsizes) \ + reduction(+:rtcsz) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + rtcsz += rcsizes[i]; + } + +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]Total communities to receive: " << rtcsz << std::endl; +#endif +#if defined(USE_MPI_COLLECTIVES) + std::vector rcomms(rtcsz), scomms(stcsz); +#else +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + std::vector rcomms(rtcsz); +#else + std::vector rcomms(rtcsz), scomms(stcsz); +#endif +#endif + sinfo.resize(rtcsz); + rinfo.resize(stcsz); + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + spos = 0; + rpos = 0; +#if defined(USE_MPI_COLLECTIVES) + for (int i = 0; i < nprocs; i++) { + if (i != me) { + std::copy(rcinfo[i].begin(), rcinfo[i].end(), scomms.data() + spos); + } + scnts[i] = scsizes[i]; + rcnts[i] = rcsizes[i]; + sdispls[i] = spos; + rdispls[i] = rpos; + spos += scnts[i]; + rpos += rcnts[i]; + } + scnts[me] = 0; + rcnts[me] = 0; + MPI_Alltoallv(scomms.data(), scnts.data(), sdispls.data(), + MPI_GRAPH_TYPE, rcomms.data(), rcnts.data(), rdispls.data(), + MPI_GRAPH_TYPE, gcomm); + + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo, rdispls), \ + firstprivate(i), schedule(runtime) /*, if(rcsizes[i] >= 1000) */ +#else +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo, rdispls), \ + firstprivate(i), schedule(guided) /*, if(rcsizes[i] >= 1000) */ +#endif + for (GraphElem j = 0; j < rcsizes[i]; j++) { + const GraphElem comm = rcomms[rdispls[i] + j]; + sinfo[rdispls[i] + j] = {comm, localCinfo[comm-base].size, localCinfo[comm-base].degree}; + } + } + } + + MPI_Alltoallv(sinfo.data(), rcnts.data(), rdispls.data(), + commType, rinfo.data(), scnts.data(), sdispls.data(), + commType, gcomm); +#else +#if !defined(USE_MPI_SENDRECV) + std::vector rcreqs(nprocs); +#endif + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#if defined(USE_MPI_SENDRECV) +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + MPI_Sendrecv(rcinfo[i].data(), scsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + rcomms.data() + rpos, rcsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + gcomm, MPI_STATUSES_IGNORE); +#else + std::copy(rcinfo[i].begin(), rcinfo[i].end(), scomms.data() + spos); + MPI_Sendrecv(scomms.data() + spos, scsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + rcomms.data() + rpos, rcsizes[i], MPI_GRAPH_TYPE, i, CommunityTag, + gcomm, MPI_STATUSES_IGNORE); +#endif +#else + MPI_Irecv(rcomms.data() + rpos, rcsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &rreqs[i]); +#if defined(REPLACE_STL_UOSET_WITH_VECTOR) + MPI_Isend(rcinfo[i].data(), scsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &sreqs[i]); +#else + std::copy(rcinfo[i].begin(), rcinfo[i].end(), scomms.data() + spos); + MPI_Isend(scomms.data() + spos, scsizes[i], MPI_GRAPH_TYPE, i, + CommunityTag, gcomm, &sreqs[i]); +#endif +#endif + } + else { +#if !defined(USE_MPI_SENDRECV) + rreqs[i] = MPI_REQUEST_NULL; + sreqs[i] = MPI_REQUEST_NULL; +#endif + } + rpos += rcsizes[i]; + spos += scsizes[i]; + } + + spos = 0; + rpos = 0; + + // poke progress on last isend/irecvs +#if !defined(USE_MPI_COLLECTIVES) && !defined(USE_MPI_SENDRECV) && defined(POKE_PROGRESS_FOR_COMMUNITY_SENDRECV_IN_LOOP) + int tf = 0, id = 0; + MPI_Testany(nprocs, sreqs.data(), &id, &tf, MPI_STATUS_IGNORE); +#endif + +#if !defined(USE_MPI_COLLECTIVES) && !defined(USE_MPI_SENDRECV) && !defined(POKE_PROGRESS_FOR_COMMUNITY_SENDRECV_IN_LOOP) + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif + + for (int i = 0; i < nprocs; i++) { + if (i != me) { +#if defined(USE_MPI_SENDRECV) +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(guided) +#endif + for (GraphElem j = 0; j < rcsizes[i]; j++) { + const GraphElem comm = rcomms[rpos + j]; + sinfo[rpos + j] = {comm, localCinfo[comm-base].size, localCinfo[comm-base].degree}; + } + + MPI_Sendrecv(sinfo.data() + rpos, rcsizes[i], commType, i, CommunityDataTag, + rinfo.data() + spos, scsizes[i], commType, i, CommunityDataTag, + gcomm, MPI_STATUSES_IGNORE); +#else + MPI_Irecv(rinfo.data() + spos, scsizes[i], commType, i, CommunityDataTag, + gcomm, &rcreqs[i]); + + // poke progress on last isend/irecvs +#if defined(POKE_PROGRESS_FOR_COMMUNITY_SENDRECV_IN_LOOP) + int flag = 0, done = 0; + while (!done) { + MPI_Test(&sreqs[i], &flag, MPI_STATUS_IGNORE); + MPI_Test(&rreqs[i], &flag, MPI_STATUS_IGNORE); + if (flag) + done = 1; + } +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos), schedule(runtime) +#else +#pragma omp parallel for default(none), shared(rcsizes, rcomms, localCinfo, sinfo), \ + firstprivate(i, rpos, base), schedule(guided) +#endif + for (GraphElem j = 0; j < rcsizes[i]; j++) { + const GraphElem comm = rcomms[rpos + j]; + sinfo[rpos + j] = {comm, localCinfo[comm-base].size, localCinfo[comm-base].degree}; + } + + MPI_Isend(sinfo.data() + rpos, rcsizes[i], commType, i, + CommunityDataTag, gcomm, &sreqs[i]); +#endif + } + else { +#if !defined(USE_MPI_SENDRECV) + rcreqs[i] = MPI_REQUEST_NULL; + sreqs[i] = MPI_REQUEST_NULL; +#endif + } + rpos += rcsizes[i]; + spos += scsizes[i]; + } + +#if !defined(USE_MPI_SENDRECV) + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rcreqs.data(), MPI_STATUSES_IGNORE); +#endif + +#endif + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + ta += (t1 - t0); +#endif + + remoteCinfo.clear(); + remoteCupdate.clear(); + + for (GraphElem i = 0; i < stcsz; i++) { + const GraphElem ccomm = rinfo[i].community; + + Comm comm; + + comm.size = rinfo[i].size; + comm.degree = rinfo[i].degree; + + remoteCinfo.insert(std::map::value_type(ccomm, comm)); + remoteCupdate.insert(std::map::value_type(ccomm, Comm())); + } +} // end fillRemoteCommunities + +void createCommunityMPIType() +{ + CommInfo cinfo; + + MPI_Aint begin, community, size, degree; + + MPI_Get_address(&cinfo, &begin); + MPI_Get_address(&cinfo.community, &community); + MPI_Get_address(&cinfo.size, &size); + MPI_Get_address(&cinfo.degree, °ree); + + int blens[] = { 1, 1, 1 }; + MPI_Aint displ[] = { community - begin, size - begin, degree - begin }; + MPI_Datatype types[] = { MPI_GRAPH_TYPE, MPI_GRAPH_TYPE, MPI_WEIGHT_TYPE }; + + MPI_Type_create_struct(3, blens, displ, types, &commType); + MPI_Type_commit(&commType); +} // createCommunityMPIType + +void destroyCommunityMPIType() +{ + MPI_Type_free(&commType); +} // destroyCommunityMPIType + +void updateRemoteCommunities(const Graph &dg, std::vector &localCinfo, + const std::map &remoteCupdate, + const int me, const int nprocs) +{ + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + std::vector> remoteArray(nprocs); + MPI_Comm gcomm = dg.get_comm(); + + // FIXME TODO can we use TBB::concurrent_vector instead, + // to make this parallel; first we have to get rid of maps + for (std::map::const_iterator iter = remoteCupdate.begin(); iter != remoteCupdate.end(); iter++) { + const GraphElem i = iter->first; + const Comm &curr = iter->second; + + const int tproc = dg.get_owner(i); + +#ifdef DEBUG_PRINTF + assert(tproc != me); +#endif + CommInfo rcinfo; + + rcinfo.community = i; + rcinfo.size = curr.size; + rcinfo.degree = curr.degree; + + remoteArray[tproc].push_back(rcinfo); + } + + std::vector send_sz(nprocs), recv_sz(nprocs); + +#ifdef DEBUG_PRINTF + GraphWeight tc = 0.0; + const double t0 = MPI_Wtime(); +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for schedule(runtime) +#else +#pragma omp parallel for schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + send_sz[i] = remoteArray[i].size(); + } + + MPI_Alltoall(send_sz.data(), 1, MPI_GRAPH_TYPE, recv_sz.data(), + 1, MPI_GRAPH_TYPE, gcomm); + +#ifdef DEBUG_PRINTF + const double t1 = MPI_Wtime(); + tc += (t1 - t0); +#endif + + GraphElem rcnt = 0, scnt = 0; +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(recv_sz, send_sz) \ + reduction(+:rcnt, scnt) schedule(runtime) +#else +#pragma omp parallel for shared(recv_sz, send_sz) \ + reduction(+:rcnt, scnt) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) { + rcnt += recv_sz[i]; + scnt += send_sz[i]; + } +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]Total number of remote communities to update: " << scnt << std::endl; +#endif + + GraphElem currPos = 0; + std::vector rdata(rcnt); + +#ifdef DEBUG_PRINTF + const double t2 = MPI_Wtime(); +#endif +#if defined(USE_MPI_SENDRECV) + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Sendrecv(remoteArray[i].data(), send_sz[i], commType, i, CommunityDataTag, + rdata.data() + currPos, recv_sz[i], commType, i, CommunityDataTag, + gcomm, MPI_STATUSES_IGNORE); + + currPos += recv_sz[i]; + } +#else + std::vector sreqs(nprocs), rreqs(nprocs); + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Irecv(rdata.data() + currPos, recv_sz[i], commType, i, + CommunityDataTag, gcomm, &rreqs[i]); + else + rreqs[i] = MPI_REQUEST_NULL; + + currPos += recv_sz[i]; + } + + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Isend(remoteArray[i].data(), send_sz[i], commType, i, + CommunityDataTag, gcomm, &sreqs[i]); + else + sreqs[i] = MPI_REQUEST_NULL; + } + + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif +#ifdef DEBUG_PRINTF + const double t3 = MPI_Wtime(); + std::cout << "[" << me << "]Update remote community MPI time: " << (t3 - t2) << std::endl; +#endif + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(rdata, localCinfo) schedule(runtime) +#else +#pragma omp parallel for shared(rdata, localCinfo) schedule(dynamic) +#endif + for (GraphElem i = 0; i < rcnt; i++) { + const CommInfo &curr = rdata[i]; + +#ifdef DEBUG_PRINTF + assert(dg.get_owner(curr.community) == me); +#endif + localCinfo[curr.community-base].size += curr.size; + localCinfo[curr.community-base].degree += curr.degree; + } +} // updateRemoteCommunities + +// initial setup before Louvain iteration begins +#if defined(USE_MPI_RMA) +void exchangeVertexReqs(const Graph &dg, size_t &ssz, size_t &rsz, + std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, + const int me, const int nprocs, MPI_Win &commwin) +#else +void exchangeVertexReqs(const Graph &dg, size_t &ssz, size_t &rsz, + std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, + const int me, const int nprocs) +#endif +{ + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + +#ifdef USE_OPENMP_LOCK + std::vector locks(nprocs); + for (int i = 0; i < nprocs; i++) + omp_init_lock(&locks[i]); +#endif + std::vector> parray(nprocs); + +#ifdef USE_OPENMP_LOCK +#pragma omp parallel default(none), shared(dg, locks, parray) +#else +#pragma omp parallel default(none), shared(dg, parray) firstprivate(nv, me) +#endif + { +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(guided) +#endif + for (GraphElem i = 0; i < nv; i++) { + GraphElem e0, e1; + + dg.edge_range(i, e0, e1); + + for (GraphElem j = e0; j < e1; j++) { + const Edge &edge = dg.get_edge(j); + const int tproc = dg.get_owner(edge.tail_); + + if (tproc != me) { +#ifdef USE_OPENMP_LOCK + omp_set_lock(&locks[tproc]); +#else + lock(); +#endif + parray[tproc].insert(edge.tail_); +#ifdef USE_OPENMP_LOCK + omp_unset_lock(&locks[tproc]); +#else + unlock(); +#endif + } + } + } + } + +#ifdef USE_OPENMP_LOCK + for (int i = 0; i < nprocs; i++) { + omp_destroy_lock(&locks[i]); + } +#endif + + rsizes.resize(nprocs); + ssizes.resize(nprocs); + ssz = 0, rsz = 0; + + int pproc = 0; + // TODO FIXME parallelize this loop + for (std::vector>::const_iterator iter = parray.begin(); iter != parray.end(); iter++) { + ssz += iter->size(); + ssizes[pproc] = iter->size(); + pproc++; + } + + MPI_Alltoall(ssizes.data(), 1, MPI_GRAPH_TYPE, rsizes.data(), + 1, MPI_GRAPH_TYPE, gcomm); + + GraphElem rsz_r = 0; +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for shared(rsizes) \ + reduction(+:rsz_r) schedule(runtime) +#else +#pragma omp parallel for shared(rsizes) \ + reduction(+:rsz_r) schedule(static) +#endif + for (int i = 0; i < nprocs; i++) + rsz_r += rsizes[i]; + rsz = rsz_r; + + svdata.resize(ssz); + rvdata.resize(rsz); + + GraphElem cpos = 0, rpos = 0; + pproc = 0; + +#if defined(USE_MPI_COLLECTIVES) + std::vector scnts(nprocs), rcnts(nprocs), sdispls(nprocs), rdispls(nprocs); + + for (std::vector>::const_iterator iter = parray.begin(); iter != parray.end(); iter++) { + std::copy(iter->begin(), iter->end(), svdata.begin() + cpos); + + scnts[pproc] = iter->size(); + rcnts[pproc] = rsizes[pproc]; + sdispls[pproc] = cpos; + rdispls[pproc] = rpos; + cpos += iter->size(); + rpos += rcnts[pproc]; + + pproc++; + } + + scnts[me] = 0; + rcnts[me] = 0; + MPI_Alltoallv(svdata.data(), scnts.data(), sdispls.data(), + MPI_GRAPH_TYPE, rvdata.data(), rcnts.data(), rdispls.data(), + MPI_GRAPH_TYPE, gcomm); +#else + std::vector rreqs(nprocs), sreqs(nprocs); + for (int i = 0; i < nprocs; i++) { + if (i != me) + MPI_Irecv(rvdata.data() + rpos, rsizes[i], MPI_GRAPH_TYPE, i, + VertexTag, gcomm, &rreqs[i]); + else + rreqs[i] = MPI_REQUEST_NULL; + + rpos += rsizes[i]; + } + + for (std::vector>::const_iterator iter = parray.begin(); iter != parray.end(); iter++) { + std::copy(iter->begin(), iter->end(), svdata.begin() + cpos); + + if (me != pproc) + MPI_Isend(svdata.data() + cpos, iter->size(), MPI_GRAPH_TYPE, pproc, + VertexTag, gcomm, &sreqs[pproc]); + else + sreqs[pproc] = MPI_REQUEST_NULL; + + cpos += iter->size(); + pproc++; + } + + MPI_Waitall(nprocs, sreqs.data(), MPI_STATUSES_IGNORE); + MPI_Waitall(nprocs, rreqs.data(), MPI_STATUSES_IGNORE); +#endif + + std::swap(svdata, rvdata); + std::swap(ssizes, rsizes); + std::swap(ssz, rsz); + + // create MPI window for communities +#if defined(USE_MPI_RMA) + GraphElem *ptr = nullptr; + MPI_Info info = MPI_INFO_NULL; +#if defined(USE_MPI_ACCUMULATE) + MPI_Info_create(&info); + MPI_Info_set(info, "accumulate_ordering", "none"); + MPI_Info_set(info, "accumulate_ops", "same_op"); +#endif + MPI_Win_allocate(rsz*sizeof(GraphElem), sizeof(GraphElem), + info, gcomm, &ptr, &commwin); + MPI_Win_lock_all(MPI_MODE_NOCHECK, commwin); +#endif +} // exchangeVertexReqs + +#if defined(USE_MPI_RMA) +GraphWeight distLouvainMethod(const int me, const int nprocs, const Graph &dg, + size_t &ssz, size_t &rsz, std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, const GraphWeight lower, + const GraphWeight thresh, int &iters, MPI_Win &commwin) +#else +GraphWeight distLouvainMethod(const int me, const int nprocs, const Graph &dg, + size_t &ssz, size_t &rsz, std::vector &ssizes, std::vector &rsizes, + std::vector &svdata, std::vector &rvdata, const GraphWeight lower, + const GraphWeight thresh, int &iters) +#endif +{ + std::vector pastComm, currComm, targetComm; + std::vector vDegree; + std::vector clusterWeight; + std::vector localCinfo, localCupdate; + + std::unordered_map remoteComm; + std::map remoteCinfo, remoteCupdate; + + const GraphElem nv = dg.get_lnv(); + MPI_Comm gcomm = dg.get_comm(); + + GraphWeight constantForSecondTerm; + GraphWeight prevMod = lower; + GraphWeight currMod = -1.0; + int numIters = 0; + + distInitLouvain(dg, pastComm, currComm, vDegree, clusterWeight, localCinfo, + localCupdate, constantForSecondTerm, me); + targetComm.resize(nv); + +#ifdef DEBUG_PRINTF + std::cout << "[" << me << "]constantForSecondTerm: " << constantForSecondTerm << std::endl; + if (me == 0) + std::cout << "Threshold: " << thresh << std::endl; +#endif + const GraphElem base = dg.get_base(me), bound = dg.get_bound(me); + +#ifdef DEBUG_PRINTF + double t0, t1; + t0 = MPI_Wtime(); +#endif + + // setup vertices and communities +#if defined(USE_MPI_RMA) + exchangeVertexReqs(dg, ssz, rsz, ssizes, rsizes, + svdata, rvdata, me, nprocs, commwin); + + // store the remote displacements + std::vector disp(nprocs); + MPI_Exscan(ssizes.data(), (GraphElem*)disp.data(), nprocs, MPI_GRAPH_TYPE, + MPI_SUM, gcomm); +#else + exchangeVertexReqs(dg, ssz, rsz, ssizes, rsizes, + svdata, rvdata, me, nprocs); +#endif + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + std::cout << "[" << me << "]Initial communication setup time before Louvain iteration (in s): " << (t1 - t0) << std::endl; +#endif + +#ifdef OMP_GPU_ALLOC + GraphElem *d_edge_indices = (GraphElem *)omp_target_alloc( + (unsigned long long)dg.edge_indices_.size() * sizeof(GraphElem), -100); + memcpy(d_edge_indices, &dg.edge_indices_[0], dg.edge_indices_.size() * sizeof(GraphElem)); + GraphElem *d_parts = (GraphElem *)omp_target_alloc( + (unsigned long long)dg.parts_.size() * sizeof(GraphElem), -100); + memcpy(d_parts, &dg.parts_[0], dg.parts_.size() * sizeof(GraphElem)); + Edge *d_edge_list = (Edge *)omp_target_alloc( + (unsigned long long)dg.edge_list_.size() * sizeof(Edge), -100); + memcpy(d_edge_list, &dg.edge_list_[0], dg.edge_list_.size() * sizeof(Edge)); + GraphElem *d_currComm = (GraphElem *)omp_target_alloc( + (unsigned long long)nv * sizeof(GraphElem), -100); + memcpy(d_currComm, &currComm[0], nv * sizeof(GraphElem)); + GraphWeight *d_vDegree = (GraphWeight *)omp_target_alloc( + (unsigned long long)nv * sizeof(GraphWeight), -100); + memcpy(d_vDegree, &vDegree[0], nv * sizeof(GraphWeight)); + GraphElem *d_targetComm = (GraphElem *)omp_target_alloc( + (unsigned long long)nv * sizeof(GraphElem), -100); + memcpy(d_targetComm, &targetComm[0], nv * sizeof(GraphElem)); + Comm *d_localCinfo = + (Comm *)omp_target_alloc((unsigned long long)nv * sizeof(Comm), -100); + memcpy(d_localCinfo, &localCinfo[0], nv * sizeof(Comm)); + Comm *d_localCupdate = + (Comm *)omp_target_alloc((unsigned long long)nv * sizeof(Comm), -100); + memcpy(d_localCupdate, &localCupdate[0], nv * sizeof(Comm)); + GraphWeight *d_clusterWeight = (GraphWeight *)omp_target_alloc( + (unsigned long long)nv * sizeof(GraphWeight), -100); + memcpy(d_clusterWeight, &clusterWeight[0], nv * sizeof(GraphWeight)); +#else + const GraphElem *d_edge_indices = &dg.edge_indices_[0]; + d_edge_indices = (GraphElem *)omp_target_alloc((unsigned long long)d_edge_indices, -200); + const GraphElem *d_parts = &dg.parts_[0]; + d_parts = (GraphElem *)omp_target_alloc((unsigned long long)d_parts, -200); + const Edge *d_edge_list = &dg.edge_list_[0]; + d_edge_list = (Edge *)omp_target_alloc((unsigned long long)d_edge_list, -200); + GraphElem *d_currComm = &currComm[0]; + d_currComm = (GraphElem *)omp_target_alloc((unsigned long long)d_currComm, -200); + const GraphWeight *d_vDegree = &vDegree[0]; + d_vDegree = (GraphWeight *)omp_target_alloc((unsigned long long)d_vDegree, -200); + GraphElem *d_targetComm = &targetComm[0]; + d_targetComm = (GraphElem *)omp_target_alloc((unsigned long long)d_targetComm, -200); + Comm *d_localCinfo = &localCinfo[0]; + d_localCinfo = (Comm *)omp_target_alloc((unsigned long long)d_localCinfo, -200); + Comm *d_localCupdate = &localCupdate[0]; + d_localCupdate = (Comm *)omp_target_alloc((unsigned long long)d_localCupdate, -200); + GraphWeight *d_clusterWeight = &clusterWeight[0]; + d_clusterWeight = (GraphWeight *)omp_target_alloc((unsigned long long)d_clusterWeight, -200); +#endif + + double size = sizeof(GraphElem) * + (dg.edge_indices_.size() + dg.parts_.size() + 2 * nv) + + sizeof(Edge) * dg.edge_list_.size() + + sizeof(GraphWeight) * 2 * nv + sizeof(Comm) * 2 * nv; + double t_start = omp_get_wtime(); + + // start Louvain iteration + //while(true) { + while(numIters < 2) { +#ifdef DEBUG_PRINTF + double t2 = omp_get_wtime(); + if (me == 0) + std::cout << "Starting Louvain iteration: " << numIters << std::endl; +#endif + numIters++; + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + +#if defined(USE_MPI_RMA) + fillRemoteCommunities(dg, me, nprocs, ssz, rsz, ssizes, + rsizes, svdata, rvdata, currComm, localCinfo, + remoteCinfo, remoteComm, remoteCupdate, + commwin, disp); +#else + fillRemoteCommunities(dg, me, nprocs, ssz, rsz, ssizes, + rsizes, svdata, rvdata, currComm, localCinfo, + remoteCinfo, remoteComm, remoteCupdate); +#endif + +#ifdef DEBUG_PRINTF + t1 = MPI_Wtime(); + std::cout << "[" << me << "]Remote community map size: " << remoteComm.size() << std::endl; + std::cout << "[" << me << "]Iteration communication time: " << (t1 - t0) << std::endl; +#endif + +#ifdef DEBUG_PRINTF + t0 = MPI_Wtime(); +#endif + +#if defined(OMP_GPU) +#else +#pragma omp parallel default(none), shared(clusterWeight, localCupdate, currComm, targetComm, \ + vDegree, localCinfo, remoteComm, pastComm, dg), \ + firstprivate(constantForSecondTerm) +#endif + { + distCleanCWandCU(nv, d_clusterWeight, d_localCupdate); + +#if defined(OMP_GPU) +#pragma omp target teams distribute parallel for map( \ + to \ + : d_edge_indices [0:dg.edge_indices_.size()], \ + d_parts [0:dg.parts_.size()], d_edge_list [0:dg.edge_list_.size()], \ + d_currComm [0:nv], d_vDegree [0:nv], d_localCinfo [0:nv]) \ + map(from \ + : d_targetComm [0:nv]) \ + map(tofrom \ + : d_localCupdate [0:nv], d_clusterWeight [0:nv]) +#elif defined(OMP_SCHEDULE_RUNTIME) +#pragma omp for schedule(runtime) +#else +#pragma omp for schedule(guided) +#endif + for (GraphElem i = 0; i < nv; i++) { + distExecuteLouvainIteration(i, d_edge_indices, d_parts, d_edge_list, d_currComm, d_targetComm, d_vDegree, d_localCinfo, + d_localCupdate, constantForSecondTerm, d_clusterWeight, me); + } + } + +#if defined(OMP_GPU) +#else +#pragma omp parallel default(none), shared(localCinfo, localCupdate) +#endif + { + distUpdateLocalCinfo(nv, d_localCinfo, d_localCupdate); + } + + // communicate remote communities + updateRemoteCommunities(dg, localCinfo, remoteCupdate, me, nprocs); + + // compute modularity + currMod = distComputeModularity(dg, d_localCinfo, d_clusterWeight, constantForSecondTerm, me); + + // exit criteria + if (currMod - prevMod < thresh) + break; + + prevMod = currMod; + if (prevMod < lower) + prevMod = lower; + +#ifdef OMP_SCHEDULE_RUNTIME +#pragma omp parallel for default(none) \ + shared(pastComm, d_currComm, d_targetComm) \ + schedule(runtime) +#else +#pragma omp parallel for default(none) \ + shared(pastComm, d_currComm, d_targetComm) firstprivate(nv) \ + schedule(static) +#endif + for (GraphElem i = 0; i < nv; i++) { + GraphElem tmp = pastComm[i]; + pastComm[i] = d_currComm[i]; + d_currComm[i] = d_targetComm[i]; + d_targetComm[i] = tmp; + } + } // end of Louvain iteration + std::cout << "Total size: " << size / 1024 / 1024 / 1024 << std::endl; + std::cout << "Time: " << omp_get_wtime() - t_start << std::endl; + +#if defined(USE_MPI_RMA) + MPI_Win_unlock_all(commwin); + MPI_Win_free(&commwin); +#endif + + iters = numIters; + + vDegree.clear(); + pastComm.clear(); + currComm.clear(); + targetComm.clear(); + clusterWeight.clear(); + localCinfo.clear(); + localCupdate.clear(); + + return prevMod; +} // distLouvainMethod plain + +#endif // __DSPL diff --git a/miniVite/err b/miniVite/err new file mode 100644 index 0000000..16184dd --- /dev/null +++ b/miniVite/err @@ -0,0 +1,8 @@ +mpicxx main.o -O3 -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda -DOMP_GPU -DCHECK_NUM_EDGES -DDEBUG_PRINTF -o miniVite +nvlink error : Undefined reference to '_ZdlPv' in '/tmp/main-f4854c.cubin' +nvlink error : Undefined reference to '_ZSt17__throw_bad_allocv' in '/tmp/main-f4854c.cubin' +nvlink error : Undefined reference to '_Znwm' in '/tmp/main-f4854c.cubin' +nvlink error : Undefined reference to '_ZNKSt8__detail20_Prime_rehash_policy14_M_need_rehashEmmm' in '/tmp/main-f4854c.cubin' +nvlink error : Undefined reference to '__assert_fail' in '/tmp/main-f4854c.cubin' +nvlink error : Undefined reference to '_ZNKSt8__detail20_Prime_rehash_policy11_M_next_bktEm' in '/tmp/main-f4854c.cubin' +clang-9: error: nvlink command failed with exit code 255 (use -v to see invocation) diff --git a/miniVite/graph.hpp b/miniVite/graph.hpp new file mode 100644 index 0000000..ad8631d --- /dev/null +++ b/miniVite/graph.hpp @@ -0,0 +1,1053 @@ +// *********************************************************************** +// +// miniVite +// +// *********************************************************************** +// +// Copyright (2018) Battelle Memorial Institute +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// ************************************************************************ + +#pragma once +#ifndef GRAPH_HPP +#define GRAPH_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "utils.hpp" + +unsigned seed; + +struct Edge +{ + GraphElem tail_; + GraphWeight weight_; + + Edge(): tail_(-1), weight_(0.0) {} +}; + +struct EdgeTuple +{ + GraphElem ij_[2]; + GraphWeight w_; + + EdgeTuple(GraphElem i, GraphElem j, GraphWeight w): + ij_{i, j}, w_(w) + {} + EdgeTuple(GraphElem i, GraphElem j): + ij_{i, j}, w_(1.0) + {} + EdgeTuple(): + ij_{-1, -1}, w_(0.0) + {} +}; + +// per process graph instance +class Graph +{ + public: + Graph(): + lnv_(-1), lne_(-1), nv_(-1), + ne_(-1), comm_(MPI_COMM_WORLD) + { + MPI_Comm_size(comm_, &size_); + MPI_Comm_rank(comm_, &rank_); + } + + Graph(GraphElem lnv, GraphElem lne, + GraphElem nv, GraphElem ne, + MPI_Comm comm=MPI_COMM_WORLD): + lnv_(lnv), lne_(lne), + nv_(nv), ne_(ne), + comm_(comm) + { + MPI_Comm_size(comm_, &size_); + MPI_Comm_rank(comm_, &rank_); + + edge_indices_.resize(lnv_+1, 0); + edge_list_.resize(lne_); // this is usually populated later + + parts_.resize(size_+1); + parts_[0] = 0; + + for (GraphElem i = 1; i < size_+1; i++) + parts_[i]=((nv_ * i) / size_); + } + + ~Graph() + { + edge_list_.clear(); + edge_indices_.clear(); + parts_.clear(); + } + + // TODO FIXME put asserts like the following + // everywhere function member of Graph class + void set_edge_index(GraphElem const vertex, GraphElem const e0) + { +#if defined(DEBUG_BUILD) + assert((vertex >= 0) && (vertex <= lnv_)); + assert((e0 >= 0) && (e0 <= lne_)); + edge_indices_.at(vertex) = e0; +#else + edge_indices_[vertex] = e0; +#endif + } + + void edge_range(GraphElem const vertex, GraphElem& e0, + GraphElem& e1) const + { + e0 = edge_indices_[vertex]; + e1 = edge_indices_[vertex+1]; + } + + // collective + void set_nedges(GraphElem lne) + { + lne_ = lne; + edge_list_.resize(lne_); + + // compute total number of edges + ne_ = 0; + MPI_Allreduce(&lne_, &ne_, 1, MPI_GRAPH_TYPE, MPI_SUM, comm_); + } + + GraphElem get_base(const int rank) const + { return parts_[rank]; } + + GraphElem get_bound(const int rank) const + { return parts_[rank+1]; } + + GraphElem get_range(const int rank) const + { return (parts_[rank+1] - parts_[rank] + 1); } + + int get_owner(const GraphElem vertex) const + { + const std::vector::const_iterator iter = + std::upper_bound(parts_.begin(), parts_.end(), vertex); + + return (iter - parts_.begin() - 1); + } + + GraphElem get_lnv() const { return lnv_; } + GraphElem get_lne() const { return lne_; } + GraphElem get_nv() const { return nv_; } + GraphElem get_ne() const { return ne_; } + MPI_Comm get_comm() const { return comm_; } + + // return edge and active info + // ---------------------------- + + Edge const& get_edge(GraphElem const index) const + { return edge_list_[index]; } + + Edge& set_edge(GraphElem const index) + { return edge_list_[index]; } + + // local <--> global index translation + // ----------------------------------- + GraphElem local_to_global(GraphElem idx) + { return (idx + get_base(rank_)); } + + GraphElem global_to_local(GraphElem idx) + { return (idx - get_base(rank_)); } + + // w.r.t passed rank + GraphElem local_to_global(GraphElem idx, int rank) + { return (idx + get_base(rank)); } + + GraphElem global_to_local(GraphElem idx, int rank) + { return (idx - get_base(rank)); } + + // print edge list (with weights) + void print(bool print_weight = true) const + { + if (lne_ < MAX_PRINT_NEDGE) + { + for (int p = 0; p < size_; p++) + { + MPI_Barrier(comm_); + if (p == rank_) + { + std::cout << "###############" << std::endl; + std::cout << "Process #" << p << ": " << std::endl; + std::cout << "###############" << std::endl; + GraphElem base = get_base(p); + for (GraphElem i = 0; i < lnv_; i++) + { + GraphElem e0, e1; + edge_range(i, e0, e1); + if (print_weight) { // print weights (default) + for (GraphElem e = e0; e < e1; e++) + { + Edge const& edge = get_edge(e); + std::cout << i+base << " " << edge.tail_ << " " << edge.weight_ << std::endl; + } + } + else { // don't print weights + for (GraphElem e = e0; e < e1; e++) + { + Edge const& edge = get_edge(e); + std::cout << i+base << " " << edge.tail_ << std::endl; + } + } + } + MPI_Barrier(comm_); + } + } + } + else + { + if (rank_ == 0) + std::cout << "Graph size per process is {" << lnv_ << ", " << lne_ << + "}, which will overwhelm STDOUT." << std::endl; + } + } + + // print statistics about edge distribution + void print_dist_stats() + { + GraphElem sumdeg = 0, maxdeg = 0; + + MPI_Reduce(&lne_, &sumdeg, 1, MPI_GRAPH_TYPE, MPI_SUM, 0, comm_); + MPI_Reduce(&lne_, &maxdeg, 1, MPI_GRAPH_TYPE, MPI_MAX, 0, comm_); + + GraphElem my_sq = lne_*lne_; + GraphElem sum_sq = 0; + MPI_Reduce(&my_sq, &sum_sq, 1, MPI_GRAPH_TYPE, MPI_SUM, 0, comm_); + + GraphWeight average = (GraphWeight) sumdeg / size_; + GraphWeight avg_sq = (GraphWeight) sum_sq / size_; + GraphWeight var = avg_sq - (average*average); + GraphWeight stddev = sqrt(var); + + MPI_Barrier(comm_); + + if (rank_ == 0) + { + std::cout << std::endl; + std::cout << "-------------------------------------------------------" << std::endl; + std::cout << "Graph edge distribution characteristics" << std::endl; + std::cout << "-------------------------------------------------------" << std::endl; + std::cout << "Number of vertices: " << nv_ << std::endl; + std::cout << "Number of edges: " << ne_ << std::endl; + std::cout << "Maximum number of edges: " << maxdeg << std::endl; + std::cout << "Average number of edges: " << average << std::endl; + std::cout << "Expected value of X^2: " << avg_sq << std::endl; + std::cout << "Variance: " << var << std::endl; + std::cout << "Standard deviation: " << stddev << std::endl; + std::cout << "-------------------------------------------------------" << std::endl; + + } + } + + // public variables + std::vector edge_indices_; + std::vector edge_list_; + GraphElem lnv_, lne_, nv_, ne_; + std::vector parts_; + + MPI_Comm comm_; + int rank_, size_; + private: +}; + +// read in binary edge list files +// using MPI I/O +class BinaryEdgeList +{ + public: + BinaryEdgeList() : + M_(-1), N_(-1), + M_local_(-1), N_local_(-1), + comm_(MPI_COMM_WORLD) + {} + BinaryEdgeList(MPI_Comm comm) : + M_(-1), N_(-1), + M_local_(-1), N_local_(-1), + comm_(comm) + {} + + // the input binary file will be sorted by + // vertices + // read a file and return a graph + Graph* read(int me, int nprocs, int ranks_per_node, std::string file) + { + int file_open_error; + MPI_File fh; + MPI_Status status; + + // specify the number of aggregates + MPI_Info info; + MPI_Info_create(&info); + int naggr = (ranks_per_node > 1) ? (nprocs/ranks_per_node) : ranks_per_node; + if (naggr >= nprocs) + naggr = 1; + std::stringstream tmp_str; + tmp_str << naggr; + std::string str = tmp_str.str(); + MPI_Info_set(info, "cb_nodes", str.c_str()); + + file_open_error = MPI_File_open(comm_, file.c_str(), MPI_MODE_RDONLY, info, &fh); + MPI_Info_free(&info); + + if (file_open_error != MPI_SUCCESS) + { + std::cout << " Error opening file! " << std::endl; + MPI_Abort(comm_, -99); + } + + // read the dimensions + MPI_File_read_all(fh, &M_, sizeof(GraphElem), MPI_BYTE, &status); + MPI_File_read_all(fh, &N_, sizeof(GraphElem), MPI_BYTE, &status); + M_local_ = ((M_*(me + 1)) / nprocs) - ((M_*me) / nprocs); + + // create local graph + Graph *g = new Graph(M_local_, 0, M_, N_); + + // Let N = array length and P = number of processors. + // From j = 0 to P-1, + // Starting point of array on processor j = floor(N * j / P) + // Length of array on processor j = floor(N * (j + 1) / P) - floor(N * j / P) + + uint64_t tot_bytes=(M_local_+1)*sizeof(GraphElem); + MPI_Offset offset = 2*sizeof(GraphElem) + ((M_*me) / nprocs)*sizeof(GraphElem); + + // read in INT_MAX increments if total byte size is > INT_MAX + + if (tot_bytes < INT_MAX) + MPI_File_read_at(fh, offset, &g->edge_indices_[0], tot_bytes, MPI_BYTE, &status); + else + { + int chunk_bytes=INT_MAX; + uint8_t *curr_pointer = (uint8_t*) &g->edge_indices_[0]; + uint64_t transf_bytes = 0; + + while (transf_bytes < tot_bytes) + { + MPI_File_read_at(fh, offset, curr_pointer, chunk_bytes, MPI_BYTE, &status); + transf_bytes += chunk_bytes; + offset += chunk_bytes; + curr_pointer += chunk_bytes; + + if ((tot_bytes - transf_bytes) < INT_MAX) + chunk_bytes = tot_bytes - transf_bytes; + } + } + + N_local_ = g->edge_indices_[M_local_] - g->edge_indices_[0]; + g->set_nedges(N_local_); + + tot_bytes = N_local_*(sizeof(Edge)); + offset = 2*sizeof(GraphElem) + (M_+1)*sizeof(GraphElem) + g->edge_indices_[0]*(sizeof(Edge)); + + if (tot_bytes < INT_MAX) + MPI_File_read_at(fh, offset, &g->edge_list_[0], tot_bytes, MPI_BYTE, &status); + else + { + int chunk_bytes=INT_MAX; + uint8_t *curr_pointer = (uint8_t*)&g->edge_list_[0]; + uint64_t transf_bytes = 0; + + while (transf_bytes < tot_bytes) + { + MPI_File_read_at(fh, offset, curr_pointer, chunk_bytes, MPI_BYTE, &status); + transf_bytes += chunk_bytes; + offset += chunk_bytes; + curr_pointer += chunk_bytes; + + if ((tot_bytes - transf_bytes) < INT_MAX) + chunk_bytes = (tot_bytes - transf_bytes); + } + } + + MPI_File_close(&fh); + + for(GraphElem i=1; i < M_local_+1; i++) + g->edge_indices_[i] -= g->edge_indices_[0]; + g->edge_indices_[0] = 0; + + return g; + } + private: + GraphElem M_; + GraphElem N_; + GraphElem M_local_; + GraphElem N_local_; + MPI_Comm comm_; +}; + +// RGG graph +// 1D vertex distribution +class GenerateRGG +{ + public: + GenerateRGG(GraphElem nv, MPI_Comm comm = MPI_COMM_WORLD) + { + nv_ = nv; + comm_ = comm; + + MPI_Comm_rank(comm_, &rank_); + MPI_Comm_size(comm_, &nprocs_); + + // neighbors + up_ = down_ = MPI_PROC_NULL; + if (nprocs_ > 1) { + if (rank_ > 0 && rank_ < (nprocs_ - 1)) { + up_ = rank_ - 1; + down_ = rank_ + 1; + } + if (rank_ == 0) + down_ = 1; + if (rank_ == (nprocs_ - 1)) + up_ = rank_ - 1; + } + + n_ = nv_ / nprocs_; + + // check if number of nodes is divisible by #processes + if ((nv_ % nprocs_) != 0) { + if (rank_ == 0) { + std::cout << "[ERROR] Number of vertices must be perfectly divisible by number of processes." << std::endl; + std::cout << "Exiting..." << std::endl; + } + MPI_Abort(comm_, -99); + } + + // check if processes are power of 2 + if (!is_pwr2(nprocs_)) { + if (rank_ == 0) { + std::cout << "[ERROR] Number of processes must be a power of 2." << std::endl; + std::cout << "Exiting..." << std::endl; + } + MPI_Abort(comm_, -99); + } + + // calculate r(n) + GraphWeight rc = sqrt((GraphWeight)log(nv)/(GraphWeight)(PI*nv)); + GraphWeight rt = sqrt((GraphWeight)2.0736/(GraphWeight)nv); + rn_ = (rc + rt)/(GraphWeight)2.0; + + assert(((GraphWeight)1.0/(GraphWeight)nprocs_) > rn_); + + MPI_Barrier(comm_); + } + + // create RGG and returns Graph + // TODO FIXME use OpenMP wherever possible + // use Euclidean distance as edge weight + // for random edges, choose from (0,1) + // otherwise, use unit weight throughout + Graph* generate(bool isLCG, bool unitEdgeWeight = true, int randomEdgePercent = 0) + { + // Generate random coordinate points + std::vector X, Y, X_up, Y_up, X_down, Y_down; + + if (isLCG) + X.resize(2*n_); + else + X.resize(n_); + + Y.resize(n_); + + if (up_ != MPI_PROC_NULL) { + X_up.resize(n_); + Y_up.resize(n_); + } + + if (down_ != MPI_PROC_NULL) { + X_down.resize(n_); + Y_down.resize(n_); + } + + // create local graph + Graph *g = new Graph(n_, 0, nv_, nv_); + + // generate random number within range + // X: 0, 1 + // Y: rank_*1/p, (rank_+1)*1/p, + GraphWeight rec_np = (GraphWeight)(1.0/(GraphWeight)nprocs_); + GraphWeight lo = rank_* rec_np; + GraphWeight hi = lo + rec_np; + assert(hi > lo); + + // measure the time to generate random numbers + MPI_Barrier(MPI_COMM_WORLD); + double st = MPI_Wtime(); + + if (!isLCG) { + // set seed (declared an extern in utils) + seed = (unsigned)reseeder(1); + +#if defined(PRINT_RANDOM_XY_COORD) + for (int k = 0; k < nprocs_; k++) { + if (k == rank_) { + std::cout << "Random number generated on Process#" << k << " :" << std::endl; + for (GraphElem i = 0; i < n_; i++) { + X[i] = genRandom(0.0, 1.0); + Y[i] = genRandom(lo, hi); + std::cout << "X, Y: " << X[i] << ", " << Y[i] << std::endl; + } + } + MPI_Barrier(comm_); + } +#else + for (GraphElem i = 0; i < n_; i++) { + //X[i] = genRandom(0.0, 1.0); + //Y[i] = genRandom(lo, hi); + X[i] = 1.0 * i / n_; + Y[i] = lo + (hi - lo) * i / n_; + } +#endif + } + else { // LCG + // X | Y + // e.g seeds: 1741, 3821 + // create LCG object + // seed to generate x0 + LCG xr(/*seed*/1, X.data(), 2*n_, comm_); + + // generate random numbers between 0-1 + xr.generate(); + + // rescale xr further between lo-hi + // and put the numbers in Y taking + // from X[n] + xr.rescale(Y.data(), n_, lo); + +#if defined(PRINT_RANDOM_XY_COORD) + for (int k = 0; k < nprocs_; k++) { + if (k == rank_) { + std::cout << "Random number generated on Process#" << k << " :" << std::endl; + for (GraphElem i = 0; i < n_; i++) { + std::cout << "X, Y: " << X[i] << ", " << Y[i] << std::endl; + } + } + MPI_Barrier(comm_); + } +#endif + } + + double et = MPI_Wtime(); + double tt = et - st; + double tot_tt = 0.0; + MPI_Reduce(&tt, &tot_tt, 1, MPI_DOUBLE, MPI_SUM, 0, comm_); + + if (rank_ == 0) { + double tot_avg = (tot_tt/nprocs_); + std::cout << "Average time to generate " << 2*n_ + << " random numbers using LCG (in s): " + << tot_avg << std::endl; + } + + // ghost(s) + + // cross edges, each processor + // communicates with up or/and down + // neighbor only + std::vector sendup_edges, senddn_edges; + std::vector recvup_edges, recvdn_edges; + std::vector edgeList; + + // counts, indexing: [2] = {up - 0, down - 1} + // TODO can't we use MPI_INT + std::array send_sizes = {0, 0}, recv_sizes = {0, 0}; +#if defined(CHECK_NUM_EDGES) + GraphElem numEdges = 0; +#endif + // local + for (GraphElem i = 0; i < n_; i++) { + //for (GraphElem j = i + 1; j < n_; j++) { + for (GraphElem j = i + 1; j < n_ && j < i + 10; j++) { + // euclidean distance: + // 2D: sqrt((px-qx)^2 + (py-qy)^2) + GraphWeight dx = X[i] - X[j]; + GraphWeight dy = Y[i] - Y[j]; + GraphWeight ed = sqrt(dx*dx + dy*dy); + // are the two vertices within the range? + if (ed <= rn_) { + // local to global index + const GraphElem g_i = g->local_to_global(i); + const GraphElem g_j = g->local_to_global(j); + + if (!unitEdgeWeight) { + edgeList.emplace_back(i, g_j, ed); + edgeList.emplace_back(j, g_i, ed); + } + else { + edgeList.emplace_back(i, g_j); + edgeList.emplace_back(j, g_i); + } +#if defined(CHECK_NUM_EDGES) + numEdges += 2; +#endif + + g->edge_indices_[i+1]++; + g->edge_indices_[j+1]++; + } + } + } + + MPI_Barrier(comm_); + + // communicate ghost coordinates with neighbors + + const int x_ndown = X_down.empty() ? 0 : n_; + const int y_ndown = Y_down.empty() ? 0 : n_; + const int x_nup = X_up.empty() ? 0 : n_; + const int y_nup = Y_up.empty() ? 0 : n_; + + MPI_Sendrecv(X.data(), n_, MPI_WEIGHT_TYPE, up_, SR_X_UP_TAG, + X_down.data(), x_ndown, MPI_WEIGHT_TYPE, down_, SR_X_UP_TAG, + comm_, MPI_STATUS_IGNORE); + MPI_Sendrecv(X.data(), n_, MPI_WEIGHT_TYPE, down_, SR_X_DOWN_TAG, + X_up.data(), x_nup, MPI_WEIGHT_TYPE, up_, SR_X_DOWN_TAG, + comm_, MPI_STATUS_IGNORE); + MPI_Sendrecv(Y.data(), n_, MPI_WEIGHT_TYPE, up_, SR_Y_UP_TAG, + Y_down.data(), y_ndown, MPI_WEIGHT_TYPE, down_, SR_Y_UP_TAG, + comm_, MPI_STATUS_IGNORE); + MPI_Sendrecv(Y.data(), n_, MPI_WEIGHT_TYPE, down_, SR_Y_DOWN_TAG, + Y_up.data(), y_nup, MPI_WEIGHT_TYPE, up_, SR_Y_DOWN_TAG, + comm_, MPI_STATUS_IGNORE); + + // exchange ghost vertices / cross edges + if (nprocs_ > 1) { + if (up_ != MPI_PROC_NULL) { + + for (GraphElem i = 0; i < n_; i++) { + for (GraphElem j = i + 1; j < n_; j++) { + GraphWeight dx = X[i] - X_up[j]; + GraphWeight dy = Y[i] - Y_up[j]; + GraphWeight ed = sqrt(dx*dx + dy*dy); + + if (ed <= rn_) { + const GraphElem g_i = g->local_to_global(i); + const GraphElem g_j = j + up_*n_; + + if (!unitEdgeWeight) { + sendup_edges.emplace_back(j, g_i, ed); + edgeList.emplace_back(i, g_j, ed); + } + else { + sendup_edges.emplace_back(j, g_i); + edgeList.emplace_back(i, g_j); + } +#if defined(CHECK_NUM_EDGES) + numEdges++; +#endif + g->edge_indices_[i+1]++; + } + } + } + + // send up sizes + send_sizes[0] = sendup_edges.size(); + } + + if (down_ != MPI_PROC_NULL) { + + for (GraphElem i = 0; i < n_; i++) { + for (GraphElem j = i + 1; j < n_; j++) { + GraphWeight dx = X[i] - X_down[j]; + GraphWeight dy = Y[i] - Y_down[j]; + GraphWeight ed = sqrt(dx*dx + dy*dy); + + if (ed <= rn_) { + const GraphElem g_i = g->local_to_global(i); + const GraphElem g_j = j + down_*n_; + + if (!unitEdgeWeight) { + senddn_edges.emplace_back(j, g_i, ed); + edgeList.emplace_back(i, g_j, ed); + } + else { + senddn_edges.emplace_back(j, g_i); + edgeList.emplace_back(i, g_j); + } +#if defined(CHECK_NUM_EDGES) + numEdges++; +#endif + g->edge_indices_[i+1]++; + } + } + } + + // send down sizes + send_sizes[1] = senddn_edges.size(); + } + } + + MPI_Barrier(comm_); + + // communicate ghost vertices with neighbors + // send/recv buffer sizes + + MPI_Sendrecv(&send_sizes[0], 1, MPI_GRAPH_TYPE, up_, SR_SIZES_UP_TAG, + &recv_sizes[1], 1, MPI_GRAPH_TYPE, down_, SR_SIZES_UP_TAG, + comm_, MPI_STATUS_IGNORE); + MPI_Sendrecv(&send_sizes[1], 1, MPI_GRAPH_TYPE, down_, SR_SIZES_DOWN_TAG, + &recv_sizes[0], 1, MPI_GRAPH_TYPE, up_, SR_SIZES_DOWN_TAG, + comm_, MPI_STATUS_IGNORE); + + // resize recv buffers + + if (recv_sizes[0] > 0) + recvup_edges.resize(recv_sizes[0]); + if (recv_sizes[1] > 0) + recvdn_edges.resize(recv_sizes[1]); + + // send/recv both up and down + + MPI_Sendrecv(sendup_edges.data(), send_sizes[0]*sizeof(struct EdgeTuple), MPI_BYTE, + up_, SR_UP_TAG, recvdn_edges.data(), recv_sizes[1]*sizeof(struct EdgeTuple), + MPI_BYTE, down_, SR_UP_TAG, comm_, MPI_STATUS_IGNORE); + MPI_Sendrecv(senddn_edges.data(), send_sizes[1]*sizeof(struct EdgeTuple), MPI_BYTE, + down_, SR_DOWN_TAG, recvup_edges.data(), recv_sizes[0]*sizeof(struct EdgeTuple), + MPI_BYTE, up_, SR_DOWN_TAG, comm_, MPI_STATUS_IGNORE); + + // update local #edges + + // down + if (down_ != MPI_PROC_NULL) { + for (GraphElem i = 0; i < recv_sizes[1]; i++) { +#if defined(CHECK_NUM_EDGES) + numEdges++; +#endif + if (!unitEdgeWeight) + edgeList.emplace_back(recvdn_edges[i].ij_[0], recvdn_edges[i].ij_[1], recvdn_edges[i].w_); + else + edgeList.emplace_back(recvdn_edges[i].ij_[0], recvdn_edges[i].ij_[1]); + g->edge_indices_[recvdn_edges[i].ij_[0]+1]++; + } + } + + // up + if (up_ != MPI_PROC_NULL) { + for (GraphElem i = 0; i < recv_sizes[0]; i++) { +#if defined(CHECK_NUM_EDGES) + numEdges++; +#endif + if (!unitEdgeWeight) + edgeList.emplace_back(recvup_edges[i].ij_[0], recvup_edges[i].ij_[1], recvup_edges[i].w_); + else + edgeList.emplace_back(recvup_edges[i].ij_[0], recvup_edges[i].ij_[1]); + g->edge_indices_[recvup_edges[i].ij_[0]+1]++; + } + } + + // add random edges based on + // randomEdgePercent + if (randomEdgePercent > 0) { + const GraphElem pnedges = (edgeList.size()/2); + GraphElem tot_pnedges = 0; + + MPI_Allreduce(&pnedges, &tot_pnedges, 1, MPI_GRAPH_TYPE, MPI_SUM, comm_); + + // extra #edges per process + const GraphElem nrande = (((GraphElem)randomEdgePercent * tot_pnedges)/100); + GraphElem pnrande; + + // TODO FIXME try to ensure a fair edge distibution + if (nrande < nprocs_) { + if (rank_ == (nprocs_ - 1)) + pnrande += nrande; + } + else { + pnrande = nrande / nprocs_; + const GraphElem pnrem = nrande % nprocs_; + if (pnrem != 0) { + if (rank_ == (nprocs_ - 1)) + pnrande += pnrem; + } + } + + // add pnrande edges + + // send/recv buffers + std::vector> rand_edges(nprocs_); + std::vector sendrand_edges, recvrand_edges; + + // outgoing/incoming send/recv sizes + std::vector sendrand_sizes(nprocs_), recvrand_sizes(nprocs_); + +#if defined(PRINT_EXTRA_NEDGES) + int extraEdges = 0; +#endif + +#if defined(DEBUG_PRINTF) + for (int i = 0; i < nprocs_; i++) { + if (i == rank_) { + std::cout << "[" << i << "]Target process for random edge insertion between " + << lo << " and " << hi << std::endl; + } + MPI_Barrier(comm_); + } +#endif + // make sure each process has a + // different seed this time since + // we want random edges + unsigned rande_seed = (unsigned)(time(0)^getpid()); + GraphWeight weight = 1.0; + std::hash reh; + + // cannot use genRandom if it's already been seeded + std::default_random_engine re(rande_seed); + std::uniform_int_distribution<> IR, JR; + std::uniform_real_distribution<> IJW; + + for (GraphElem k = 0; k < pnrande; k++) { + + // randomly pick start/end vertex and target from my list + const GraphElem i = (GraphElem)IR(re, std::uniform_int_distribution<>::param_type{0, (int)(n_- 1)}); + const GraphElem g_j = (GraphElem)JR(re, std::uniform_int_distribution<>::param_type{0, (int)(nv_- 1)}); + const int target = g->get_owner(g_j); + const GraphElem j = g->global_to_local(g_j, target); // local + + if (i == j) + continue; + + const GraphElem g_i = g->local_to_global(i); + + // check for duplicates prior to edgeList insertion + auto found = std::find_if(edgeList.begin(), edgeList.end(), + [&](EdgeTuple const& et) + { return ((et.ij_[0] == i) && (et.ij_[1] == g_j)); }); + + // OK to insert, not in list + if (found == std::end(edgeList)) { + + // calculate weight + if (!unitEdgeWeight) { + if (target == rank_) { + GraphWeight dx = X[i] - X[j]; + GraphWeight dy = Y[i] - Y[j]; + weight = sqrt(dx*dx + dy*dy); + } + else if (target == up_) { + GraphWeight dx = X[i] - X_up[j]; + GraphWeight dy = Y[i] - Y_up[j]; + weight = sqrt(dx*dx + dy*dy); + } + else if (target == down_) { + GraphWeight dx = X[i] - X_down[j]; + GraphWeight dy = Y[i] - Y_down[j]; + weight = sqrt(dx*dx + dy*dy); + } + else { + unsigned randw_seed = reh((GraphElem)(g_i*nv_+g_j)); + std::default_random_engine rew(randw_seed); + weight = (GraphWeight)IJW(rew, std::uniform_real_distribution<>::param_type{0.0, 1.0}); + } + } + + rand_edges[target].emplace_back(j, g_i, weight); + sendrand_sizes[target]++; + +#if defined(PRINT_EXTRA_NEDGES) + extraEdges++; +#endif +#if defined(CHECK_NUM_EDGES) + numEdges++; +#endif + edgeList.emplace_back(i, g_j, weight); + g->edge_indices_[i+1]++; + } + } + +#if defined(PRINT_EXTRA_NEDGES) + int totExtraEdges = 0; + MPI_Reduce(&extraEdges, &totExtraEdges, 1, MPI_INT, MPI_SUM, 0, comm_); + if (rank_ == 0) + std::cout << "Adding extra " << totExtraEdges << " edges while trying to incorporate " + << randomEdgePercent << "%" << " extra edges globally." << std::endl; +#endif + + MPI_Barrier(comm_); + + // communicate ghosts edges + MPI_Request rande_sreq; + + MPI_Ialltoall(sendrand_sizes.data(), 1, MPI_INT, + recvrand_sizes.data(), 1, MPI_INT, comm_, + &rande_sreq); + + // send data if outgoing size > 0 + for (int p = 0; p < nprocs_; p++) { + sendrand_edges.insert(sendrand_edges.end(), + rand_edges[p].begin(), rand_edges[p].end()); + } + + MPI_Wait(&rande_sreq, MPI_STATUS_IGNORE); + + // total recvbuffer size + const int rcount = std::accumulate(recvrand_sizes.begin(), recvrand_sizes.end(), 0); + recvrand_edges.resize(rcount); + + // alltoallv for incoming data + // TODO FIXME make sure size of extra edges is + // within INT limits + + int rpos = 0, spos = 0; + std::vector sdispls(nprocs_), rdispls(nprocs_); + + for (int p = 0; p < nprocs_; p++) { + + sendrand_sizes[p] *= sizeof(struct EdgeTuple); + recvrand_sizes[p] *= sizeof(struct EdgeTuple); + + sdispls[p] = spos; + rdispls[p] = rpos; + + spos += sendrand_sizes[p]; + rpos += recvrand_sizes[p]; + } + + MPI_Alltoallv(sendrand_edges.data(), sendrand_sizes.data(), sdispls.data(), + MPI_BYTE, recvrand_edges.data(), recvrand_sizes.data(), rdispls.data(), + MPI_BYTE, comm_); + + // update local edge list + for (int i = 0; i < rcount; i++) { +#if defined(CHECK_NUM_EDGES) + numEdges++; +#endif + edgeList.emplace_back(recvrand_edges[i].ij_[0], recvrand_edges[i].ij_[1], recvrand_edges[i].w_); + g->edge_indices_[recvrand_edges[i].ij_[0]+1]++; + } + + sendrand_edges.clear(); + recvrand_edges.clear(); + rand_edges.clear(); + } // end of (conditional) random edges addition + + MPI_Barrier(comm_); + + // set graph edge indices + + std::vector ecTmp(n_+1); + std::partial_sum(g->edge_indices_.begin(), g->edge_indices_.end(), ecTmp.begin()); + g->edge_indices_ = ecTmp; + + for(GraphElem i = 1; i < n_+1; i++) + g->edge_indices_[i] -= g->edge_indices_[0]; + g->edge_indices_[0] = 0; + + g->set_edge_index(0, 0); + for (GraphElem i = 0; i < n_; i++) + g->set_edge_index(i+1, g->edge_indices_[i+1]); + + const GraphElem nedges = g->edge_indices_[n_] - g->edge_indices_[0]; + g->set_nedges(nedges); + + // set graph edge list + // sort edge list + auto ecmp = [] (EdgeTuple const& e0, EdgeTuple const& e1) + { return ((e0.ij_[0] < e1.ij_[0]) || ((e0.ij_[0] == e1.ij_[0]) && (e0.ij_[1] < e1.ij_[1]))); }; + + if (!std::is_sorted(edgeList.begin(), edgeList.end(), ecmp)) { +#if defined(DEBUG_PRINTF) + std::cout << "Edge list is not sorted." << std::endl; +#endif + std::sort(edgeList.begin(), edgeList.end(), ecmp); + } +#if defined(DEBUG_PRINTF) + else + std::cout << "Edge list is sorted!" << std::endl; +#endif + + GraphElem ePos = 0; + for (GraphElem i = 0; i < n_; i++) { + GraphElem e0, e1; + + g->edge_range(i, e0, e1); +#if defined(DEBUG_PRINTF) + if ((i % 100000) == 0) + std::cout << "Processing edges for vertex: " << i << ", range(" << e0 << ", " << e1 << + ")" << std::endl; +#endif + for (GraphElem j = e0; j < e1; j++) { + Edge &edge = g->set_edge(j); + + assert(ePos == j); + assert(i == edgeList[ePos].ij_[0]); + + edge.tail_ = edgeList[ePos].ij_[1]; + edge.weight_ = edgeList[ePos].w_; + + ePos++; + } + } + +#if defined(CHECK_NUM_EDGES) + GraphElem tot_numEdges = 0; + MPI_Allreduce(&numEdges, &tot_numEdges, 1, MPI_GRAPH_TYPE, MPI_SUM, comm_); + const GraphElem tne = g->get_ne(); + assert(tne == tot_numEdges); +#endif + edgeList.clear(); + + X.clear(); + Y.clear(); + X_up.clear(); + Y_up.clear(); + X_down.clear(); + Y_down.clear(); + + sendup_edges.clear(); + senddn_edges.clear(); + recvup_edges.clear(); + recvdn_edges.clear(); + + return g; + } + + GraphWeight get_d() const { return rn_; } + GraphElem get_nv() const { return nv_; } + + private: + GraphElem nv_, n_; + GraphWeight rn_; + MPI_Comm comm_; + int nprocs_, rank_, up_, down_; +}; + +#endif diff --git a/miniVite/log b/miniVite/log new file mode 100644 index 0000000..19ee514 --- /dev/null +++ b/miniVite/log @@ -0,0 +1,518 @@ +My libomptarget --> Set mode to SDEV +==168619== NVPROF is profiling process 168619, command: ./miniVite -n 50000000 +Average time to generate 100000000 random numbers using LCG (in s): 0.182072 +********************************************************************** +Generated Random Geometric Graph with d: 0.000269794 +Number of vertices: 50000000 +Number of edges: 899999910 +Time to generate distributed graph of 50000000 vertices (in s): 88.1166 +Size: 16 : 8 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002004c0000000, size=400000008 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002004d7e00000, size=16 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002004e0000000, size=14399998560 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200840000000, size=400000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200860000000, size=400000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200880000000, size=400000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002008a0000000, size=800000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002008e0000000, size=800000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200920000000, size=400000000 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 50000000 device: 0 UM: 0) at 1 +My libomptarget --> Map 0x0000200920000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200920000000 +My libomptarget --> Apply opt 1 to 0x0000200920000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002008e0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008e0000000 +My libomptarget --> Apply opt 1 to 0x00002008e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002008e0000000 from soft device (0x00002008e0000000), size=800000000 +My libomptarget --> Unmap 0x0000200920000000 from soft device (0x0000200920000000), size=400000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 50000000 device: 0 UM: 0) at 2 +My libomptarget --> Map 0x00002004c0000000 to soft device, size=400000008 +My libomptarget --> Apply opt 4 to 0x00002004c0000000 +My libomptarget --> Apply opt 1 to 0x00002004c0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002004d7e00000 to soft device, size=16 +My libomptarget --> Apply opt 4 to 0x00002004d7e00000 +My libomptarget --> Apply opt 1 to 0x00002004d7e00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002004e0000000 to soft device, size=14399998560 +My libomptarget --> Apply opt 4 to 0x00002004e0000000 +My libomptarget --> Apply opt 1 to 0x00002004e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200840000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200840000000 +My libomptarget --> Apply opt 1 to 0x0000200840000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200880000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200880000000 +My libomptarget --> Apply opt 1 to 0x0000200880000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200860000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200860000000 +My libomptarget --> Apply opt 1 to 0x0000200860000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002008a0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008a0000000 +My libomptarget --> Apply opt 1 to 0x00002008a0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002008e0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008e0000000 +My libomptarget --> Apply opt 1 to 0x00002008e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200920000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200920000000 +My libomptarget --> Apply opt 1 to 0x0000200920000000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x0000200920000000 from soft device (0x0000200920000000), size=400000000 +My libomptarget --> Unmap 0x00002008e0000000 from soft device (0x00002008e0000000), size=800000000 +My libomptarget --> Unmap 0x00002008a0000000 from soft device (0x00002008a0000000), size=800000000 +My libomptarget --> Unmap 0x0000200860000000 from soft device (0x0000200860000000), size=400000000 +My libomptarget --> Unmap 0x0000200880000000 from soft device (0x0000200880000000), size=400000000 +My libomptarget --> Unmap 0x0000200840000000 from soft device (0x0000200840000000), size=400000000 +My libomptarget --> Unmap 0x00002004e0000000 from soft device (0x00002004e0000000), size=14399998560 +My libomptarget --> Unmap 0x00002004d7e00000 from soft device (0x00002004d7e00000), size=16 +My libomptarget --> Unmap 0x00002004c0000000 from soft device (0x00002004c0000000), size=400000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 50000000 device: 0 UM: 0) at 3 +My libomptarget --> Map 0x00002008a0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008a0000000 +My libomptarget --> Apply opt 1 to 0x00002008a0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002008e0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008e0000000 +My libomptarget --> Apply opt 1 to 0x00002008e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002008e0000000 from soft device (0x00002008e0000000), size=800000000 +My libomptarget --> Unmap 0x00002008a0000000 from soft device (0x00002008a0000000), size=800000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 50000000 device: 0 UM: 0) at 4 +My libomptarget --> Map 0x00007ffff20be9a8 to device (0x0000200997600000), size=8 +My libomptarget --> Submit 0x00007ffff20be9a8 to 0x0000200997600000, size=8 +My libomptarget --> Map 0x0000200920000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200920000000 +My libomptarget --> Apply opt 1 to 0x0000200920000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00007ffff20be9a0 to device (0x0000200997600200), size=8 +My libomptarget --> Submit 0x00007ffff20be9a0 to 0x0000200997600200, size=8 +My libomptarget --> Map 0x00002008a0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008a0000000 +My libomptarget --> Apply opt 1 to 0x00002008a0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002008a0000000 from soft device (0x00002008a0000000), size=800000000 +My libomptarget --> Retrieve 0x00007ffff20be9a0 from 0x0000200997600200, size=8 +My libomptarget --> Unmap 0x00007ffff20be9a0 from device (0x0000200997600200), size=8 +My libomptarget --> Unmap 0x0000200920000000 from soft device (0x0000200920000000), size=400000000 +My libomptarget --> Retrieve 0x00007ffff20be9a8 from 0x0000200997600000, size=8 +My libomptarget --> Unmap 0x00007ffff20be9a8 from device (0x0000200997600000), size=8 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 50000000 device: 0 UM: 0) at 5 +My libomptarget --> Map 0x0000200920000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200920000000 +My libomptarget --> Apply opt 1 to 0x0000200920000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002008e0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008e0000000 +My libomptarget --> Apply opt 1 to 0x00002008e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002008e0000000 from soft device (0x00002008e0000000), size=800000000 +My libomptarget --> Unmap 0x0000200920000000 from soft device (0x0000200920000000), size=400000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 50000000 device: 0 UM: 0) at 6 +My libomptarget --> Map 0x00002004c0000000 to soft device, size=400000008 +My libomptarget --> Apply opt 4 to 0x00002004c0000000 +My libomptarget --> Apply opt 1 to 0x00002004c0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002004d7e00000 to soft device, size=16 +My libomptarget --> Apply opt 4 to 0x00002004d7e00000 +My libomptarget --> Apply opt 1 to 0x00002004d7e00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002004e0000000 to soft device, size=14399998560 +My libomptarget --> Apply opt 4 to 0x00002004e0000000 +My libomptarget --> Apply opt 1 to 0x00002004e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200840000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200840000000 +My libomptarget --> Apply opt 1 to 0x0000200840000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200880000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200880000000 +My libomptarget --> Apply opt 1 to 0x0000200880000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200860000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200860000000 +My libomptarget --> Apply opt 1 to 0x0000200860000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002008a0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008a0000000 +My libomptarget --> Apply opt 1 to 0x00002008a0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002008e0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008e0000000 +My libomptarget --> Apply opt 1 to 0x00002008e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200920000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200920000000 +My libomptarget --> Apply opt 1 to 0x0000200920000000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x0000200920000000 from soft device (0x0000200920000000), size=400000000 +My libomptarget --> Unmap 0x00002008e0000000 from soft device (0x00002008e0000000), size=800000000 +My libomptarget --> Unmap 0x00002008a0000000 from soft device (0x00002008a0000000), size=800000000 +My libomptarget --> Unmap 0x0000200860000000 from soft device (0x0000200860000000), size=400000000 +My libomptarget --> Unmap 0x0000200880000000 from soft device (0x0000200880000000), size=400000000 +My libomptarget --> Unmap 0x0000200840000000 from soft device (0x0000200840000000), size=400000000 +My libomptarget --> Unmap 0x00002004e0000000 from soft device (0x00002004e0000000), size=14399998560 +My libomptarget --> Unmap 0x00002004d7e00000 from soft device (0x00002004d7e00000), size=16 +My libomptarget --> Unmap 0x00002004c0000000 from soft device (0x00002004c0000000), size=400000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 50000000 device: 0 UM: 0) at 7 +My libomptarget --> Map 0x00002008a0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008a0000000 +My libomptarget --> Apply opt 1 to 0x00002008a0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002008e0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008e0000000 +My libomptarget --> Apply opt 1 to 0x00002008e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002008e0000000 from soft device (0x00002008e0000000), size=800000000 +My libomptarget --> Unmap 0x00002008a0000000 from soft device (0x00002008a0000000), size=800000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 50000000 device: 0 UM: 0) at 8 +My libomptarget --> Map 0x00007ffff20be9a8 to device (0x0000200997600000), size=8 +My libomptarget --> Submit 0x00007ffff20be9a8 to 0x0000200997600000, size=8 +My libomptarget --> Map 0x0000200920000000 to soft device, size=400000000 +My libomptarget --> Apply opt 4 to 0x0000200920000000 +My libomptarget --> Apply opt 1 to 0x0000200920000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00007ffff20be9a0 to device (0x0000200997600200), size=8 +My libomptarget --> Submit 0x00007ffff20be9a0 to 0x0000200997600200, size=8 +My libomptarget --> Map 0x00002008a0000000 to soft device, size=800000000 +My libomptarget --> Apply opt 4 to 0x00002008a0000000 +My libomptarget --> Apply opt 1 to 0x00002008a0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002008a0000000 from soft device (0x00002008a0000000), size=800000000 +My libomptarget --> Retrieve 0x00007ffff20be9a0 from 0x0000200997600200, size=8 +My libomptarget --> Unmap 0x00007ffff20be9a0 from device (0x0000200997600200), size=8 +My libomptarget --> Unmap 0x0000200920000000 from soft device (0x0000200920000000), size=400000000 +My libomptarget --> Retrieve 0x00007ffff20be9a8 from 0x0000200997600000, size=8 +My libomptarget --> Unmap 0x00007ffff20be9a8 from device (0x0000200997600000), size=8 +Total size: 16.7638 +Time: 80.839 +Modularity: -2e-08, Iterations: 2, Time (in s): 91.9998 +********************************************************************** +==168619== Profiling application: ./miniVite -n 50000000 +==168619== Profiling result: + Type Time(%) Time Calls Avg Min Max Name + GPU activities: 88.78% 70.8005s 2 35.4002s 13.8961s 56.9044s __omp_offloading_35_eeedb51__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1367 + 7.38% 5.88504s 2 2.94252s 2.90431s 2.98072s __omp_offloading_35_eeedb51__Z20distUpdateLocalCinfolP4CommPKS__l435 + 3.45% 2.75114s 2 1.37557s 1.31162s 1.43952s __omp_offloading_35_eeedb51__Z21distComputeModularityRK5GraphP4CommPKddi_l395 + 0.39% 309.96ms 2 154.98ms 2.5277ms 307.43ms __omp_offloading_35_eeedb51__Z16distCleanCWandCUlPdP4Comm_l454 + 0.00% 14.176us 8 1.7720us 1.6320us 1.8880us [CUDA memcpy DtoH] + 0.00% 7.2000us 5 1.4400us 1.2480us 1.7280us [CUDA memcpy HtoD] + API calls: 98.42% 79.7474s 8 9.96842s 2.6219ms 56.9045s cuCtxSynchronize + 0.80% 645.71ms 1 645.71ms 645.71ms 645.71ms cuCtxDestroy + 0.65% 523.16ms 1 523.16ms 523.16ms 523.16ms cuCtxCreate + 0.07% 55.862ms 4 13.965ms 26.356us 29.241ms cuMemAlloc + 0.03% 21.165ms 9 2.3517ms 69.686us 20.311ms cuMemAllocManaged + 0.02% 14.921ms 30 497.36us 3.8050us 10.727ms cuMemAdvise + 0.01% 11.501ms 1 11.501ms 11.501ms 11.501ms cuModuleLoadDataEx + 0.00% 3.5211ms 8 440.13us 33.118us 3.1674ms cuLaunchKernel + 0.00% 3.4017ms 1 3.4017ms 3.4017ms 3.4017ms cuModuleUnload + 0.00% 1.0287ms 4 257.18us 27.296us 488.97us cuMemFree + 0.00% 610.48us 8 76.310us 53.527us 105.83us cuMemcpyDtoH + 0.00% 233.54us 5 46.707us 27.817us 70.651us cuMemcpyHtoD + 0.00% 62.364us 34 1.8340us 555ns 4.7440us cuCtxSetCurrent + 0.00% 18.389us 8 2.2980us 1.7010us 2.9630us cuFuncGetAttribute + 0.00% 13.046us 21 621ns 338ns 1.0360us cuDeviceGetAttribute + 0.00% 12.614us 5 2.5220us 2.3040us 3.1820us cuModuleGetGlobal + 0.00% 11.860us 6 1.9760us 1.2010us 4.5830us cuDeviceGetPCIBusId + 0.00% 8.3770us 7 1.1960us 592ns 4.2380us cuDeviceGet + 0.00% 7.7370us 4 1.9340us 1.5450us 2.9960us cuModuleGetFunction + 0.00% 1.5730us 3 524ns 403ns 588ns cuDeviceGetCount + +==168619== Unified Memory profiling result: +Device "Tesla V100-SXM2-16GB (0)" + Count Avg Size Min Size Max Size Total Size Total Time Name + 210990 169.82KB 64.000KB 1.6250MB 34.16998GB 1.252414s Host To Device + 9314 1.9949MB 64.000KB 2.0000MB 18.14508GB 433.0975ms Device To Host + 31726 - - - - 79.700933s Gpu page fault groups + 319 1.9969MB 1.5000MB 2.0000MB 637.0000MB - Remote mapping to device +Total CPU Page faults: 51896 +Total remote mappings from CPU: 319 + +------------------------------------------------------------ +Sender: LSF System +Subject: Job 310708: in cluster Done + +Job was submitted from host by user in cluster at Wed Mar 27 16:42:25 2019 +Job was executed on host(s) <1*batch3>, in queue , as user in cluster at Wed Mar 27 16:42:35 2019 + <42*g33n07> + was used as the home directory. + was used as the working directory. +Started at Wed Mar 27 16:42:35 2019 +Terminated at Wed Mar 27 16:45:46 2019 +Results reported at Wed Mar 27 16:45:46 2019 + +The output (if any) is above this job summary. + +My libomptarget --> Set mode to SDEV +==114131== NVPROF is profiling process 114131, command: ./miniVite -n 5000000 +Average time to generate 10000000 random numbers using LCG (in s): 0.0181821 +********************************************************************** +Generated Random Geometric Graph with d: 0.000817469 +Number of vertices: 5000000 +Number of edges: 89999910 +Time to generate distributed graph of 5000000 vertices (in s): 8.43148 +Size: 16 : 8 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e0000000, size=40000008 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e2800000, size=16 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200120000000, size=1439998560 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200175e00000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200178600000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x000020017ae00000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e2a00000, size=80000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e7800000, size=80000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x000020017d600000, size=40000000 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 5000000 device: 0 UM: 0) at 1 +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 5000000 device: 0 UM: 0) at 2 +My libomptarget --> Map 0x00002000e0000000 to soft device, size=40000008 +My libomptarget --> Apply opt 4 to 0x00002000e0000000 +My libomptarget --> Apply opt 1 to 0x00002000e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e2800000 to soft device, size=16 +My libomptarget --> Apply opt 4 to 0x00002000e2800000 +My libomptarget --> Apply opt 1 to 0x00002000e2800000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200120000000 to soft device, size=1439998560 +My libomptarget --> Apply opt 4 to 0x0000200120000000 +My libomptarget --> Apply opt 1 to 0x0000200120000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200175e00000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x0000200175e00000 +My libomptarget --> Apply opt 1 to 0x0000200175e00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x000020017ae00000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017ae00000 +My libomptarget --> Apply opt 1 to 0x000020017ae00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200178600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x0000200178600000 +My libomptarget --> Apply opt 1 to 0x0000200178600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> Unmap 0x0000200178600000 from soft device (0x0000200178600000), size=40000000 +My libomptarget --> Unmap 0x000020017ae00000 from soft device (0x000020017ae00000), size=40000000 +My libomptarget --> Unmap 0x0000200175e00000 from soft device (0x0000200175e00000), size=40000000 +My libomptarget --> Unmap 0x0000200120000000 from soft device (0x0000200120000000), size=1439998560 +My libomptarget --> Unmap 0x00002000e2800000 from soft device (0x00002000e2800000), size=16 +My libomptarget --> Unmap 0x00002000e0000000 from soft device (0x00002000e0000000), size=40000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 5000000 device: 0 UM: 0) at 3 +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 5000000 device: 0 UM: 0) at 4 +My libomptarget --> Map 0x00007fffe1e06888 to device (0x00002001d7600000), size=8 +My libomptarget --> Submit 0x00007fffe1e06888 to 0x00002001d7600000, size=8 +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00007fffe1e06880 to device (0x00002001d7600200), size=8 +My libomptarget --> Submit 0x00007fffe1e06880 to 0x00002001d7600200, size=8 +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> Retrieve 0x00007fffe1e06880 from 0x00002001d7600200, size=8 +My libomptarget --> Unmap 0x00007fffe1e06880 from device (0x00002001d7600200), size=8 +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> Retrieve 0x00007fffe1e06888 from 0x00002001d7600000, size=8 +My libomptarget --> Unmap 0x00007fffe1e06888 from device (0x00002001d7600000), size=8 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 5000000 device: 0 UM: 0) at 5 +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 5000000 device: 0 UM: 0) at 6 +My libomptarget --> Map 0x00002000e0000000 to soft device, size=40000008 +My libomptarget --> Apply opt 4 to 0x00002000e0000000 +My libomptarget --> Apply opt 1 to 0x00002000e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e2800000 to soft device, size=16 +My libomptarget --> Apply opt 4 to 0x00002000e2800000 +My libomptarget --> Apply opt 1 to 0x00002000e2800000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200120000000 to soft device, size=1439998560 +My libomptarget --> Apply opt 4 to 0x0000200120000000 +My libomptarget --> Apply opt 1 to 0x0000200120000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200175e00000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x0000200175e00000 +My libomptarget --> Apply opt 1 to 0x0000200175e00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x000020017ae00000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017ae00000 +My libomptarget --> Apply opt 1 to 0x000020017ae00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200178600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x0000200178600000 +My libomptarget --> Apply opt 1 to 0x0000200178600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> Unmap 0x0000200178600000 from soft device (0x0000200178600000), size=40000000 +My libomptarget --> Unmap 0x000020017ae00000 from soft device (0x000020017ae00000), size=40000000 +My libomptarget --> Unmap 0x0000200175e00000 from soft device (0x0000200175e00000), size=40000000 +My libomptarget --> Unmap 0x0000200120000000 from soft device (0x0000200120000000), size=1439998560 +My libomptarget --> Unmap 0x00002000e2800000 from soft device (0x00002000e2800000), size=16 +My libomptarget --> Unmap 0x00002000e0000000 from soft device (0x00002000e0000000), size=40000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 5000000 device: 0 UM: 0) at 7 +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 5000000 device: 0 UM: 0) at 8 +My libomptarget --> Map 0x00007fffe1e06888 to device (0x00002001d7600000), size=8 +My libomptarget --> Submit 0x00007fffe1e06888 to 0x00002001d7600000, size=8 +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00007fffe1e06880 to device (0x00002001d7600200), size=8 +My libomptarget --> Submit 0x00007fffe1e06880 to 0x00002001d7600200, size=8 +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> Retrieve 0x00007fffe1e06880 from 0x00002001d7600200, size=8 +My libomptarget --> Unmap 0x00007fffe1e06880 from device (0x00002001d7600200), size=8 +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> Retrieve 0x00007fffe1e06888 from 0x00002001d7600000, size=8 +My libomptarget --> Unmap 0x00007fffe1e06888 from device (0x00002001d7600000), size=8 +Total size: 1.67638 +Time: 0.743411 +Modularity: 8.22212e-07, Iterations: 2, Time (in s): 2.44237 +********************************************************************** +==114131== Profiling application: ./miniVite -n 5000000 +==114131== Profiling result: + Type Time(%) Time Calls Avg Min Max Name + GPU activities: 93.44% 474.32ms 2 237.16ms 21.093ms 453.23ms __omp_offloading_35_eeedb51__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1367 + 6.30% 31.997ms 2 15.999ms 253.70us 31.743ms __omp_offloading_35_eeedb51__Z16distCleanCWandCUlPdP4Comm_l454 + 0.13% 650.77us 2 325.38us 324.62us 326.15us __omp_offloading_35_eeedb51__Z21distComputeModularityRK5GraphP4CommPKddi_l395 + 0.12% 631.82us 2 315.91us 314.70us 317.13us __omp_offloading_35_eeedb51__Z20distUpdateLocalCinfolP4CommPKS__l435 + 0.00% 14.401us 8 1.8000us 1.6320us 2.0160us [CUDA memcpy DtoH] + 0.00% 7.0080us 5 1.4010us 1.2480us 1.6000us [CUDA memcpy HtoD] + API calls: 40.00% 518.67ms 1 518.67ms 518.67ms 518.67ms cuCtxCreate + 39.20% 508.28ms 8 63.536ms 356.70us 453.31ms cuCtxSynchronize + 16.52% 214.18ms 1 214.18ms 214.18ms 214.18ms cuCtxDestroy + 1.62% 21.061ms 9 2.3401ms 80.485us 20.281ms cuMemAllocManaged + 0.89% 11.579ms 1 11.579ms 11.579ms 11.579ms cuModuleLoadDataEx + 0.56% 7.2959ms 1 7.2959ms 7.2959ms 7.2959ms cuModuleUnload + 0.51% 6.6057ms 8 825.71us 28.769us 6.3330ms cuLaunchKernel + 0.24% 3.0631ms 4 765.77us 23.171us 1.5982ms cuMemAlloc + 0.23% 3.0404ms 30 101.35us 3.7320us 2.0698ms cuMemAdvise + 0.12% 1.5644ms 4 391.11us 30.221us 753.34us cuMemFree + 0.07% 889.41us 8 111.18us 89.358us 125.11us cuMemcpyDtoH + 0.01% 193.93us 5 38.786us 26.534us 53.105us cuMemcpyHtoD + 0.00% 59.670us 34 1.7550us 676ns 4.4900us cuCtxSetCurrent + 0.00% 14.464us 8 1.8080us 1.2480us 2.4810us cuFuncGetAttribute + 0.00% 13.321us 5 2.6640us 2.1600us 3.6020us cuModuleGetGlobal + 0.00% 12.168us 6 2.0280us 1.1920us 5.1090us cuDeviceGetPCIBusId + 0.00% 11.903us 21 566ns 293ns 949ns cuDeviceGetAttribute + 0.00% 8.5710us 7 1.2240us 596ns 4.3550us cuDeviceGet + 0.00% 7.0220us 4 1.7550us 1.4670us 2.4140us cuModuleGetFunction + 0.00% 1.5720us 3 524ns 375ns 609ns cuDeviceGetCount + +==114131== Unified Memory profiling result: +Device "Tesla V100-SXM2-16GB (0)" + Count Avg Size Min Size Max Size Total Size Total Time Name + 5614 164.73KB 64.000KB 1.2500MB 903.1250MB 33.28173ms Host To Device + 692 - - - - 226.4184ms Gpu page fault groups + 40 1.9094MB 192.00KB 2.0000MB 76.37500MB - Remote mapping to device +Total CPU Page faults: 5212 +Total remote mappings from CPU: 40 + +------------------------------------------------------------ +Sender: LSF System +Subject: Job 310715: in cluster Done + +Job was submitted from host by user in cluster at Wed Mar 27 16:46:44 2019 +Job was executed on host(s) <1*batch2>, in queue , as user in cluster at Wed Mar 27 16:46:54 2019 + <42*g31n10> + was used as the home directory. + was used as the working directory. +Started at Wed Mar 27 16:46:54 2019 +Terminated at Wed Mar 27 16:47:11 2019 +Results reported at Wed Mar 27 16:47:11 2019 + +The output (if any) is above this job summary. + + + +------------------------------------------------------------ +Sender: LSF System +Subject: Job 311049: in cluster Done + +Job was submitted from host by user in cluster at Wed Mar 27 22:00:55 2019 +Job was executed on host(s) <1*batch1>, in queue , as user in cluster at Wed Mar 27 22:01:04 2019 + <42*a32n16> + was used as the home directory. + was used as the working directory. +Started at Wed Mar 27 22:01:04 2019 +Terminated at Wed Mar 27 22:01:06 2019 +Results reported at Wed Mar 27 22:01:06 2019 + +The output (if any) is above this job summary. + diff --git a/miniVite/log1 b/miniVite/log1 new file mode 100644 index 0000000..aa97cdb --- /dev/null +++ b/miniVite/log1 @@ -0,0 +1,598 @@ +My libomptarget --> Set mode to DEV +==158920== NVPROF is profiling process 158920, command: ./miniVite -n 5000000 +Average time to generate 10000000 random numbers using LCG (in s): 0.0181787 +********************************************************************** +Generated Random Geometric Graph with d: 0.000817469 +Number of vertices: 5000000 +Number of edges: 89999910 +Time to generate distributed graph of 5000000 vertices (in s): 8.47192 +Size: 16 : 8 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e0000000, size=40000008 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e2800000, size=16 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200100000000, size=1439998560 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200155e00000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200158600000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x000020015ae00000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e2a00000, size=80000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e7800000, size=80000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x000020015d600000, size=40000000 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 5000000 device: 0 UM: 0) at 1 +My libomptarget --> Map 0x000020015d600000 to device (0x00002000d9800000), size=40000000 +My libomptarget --> Map 0x00002000e7800000 to device (0x00002001a0000000), size=80000000 +My libomptarget --> Retrieve 0x00002000e7800000 from 0x00002001a0000000, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from device (0x00002001a0000000), size=80000000 +My libomptarget --> Retrieve 0x000020015d600000 from 0x00002000d9800000, size=40000000 +My libomptarget --> Unmap 0x000020015d600000 from device (0x00002000d9800000), size=40000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 5000000 device: 0 UM: 0) at 2 +My libomptarget --> Map 0x00002000e0000000 to device (0x00002000d9800000), size=40000008 +My libomptarget --> Submit 0x00002000e0000000 to 0x00002000d9800000, size=40000008 +My libomptarget --> Map 0x00002000e2800000 to device (0x000020019dc00000), size=16 +My libomptarget --> Submit 0x00002000e2800000 to 0x000020019dc00000, size=16 +My libomptarget --> Map 0x0000200100000000 to device (0x00002001a0000000), size=1439998560 +My libomptarget --> Submit 0x0000200100000000 to 0x00002001a0000000, size=1439998560 +My libomptarget --> Map 0x0000200155e00000 to device (0x00002001f5e00000), size=40000000 +My libomptarget --> Submit 0x0000200155e00000 to 0x00002001f5e00000, size=40000000 +My libomptarget --> Map 0x000020015ae00000 to device (0x00002001f8600000), size=40000000 +My libomptarget --> Map 0x0000200158600000 to device (0x00002001fae00000), size=40000000 +My libomptarget --> Submit 0x0000200158600000 to 0x00002001fae00000, size=40000000 +My libomptarget --> Map 0x00002000e2a00000 to device (0x0000200200000000), size=80000000 +My libomptarget --> Submit 0x00002000e2a00000 to 0x0000200200000000, size=80000000 +My libomptarget --> Map 0x00002000e7800000 to device (0x0000200204e00000), size=80000000 +My libomptarget --> Submit 0x00002000e7800000 to 0x0000200204e00000, size=80000000 +My libomptarget --> Map 0x000020015d600000 to device (0x0000200209c00000), size=40000000 +My libomptarget --> Submit 0x000020015d600000 to 0x0000200209c00000, size=40000000 +My libomptarget --> Retrieve 0x000020015d600000 from 0x0000200209c00000, size=40000000 +My libomptarget --> Unmap 0x000020015d600000 from device (0x0000200209c00000), size=40000000 +My libomptarget --> Retrieve 0x00002000e7800000 from 0x0000200204e00000, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from device (0x0000200204e00000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from device (0x0000200200000000), size=80000000 +My libomptarget --> Unmap 0x0000200158600000 from device (0x00002001fae00000), size=40000000 +My libomptarget --> Retrieve 0x000020015ae00000 from 0x00002001f8600000, size=40000000 +My libomptarget --> Unmap 0x000020015ae00000 from device (0x00002001f8600000), size=40000000 +My libomptarget --> Unmap 0x0000200155e00000 from device (0x00002001f5e00000), size=40000000 +My libomptarget --> Unmap 0x0000200100000000 from device (0x00002001a0000000), size=1439998560 +My libomptarget --> Unmap 0x00002000e2800000 from device (0x000020019dc00000), size=16 +My libomptarget --> Unmap 0x00002000e0000000 from device (0x00002000d9800000), size=40000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 5000000 device: 0 UM: 0) at 3 +My libomptarget --> Map 0x00002000e2a00000 to device (0x0000200237600000), size=80000000 +My libomptarget --> Submit 0x00002000e2a00000 to 0x0000200237600000, size=80000000 +My libomptarget --> Map 0x00002000e7800000 to device (0x00002000d9800000), size=80000000 +My libomptarget --> Submit 0x00002000e7800000 to 0x00002000d9800000, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from device (0x00002000d9800000), size=80000000 +My libomptarget --> Retrieve 0x00002000e2a00000 from 0x0000200237600000, size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from device (0x0000200237600000), size=80000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 5000000 device: 0 UM: 0) at 4 +My libomptarget --> Map 0x00007fffedfd3f28 to device (0x0000200237600000), size=8 +My libomptarget --> Submit 0x00007fffedfd3f28 to 0x0000200237600000, size=8 +My libomptarget --> Map 0x000020015d600000 to device (0x0000200237800000), size=40000000 +My libomptarget --> Submit 0x000020015d600000 to 0x0000200237800000, size=40000000 +My libomptarget --> Map 0x00007fffedfd3f20 to device (0x0000200237600200), size=8 +My libomptarget --> Submit 0x00007fffedfd3f20 to 0x0000200237600200, size=8 +My libomptarget --> Map 0x00002000e2a00000 to device (0x000020023a000000), size=80000000 +My libomptarget --> Submit 0x00002000e2a00000 to 0x000020023a000000, size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from device (0x000020023a000000), size=80000000 +My libomptarget --> Retrieve 0x00007fffedfd3f20 from 0x0000200237600200, size=8 +My libomptarget --> Unmap 0x00007fffedfd3f20 from device (0x0000200237600200), size=8 +My libomptarget --> Unmap 0x000020015d600000 from device (0x0000200237800000), size=40000000 +My libomptarget --> Retrieve 0x00007fffedfd3f28 from 0x0000200237600000, size=8 +My libomptarget --> Unmap 0x00007fffedfd3f28 from device (0x0000200237600000), size=8 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 5000000 device: 0 UM: 0) at 5 +My libomptarget --> Map 0x000020015d600000 to device (0x0000200237600000), size=40000000 +My libomptarget --> Map 0x00002000e7800000 to device (0x0000200239e00000), size=80000000 +My libomptarget --> Retrieve 0x00002000e7800000 from 0x0000200239e00000, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from device (0x0000200239e00000), size=80000000 +My libomptarget --> Retrieve 0x000020015d600000 from 0x0000200237600000, size=40000000 +My libomptarget --> Unmap 0x000020015d600000 from device (0x0000200237600000), size=40000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 5000000 device: 0 UM: 0) at 6 +My libomptarget --> Map 0x00002000e0000000 to device (0x0000200237600000), size=40000008 +My libomptarget --> Submit 0x00002000e0000000 to 0x0000200237600000, size=40000008 +My libomptarget --> Map 0x00002000e2800000 to device (0x0000200239e00000), size=16 +My libomptarget --> Submit 0x00002000e2800000 to 0x0000200239e00000, size=16 +My libomptarget --> Map 0x0000200100000000 to device (0x00002001a0000000), size=1439998560 +My libomptarget --> Submit 0x0000200100000000 to 0x00002001a0000000, size=1439998560 +My libomptarget --> Map 0x0000200155e00000 to device (0x00002001f5e00000), size=40000000 +My libomptarget --> Submit 0x0000200155e00000 to 0x00002001f5e00000, size=40000000 +My libomptarget --> Map 0x000020015ae00000 to device (0x00002001f8600000), size=40000000 +My libomptarget --> Map 0x0000200158600000 to device (0x00002001fae00000), size=40000000 +My libomptarget --> Submit 0x0000200158600000 to 0x00002001fae00000, size=40000000 +My libomptarget --> Map 0x00002000e2a00000 to device (0x000020023a000000), size=80000000 +My libomptarget --> Submit 0x00002000e2a00000 to 0x000020023a000000, size=80000000 +My libomptarget --> Map 0x00002000e7800000 to device (0x00002000d9800000), size=80000000 +My libomptarget --> Submit 0x00002000e7800000 to 0x00002000d9800000, size=80000000 +My libomptarget --> Map 0x000020015d600000 to device (0x00002001fd600000), size=40000000 +My libomptarget --> Submit 0x000020015d600000 to 0x00002001fd600000, size=40000000 +My libomptarget --> Retrieve 0x000020015d600000 from 0x00002001fd600000, size=40000000 +My libomptarget --> Unmap 0x000020015d600000 from device (0x00002001fd600000), size=40000000 +My libomptarget --> Retrieve 0x00002000e7800000 from 0x00002000d9800000, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from device (0x00002000d9800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from device (0x000020023a000000), size=80000000 +My libomptarget --> Unmap 0x0000200158600000 from device (0x00002001fae00000), size=40000000 +My libomptarget --> Retrieve 0x000020015ae00000 from 0x00002001f8600000, size=40000000 +My libomptarget --> Unmap 0x000020015ae00000 from device (0x00002001f8600000), size=40000000 +My libomptarget --> Unmap 0x0000200155e00000 from device (0x00002001f5e00000), size=40000000 +My libomptarget --> Unmap 0x0000200100000000 from device (0x00002001a0000000), size=1439998560 +My libomptarget --> Unmap 0x00002000e2800000 from device (0x0000200239e00000), size=16 +My libomptarget --> Unmap 0x00002000e0000000 from device (0x0000200237600000), size=40000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 5000000 device: 0 UM: 0) at 7 +My libomptarget --> Map 0x00002000e2a00000 to device (0x0000200237600000), size=80000000 +My libomptarget --> Submit 0x00002000e2a00000 to 0x0000200237600000, size=80000000 +My libomptarget --> Map 0x00002000e7800000 to device (0x00002000d9800000), size=80000000 +My libomptarget --> Submit 0x00002000e7800000 to 0x00002000d9800000, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from device (0x00002000d9800000), size=80000000 +My libomptarget --> Retrieve 0x00002000e2a00000 from 0x0000200237600000, size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from device (0x0000200237600000), size=80000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 5000000 device: 0 UM: 0) at 8 +My libomptarget --> Map 0x00007fffedfd3f28 to device (0x0000200237600000), size=8 +My libomptarget --> Submit 0x00007fffedfd3f28 to 0x0000200237600000, size=8 +My libomptarget --> Map 0x000020015d600000 to device (0x0000200237800000), size=40000000 +My libomptarget --> Submit 0x000020015d600000 to 0x0000200237800000, size=40000000 +My libomptarget --> Map 0x00007fffedfd3f20 to device (0x0000200237600200), size=8 +My libomptarget --> Submit 0x00007fffedfd3f20 to 0x0000200237600200, size=8 +My libomptarget --> Map 0x00002000e2a00000 to device (0x000020023a000000), size=80000000 +My libomptarget --> Submit 0x00002000e2a00000 to 0x000020023a000000, size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from device (0x000020023a000000), size=80000000 +My libomptarget --> Retrieve 0x00007fffedfd3f20 from 0x0000200237600200, size=8 +My libomptarget --> Unmap 0x00007fffedfd3f20 from device (0x0000200237600200), size=8 +My libomptarget --> Unmap 0x000020015d600000 from device (0x0000200237800000), size=40000000 +My libomptarget --> Retrieve 0x00007fffedfd3f28 from 0x0000200237600000, size=8 +My libomptarget --> Unmap 0x00007fffedfd3f28 from device (0x0000200237600000), size=8 +Total size: 1.67638 +Time: 0.797371 +Modularity: 8.22212e-07, Iterations: 2, Time (in s): 2.47803 +********************************************************************** +==158920== Profiling application: ./miniVite -n 5000000 +==158920== Profiling result: + Type Time(%) Time Calls Avg Min Max Name + GPU activities: 91.38% 486.10ms 36 13.503ms 2.0480us 166.74ms [CUDA memcpy DtoD] + 8.26% 43.918ms 2 21.959ms 21.908ms 22.010ms __omp_offloading_35_eeedb51__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1367 + 0.14% 750.04us 2 375.02us 374.27us 375.77us __omp_offloading_35_eeedb51__Z21distComputeModularityRK5GraphP4CommPKddi_l395 + 0.12% 639.87us 2 319.93us 318.62us 321.25us __omp_offloading_35_eeedb51__Z20distUpdateLocalCinfolP4CommPKS__l435 + 0.09% 504.73us 2 252.37us 252.00us 252.73us __omp_offloading_35_eeedb51__Z16distCleanCWandCUlPdP4Comm_l454 + 0.00% 15.552us 8 1.9440us 1.7600us 2.1760us [CUDA memcpy DtoH] + 0.00% 7.9680us 5 1.5930us 1.3760us 1.7280us [CUDA memcpy HtoD] + API calls: 35.22% 524.24ms 1 524.24ms 524.24ms 524.24ms cuCtxCreate + 29.72% 442.40ms 29 15.255ms 28.595us 167.00ms cuMemcpyHtoD + 19.82% 295.04ms 1 295.04ms 295.04ms 295.04ms cuCtxDestroy + 3.67% 54.573ms 34 1.6051ms 42.012us 8.8931ms cuMemAlloc + 3.52% 52.401ms 20 2.6201ms 90.217us 8.2123ms cuMemcpyDtoH + 3.13% 46.539ms 8 5.8174ms 335.42us 22.099ms cuCtxSynchronize + 1.98% 29.432ms 34 865.65us 34.372us 3.1892ms cuMemFree + 1.41% 21.040ms 9 2.3377ms 63.714us 20.305ms cuMemAllocManaged + 0.78% 11.613ms 1 11.613ms 11.613ms 11.613ms cuModuleLoadDataEx + 0.48% 7.2150ms 1 7.2150ms 7.2150ms 7.2150ms cuModuleUnload + 0.24% 3.5659ms 8 445.74us 30.009us 3.2446ms cuLaunchKernel + 0.01% 186.90us 130 1.4370us 533ns 5.1930us cuCtxSetCurrent + 0.00% 15.519us 8 1.9390us 1.0490us 2.8850us cuFuncGetAttribute + 0.00% 13.594us 5 2.7180us 2.2340us 3.8610us cuModuleGetGlobal + 0.00% 12.258us 21 583ns 272ns 1.0910us cuDeviceGetAttribute + 0.00% 11.703us 6 1.9500us 1.2010us 4.3370us cuDeviceGetPCIBusId + 0.00% 8.8880us 7 1.2690us 623ns 4.5410us cuDeviceGet + 0.00% 7.9890us 4 1.9970us 1.5170us 3.3080us cuModuleGetFunction + 0.00% 1.5340us 3 511ns 361ns 606ns cuDeviceGetCount + +==158920== Unified Memory profiling result: +Total CPU Page faults: 5172 + +------------------------------------------------------------ +Sender: LSF System +Subject: Job 310716: in cluster Done + +Job was submitted from host by user in cluster at Wed Mar 27 16:47:14 2019 +Job was executed on host(s) <1*batch5>, in queue , as user in cluster at Wed Mar 27 16:47:28 2019 + <42*a20n12> + was used as the home directory. + was used as the working directory. +Started at Wed Mar 27 16:47:28 2019 +Terminated at Wed Mar 27 16:47:49 2019 +Results reported at Wed Mar 27 16:47:49 2019 + +The output (if any) is above this job summary. + +My libomptarget --> Set mode to UM +==13217== NVPROF is profiling process 13217, command: ./miniVite -n 5000000 +Average time to generate 10000000 random numbers using LCG (in s): 0.0182397 +********************************************************************** +Generated Random Geometric Graph with d: 0.000817469 +Number of vertices: 5000000 +Number of edges: 89999910 +Time to generate distributed graph of 5000000 vertices (in s): 8.38551 +Size: 16 : 8 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e0000000, size=40000008 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e2800000, size=16 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200100000000, size=1439998560 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200155e00000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200158600000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x000020015ae00000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e2a00000, size=80000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e7800000, size=80000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x000020015d600000, size=40000000 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 5000000 device: 0 UM: 0) at 1 +My libomptarget --> Map 0x000020015d600000 to UM, size=40000000 +My libomptarget --> Map 0x00002000e7800000 to UM, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from UM (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x000020015d600000 from UM (0x000020015d600000), size=40000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 5000000 device: 0 UM: 0) at 2 +My libomptarget --> Map 0x00002000e0000000 to UM, size=40000008 +My libomptarget --> Map 0x00002000e2800000 to UM, size=16 +My libomptarget --> Map 0x0000200100000000 to UM, size=1439998560 +My libomptarget --> Map 0x0000200155e00000 to UM, size=40000000 +My libomptarget --> Map 0x000020015ae00000 to UM, size=40000000 +My libomptarget --> Map 0x0000200158600000 to UM, size=40000000 +My libomptarget --> Map 0x00002000e2a00000 to UM, size=80000000 +My libomptarget --> Map 0x00002000e7800000 to UM, size=80000000 +My libomptarget --> Map 0x000020015d600000 to UM, size=40000000 +My libomptarget --> Unmap 0x000020015d600000 from UM (0x000020015d600000), size=40000000 +My libomptarget --> Unmap 0x00002000e7800000 from UM (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from UM (0x00002000e2a00000), size=80000000 +My libomptarget --> Unmap 0x0000200158600000 from UM (0x0000200158600000), size=40000000 +My libomptarget --> Unmap 0x000020015ae00000 from UM (0x000020015ae00000), size=40000000 +My libomptarget --> Unmap 0x0000200155e00000 from UM (0x0000200155e00000), size=40000000 +My libomptarget --> Unmap 0x0000200100000000 from UM (0x0000200100000000), size=1439998560 +My libomptarget --> Unmap 0x00002000e2800000 from UM (0x00002000e2800000), size=16 +My libomptarget --> Unmap 0x00002000e0000000 from UM (0x00002000e0000000), size=40000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 5000000 device: 0 UM: 0) at 3 +My libomptarget --> Map 0x00002000e2a00000 to UM, size=80000000 +My libomptarget --> Map 0x00002000e7800000 to UM, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from UM (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from UM (0x00002000e2a00000), size=80000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 5000000 device: 0 UM: 0) at 4 +My libomptarget --> Map 0x00007fffda6c2478 to device (0x00002001b7600000), size=8 +My libomptarget --> Submit 0x00007fffda6c2478 to 0x00002001b7600000, size=8 +My libomptarget --> Map 0x000020015d600000 to UM, size=40000000 +My libomptarget --> Map 0x00007fffda6c2470 to device (0x00002001b7600200), size=8 +My libomptarget --> Submit 0x00007fffda6c2470 to 0x00002001b7600200, size=8 +My libomptarget --> Map 0x00002000e2a00000 to UM, size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from UM (0x00002000e2a00000), size=80000000 +My libomptarget --> Retrieve 0x00007fffda6c2470 from 0x00002001b7600200, size=8 +My libomptarget --> Unmap 0x00007fffda6c2470 from device (0x00002001b7600200), size=8 +My libomptarget --> Unmap 0x000020015d600000 from UM (0x000020015d600000), size=40000000 +My libomptarget --> Retrieve 0x00007fffda6c2478 from 0x00002001b7600000, size=8 +My libomptarget --> Unmap 0x00007fffda6c2478 from device (0x00002001b7600000), size=8 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 5000000 device: 0 UM: 0) at 5 +My libomptarget --> Map 0x000020015d600000 to UM, size=40000000 +My libomptarget --> Map 0x00002000e7800000 to UM, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from UM (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x000020015d600000 from UM (0x000020015d600000), size=40000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 5000000 device: 0 UM: 0) at 6 +My libomptarget --> Map 0x00002000e0000000 to UM, size=40000008 +My libomptarget --> Map 0x00002000e2800000 to UM, size=16 +My libomptarget --> Map 0x0000200100000000 to UM, size=1439998560 +My libomptarget --> Map 0x0000200155e00000 to UM, size=40000000 +My libomptarget --> Map 0x000020015ae00000 to UM, size=40000000 +My libomptarget --> Map 0x0000200158600000 to UM, size=40000000 +My libomptarget --> Map 0x00002000e2a00000 to UM, size=80000000 +My libomptarget --> Map 0x00002000e7800000 to UM, size=80000000 +My libomptarget --> Map 0x000020015d600000 to UM, size=40000000 +My libomptarget --> Unmap 0x000020015d600000 from UM (0x000020015d600000), size=40000000 +My libomptarget --> Unmap 0x00002000e7800000 from UM (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from UM (0x00002000e2a00000), size=80000000 +My libomptarget --> Unmap 0x0000200158600000 from UM (0x0000200158600000), size=40000000 +My libomptarget --> Unmap 0x000020015ae00000 from UM (0x000020015ae00000), size=40000000 +My libomptarget --> Unmap 0x0000200155e00000 from UM (0x0000200155e00000), size=40000000 +My libomptarget --> Unmap 0x0000200100000000 from UM (0x0000200100000000), size=1439998560 +My libomptarget --> Unmap 0x00002000e2800000 from UM (0x00002000e2800000), size=16 +My libomptarget --> Unmap 0x00002000e0000000 from UM (0x00002000e0000000), size=40000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 5000000 device: 0 UM: 0) at 7 +My libomptarget --> Map 0x00002000e2a00000 to UM, size=80000000 +My libomptarget --> Map 0x00002000e7800000 to UM, size=80000000 +My libomptarget --> Unmap 0x00002000e7800000 from UM (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from UM (0x00002000e2a00000), size=80000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 5000000 device: 0 UM: 0) at 8 +My libomptarget --> Map 0x00007fffda6c2478 to device (0x00002001b7600000), size=8 +My libomptarget --> Submit 0x00007fffda6c2478 to 0x00002001b7600000, size=8 +My libomptarget --> Map 0x000020015d600000 to UM, size=40000000 +My libomptarget --> Map 0x00007fffda6c2470 to device (0x00002001b7600200), size=8 +My libomptarget --> Submit 0x00007fffda6c2470 to 0x00002001b7600200, size=8 +My libomptarget --> Map 0x00002000e2a00000 to UM, size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from UM (0x00002000e2a00000), size=80000000 +My libomptarget --> Retrieve 0x00007fffda6c2470 from 0x00002001b7600200, size=8 +My libomptarget --> Unmap 0x00007fffda6c2470 from device (0x00002001b7600200), size=8 +My libomptarget --> Unmap 0x000020015d600000 from UM (0x000020015d600000), size=40000000 +My libomptarget --> Retrieve 0x00007fffda6c2478 from 0x00002001b7600000, size=8 +My libomptarget --> Unmap 0x00007fffda6c2478 from device (0x00002001b7600000), size=8 +Total size: 1.67638 +Time: 0.732451 +Modularity: 8.22212e-07, Iterations: 2, Time (in s): 2.4223 +********************************************************************** +==13217== Profiling application: ./miniVite -n 5000000 +==13217== Profiling result: + Type Time(%) Time Calls Avg Min Max Name + GPU activities: 93.79% 493.19ms 2 246.59ms 43.538ms 449.65ms __omp_offloading_35_eeedb51__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1367 + 5.96% 31.328ms 2 15.664ms 250.43us 31.078ms __omp_offloading_35_eeedb51__Z16distCleanCWandCUlPdP4Comm_l454 + 0.12% 646.84us 2 323.42us 322.85us 324.00us __omp_offloading_35_eeedb51__Z21distComputeModularityRK5GraphP4CommPKddi_l395 + 0.12% 640.60us 2 320.30us 317.53us 323.07us __omp_offloading_35_eeedb51__Z20distUpdateLocalCinfolP4CommPKS__l435 + 0.00% 14.336us 8 1.7920us 1.6000us 2.0160us [CUDA memcpy DtoH] + 0.00% 7.0400us 5 1.4080us 1.2480us 1.6000us [CUDA memcpy HtoD] + API calls: 38.34% 526.46ms 8 65.807ms 356.21us 449.74ms cuCtxSynchronize + 38.05% 522.45ms 1 522.45ms 522.45ms 522.45ms cuCtxCreate + 19.76% 271.31ms 1 271.31ms 271.31ms 271.31ms cuCtxDestroy + 1.54% 21.175ms 9 2.3528ms 62.599us 20.311ms cuMemAllocManaged + 0.86% 11.793ms 1 11.793ms 11.793ms 11.793ms cuModuleLoadDataEx + 0.54% 7.3927ms 1 7.3927ms 7.3927ms 7.3927ms cuModuleUnload + 0.49% 6.6668ms 8 833.35us 24.849us 6.3629ms cuLaunchKernel + 0.23% 3.1179ms 4 779.48us 20.709us 1.6574ms cuMemAlloc + 0.12% 1.6051ms 4 401.28us 34.284us 770.77us cuMemFree + 0.06% 822.10us 8 102.76us 88.720us 116.52us cuMemcpyDtoH + 0.02% 208.24us 5 41.647us 26.380us 66.923us cuMemcpyHtoD + 0.01% 69.504us 34 2.0440us 543ns 6.6380us cuCtxSetCurrent + 0.00% 17.224us 8 2.1530us 1.3830us 5.5330us cuFuncGetAttribute + 0.00% 13.122us 21 624ns 432ns 1.7660us cuDeviceGetAttribute + 0.00% 13.090us 5 2.6180us 2.0610us 3.8750us cuModuleGetGlobal + 0.00% 10.963us 6 1.8270us 1.1400us 4.0110us cuDeviceGetPCIBusId + 0.00% 8.8770us 7 1.2680us 602ns 4.2380us cuDeviceGet + 0.00% 8.5390us 4 2.1340us 1.4970us 3.8560us cuModuleGetFunction + 0.00% 1.5890us 3 529ns 416ns 599ns cuDeviceGetCount + +==13217== Unified Memory profiling result: +Device "Tesla V100-SXM2-16GB (0)" + Count Avg Size Min Size Max Size Total Size Total Time Name + 9400 166.63KB 64.000KB 1.3750MB 1.493774GB 56.01582ms Host To Device + 812 192.95KB 64.000KB 960.00KB 153.0000MB 5.260943ms Device To Host + 1694 - - - - 505.7533ms Gpu page fault groups +Total CPU Page faults: 5664 + +------------------------------------------------------------ +Sender: LSF System +Subject: Job 310719: in cluster Done + +Job was submitted from host by user in cluster at Wed Mar 27 16:50:55 2019 +Job was executed on host(s) <1*batch5>, in queue , as user in cluster at Wed Mar 27 16:51:02 2019 + <42*a29n08> + was used as the home directory. + was used as the working directory. +Started at Wed Mar 27 16:51:02 2019 +Terminated at Wed Mar 27 16:51:20 2019 +Results reported at Wed Mar 27 16:51:20 2019 + +The output (if any) is above this job summary. + +My libomptarget --> Set mode to SDEV +==15656== NVPROF is profiling process 15656, command: ./miniVite -n 5000000 +Average time to generate 10000000 random numbers using LCG (in s): 0.0181794 +********************************************************************** +Generated Random Geometric Graph with d: 0.000817469 +Number of vertices: 5000000 +Number of edges: 89999910 +Time to generate distributed graph of 5000000 vertices (in s): 8.4145 +Size: 16 : 8 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e0000000, size=40000008 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e2800000, size=16 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200120000000, size=1439998560 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200175e00000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x0000200178600000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x000020017ae00000, size=40000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e2a00000, size=80000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x00002000e7800000, size=80000000 +My libomptarget --> omp_target_alloc returns uvm ptr 0x000020017d600000, size=40000000 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 5000000 device: 0 UM: 0) at 1 +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 5000000 device: 0 UM: 0) at 2 +My libomptarget --> Map 0x00002000e0000000 to soft device, size=40000008 +My libomptarget --> Apply opt 4 to 0x00002000e0000000 +My libomptarget --> Apply opt 1 to 0x00002000e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e2800000 to soft device, size=16 +My libomptarget --> Apply opt 4 to 0x00002000e2800000 +My libomptarget --> Apply opt 1 to 0x00002000e2800000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200120000000 to soft device, size=1439998560 +My libomptarget --> Apply opt 4 to 0x0000200120000000 +My libomptarget --> Apply opt 1 to 0x0000200120000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200175e00000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x0000200175e00000 +My libomptarget --> Apply opt 1 to 0x0000200175e00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x000020017ae00000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017ae00000 +My libomptarget --> Apply opt 1 to 0x000020017ae00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200178600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x0000200178600000 +My libomptarget --> Apply opt 1 to 0x0000200178600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> Unmap 0x0000200178600000 from soft device (0x0000200178600000), size=40000000 +My libomptarget --> Unmap 0x000020017ae00000 from soft device (0x000020017ae00000), size=40000000 +My libomptarget --> Unmap 0x0000200175e00000 from soft device (0x0000200175e00000), size=40000000 +My libomptarget --> Unmap 0x0000200120000000 from soft device (0x0000200120000000), size=1439998560 +My libomptarget --> Unmap 0x00002000e2800000 from soft device (0x00002000e2800000), size=16 +My libomptarget --> Unmap 0x00002000e0000000 from soft device (0x00002000e0000000), size=40000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 5000000 device: 0 UM: 0) at 3 +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 5000000 device: 0 UM: 0) at 4 +My libomptarget --> Map 0x00007fffca5000d8 to device (0x00002001d7600000), size=8 +My libomptarget --> Submit 0x00007fffca5000d8 to 0x00002001d7600000, size=8 +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00007fffca5000d0 to device (0x00002001d7600200), size=8 +My libomptarget --> Submit 0x00007fffca5000d0 to 0x00002001d7600200, size=8 +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> Retrieve 0x00007fffca5000d0 from 0x00002001d7600200, size=8 +My libomptarget --> Unmap 0x00007fffca5000d0 from device (0x00002001d7600200), size=8 +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> Retrieve 0x00007fffca5000d8 from 0x00002001d7600000, size=8 +My libomptarget --> Unmap 0x00007fffca5000d8 from device (0x00002001d7600000), size=8 +My libomptarget --> COMPUTE (0x00000000100166f8) (#iter: 5000000 device: 0 UM: 0) at 5 +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> COMPUTE (0x0000000010016724) (#iter: 5000000 device: 0 UM: 0) at 6 +My libomptarget --> Map 0x00002000e0000000 to soft device, size=40000008 +My libomptarget --> Apply opt 4 to 0x00002000e0000000 +My libomptarget --> Apply opt 1 to 0x00002000e0000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e2800000 to soft device, size=16 +My libomptarget --> Apply opt 4 to 0x00002000e2800000 +My libomptarget --> Apply opt 1 to 0x00002000e2800000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200120000000 to soft device, size=1439998560 +My libomptarget --> Apply opt 4 to 0x0000200120000000 +My libomptarget --> Apply opt 1 to 0x0000200120000000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200175e00000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x0000200175e00000 +My libomptarget --> Apply opt 1 to 0x0000200175e00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x000020017ae00000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017ae00000 +My libomptarget --> Apply opt 1 to 0x000020017ae00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x0000200178600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x0000200178600000 +My libomptarget --> Apply opt 1 to 0x0000200178600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> Unmap 0x0000200178600000 from soft device (0x0000200178600000), size=40000000 +My libomptarget --> Unmap 0x000020017ae00000 from soft device (0x000020017ae00000), size=40000000 +My libomptarget --> Unmap 0x0000200175e00000 from soft device (0x0000200175e00000), size=40000000 +My libomptarget --> Unmap 0x0000200120000000 from soft device (0x0000200120000000), size=1439998560 +My libomptarget --> Unmap 0x00002000e2800000 from soft device (0x00002000e2800000), size=16 +My libomptarget --> Unmap 0x00002000e0000000 from soft device (0x00002000e0000000), size=40000008 +My libomptarget --> COMPUTE (0x00000000100166d9) (#iter: 5000000 device: 0 UM: 0) at 7 +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00002000e7800000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e7800000 +My libomptarget --> Apply opt 1 to 0x00002000e7800000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e7800000 from soft device (0x00002000e7800000), size=80000000 +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> COMPUTE (0x00000000100166d8) (#iter: 5000000 device: 0 UM: 0) at 8 +My libomptarget --> Map 0x00007fffca5000d8 to device (0x00002001d7600000), size=8 +My libomptarget --> Submit 0x00007fffca5000d8 to 0x00002001d7600000, size=8 +My libomptarget --> Map 0x000020017d600000 to soft device, size=40000000 +My libomptarget --> Apply opt 4 to 0x000020017d600000 +My libomptarget --> Apply opt 1 to 0x000020017d600000 +My libomptarget --> Invalid optimization +My libomptarget --> Map 0x00007fffca5000d0 to device (0x00002001d7600200), size=8 +My libomptarget --> Submit 0x00007fffca5000d0 to 0x00002001d7600200, size=8 +My libomptarget --> Map 0x00002000e2a00000 to soft device, size=80000000 +My libomptarget --> Apply opt 4 to 0x00002000e2a00000 +My libomptarget --> Apply opt 1 to 0x00002000e2a00000 +My libomptarget --> Invalid optimization +My libomptarget --> Unmap 0x00002000e2a00000 from soft device (0x00002000e2a00000), size=80000000 +My libomptarget --> Retrieve 0x00007fffca5000d0 from 0x00002001d7600200, size=8 +My libomptarget --> Unmap 0x00007fffca5000d0 from device (0x00002001d7600200), size=8 +My libomptarget --> Unmap 0x000020017d600000 from soft device (0x000020017d600000), size=40000000 +My libomptarget --> Retrieve 0x00007fffca5000d8 from 0x00002001d7600000, size=8 +My libomptarget --> Unmap 0x00007fffca5000d8 from device (0x00002001d7600000), size=8 +Total size: 1.67638 +Time: 0.712737 +Modularity: 8.22212e-07, Iterations: 2, Time (in s): 2.37011 +********************************************************************** +==15656== Profiling application: ./miniVite -n 5000000 +==15656== Profiling result: + Type Time(%) Time Calls Avg Min Max Name + GPU activities: 93.47% 443.05ms 2 221.53ms 20.894ms 422.16ms __omp_offloading_35_eeedb51__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1367 + 6.26% 29.668ms 2 14.834ms 252.83us 29.415ms __omp_offloading_35_eeedb51__Z16distCleanCWandCUlPdP4Comm_l454 + 0.14% 645.59us 2 322.80us 322.37us 323.23us __omp_offloading_35_eeedb51__Z21distComputeModularityRK5GraphP4CommPKddi_l395 + 0.13% 635.20us 2 317.60us 317.05us 318.14us __omp_offloading_35_eeedb51__Z20distUpdateLocalCinfolP4CommPKS__l435 + 0.00% 14.368us 8 1.7960us 1.6000us 2.0160us [CUDA memcpy DtoH] + 0.00% 7.0720us 5 1.4140us 1.2480us 1.6000us [CUDA memcpy HtoD] + API calls: 40.70% 520.60ms 1 520.60ms 520.60ms 520.60ms cuCtxCreate + 37.11% 474.66ms 8 59.333ms 348.41us 422.24ms cuCtxSynchronize + 17.93% 229.37ms 1 229.37ms 229.37ms 229.37ms cuCtxDestroy + 1.65% 21.044ms 9 2.3382ms 77.557us 20.303ms cuMemAllocManaged + 0.90% 11.558ms 1 11.558ms 11.558ms 11.558ms cuModuleLoadDataEx + 0.57% 7.2276ms 1 7.2276ms 7.2276ms 7.2276ms cuModuleUnload + 0.52% 6.5948ms 8 824.34us 24.212us 6.3617ms cuLaunchKernel + 0.22% 2.7807ms 30 92.689us 3.1470us 1.9706ms cuMemAdvise + 0.20% 2.5650ms 4 641.26us 20.647us 1.3774ms cuMemAlloc + 0.12% 1.5353ms 4 383.83us 30.558us 741.42us cuMemFree + 0.06% 830.25us 8 103.78us 88.896us 125.59us cuMemcpyDtoH + 0.01% 168.38us 5 33.675us 26.187us 48.213us cuMemcpyHtoD + 0.00% 53.465us 34 1.5720us 641ns 4.6320us cuCtxSetCurrent + 0.00% 13.006us 5 2.6010us 2.0720us 3.2640us cuModuleGetGlobal + 0.00% 12.896us 21 614ns 365ns 1.1060us cuDeviceGetAttribute + 0.00% 12.454us 8 1.5560us 890ns 2.4160us cuFuncGetAttribute + 0.00% 11.742us 6 1.9570us 1.1400us 4.6640us cuDeviceGetPCIBusId + 0.00% 8.6470us 7 1.2350us 597ns 4.3750us cuDeviceGet + 0.00% 7.5310us 4 1.8820us 1.4760us 2.8370us cuModuleGetFunction + 0.00% 1.5450us 3 515ns 329ns 621ns cuDeviceGetCount + +==15656== Unified Memory profiling result: +Device "Tesla V100-SXM2-16GB (0)" + Count Avg Size Min Size Max Size Total Size Total Time Name + 9041 158.13KB 64.000KB 1.3125MB 1.363464GB 51.94749ms Host To Device + 1481 - - - - 448.4253ms Gpu page fault groups + 40 1.9094MB 192.00KB 2.0000MB 76.37500MB - Remote mapping to device +Total CPU Page faults: 5212 +Total remote mappings from CPU: 40 + +------------------------------------------------------------ +Sender: LSF System +Subject: Job 310728: in cluster Done + +Job was submitted from host by user in cluster at Wed Mar 27 17:01:23 2019 +Job was executed on host(s) <1*batch5>, in queue , as user in cluster at Wed Mar 27 17:01:36 2019 + <42*h36n13> + was used as the home directory. + was used as the working directory. +Started at Wed Mar 27 17:01:36 2019 +Terminated at Wed Mar 27 17:01:53 2019 +Results reported at Wed Mar 27 17:01:53 2019 + +The output (if any) is above this job summary. + diff --git a/miniVite/logcmpl b/miniVite/logcmpl new file mode 100644 index 0000000..aa4afc3 --- /dev/null +++ b/miniVite/logcmpl @@ -0,0 +1,5666 @@ +mpicxx -std=c++11 -g -O3 -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda -DOMP_GPU -DOMP_GPU_ALLOC -DCHECK_NUM_EDGES -Xclang -load -Xclang ~/git/unifiedmem/code/llvm-pass/build/uvm/libOMPPass.so -c -o main.o main.cpp +In file included from main.cpp:58: +In file included from ./dspl_gpu_kernel.hpp:58: +In file included from ./graph.hpp:56: +./utils.hpp:263:56: warning: using floating point absolute value function 'fabs' when argument is of integer type [-Wabsolute-value] + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult); // 0-1 + ^ +./utils.hpp:263:56: note: use function 'std::abs' instead + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult); // 0-1 + ^~~~ + std::abs + ---- Function Argument Access Frequency CG Analysis ---- +On function _Z7is_pwr2i +Round 0 +Round end +On function _Z8reseederj +Round 0 +Round end +On function _ZNSt8seed_seq8generateIN9__gnu_cxx17__normal_iteratorIPjSt6vectorIjSaIjEEEEEEvT_S8_ +Round 0 + alias entry %18 = getelementptr inbounds %"class.std::seed_seq", %"class.std::seed_seq"* %0, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !10369 + alias entry %19 = bitcast i32** %18 to i64*, !dbg !10369 + alias entry %21 = bitcast %"class.std::seed_seq"* %0 to i64*, !dbg !10376 +Round 1 +Round end + load (6.274510e-01) from %"class.std::seed_seq"* %0 + load (6.274510e-01) from %"class.std::seed_seq"* %0 + Frequency of %"class.std::seed_seq"* %0 + load: 1.254902e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z4lockv +Round 0 +Round end +On function _Z6unlockv +Round 0 +Round end +On function _Z19distSumVertexDegreeRK5GraphRSt6vectorIdSaIdEERS2_I4CommSaIS6_EE +Round 0 + alias entry %6 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10459 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __clang_call_terminate +Round 0 +Round end + Frequency of i8* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined. +Round 0 + alias entry %25 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 0, i32 0, i32 0, i32 0 + alias entry %26 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 1, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (6.350000e+00) from %class.Graph* %3 + load (6.350000e+00) from %class.Graph* %3 + load (6.350000e+00) from %"class.std::vector.10"* %4 + load (6.350000e+00) from %"class.std::vector.15"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %class.Graph* %3 + load: 1.270000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %4 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %5 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z29distCalcConstantForSecondTermRKSt6vectorIdSaIdEEP19ompi_communicator_t +Round 0 + alias entry %9 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10283 + alias entry %10 = bitcast double** %9 to i64*, !dbg !10283 + alias entry %12 = bitcast %"class.std::vector.10"* %0 to i64*, !dbg !10288 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.10"* %0 + load (1.000000e+00) from %"class.std::vector.10"* %0 + Frequency of %"class.std::vector.10"* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.ompi_communicator_t* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..2 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %102 = bitcast double* %3 to i64*, !dbg !10325 +Round 1 +Round end + load (3.157895e-01) from %"class.std::vector.10"* %4 + load (2.105263e-01) from double* %3 + store (2.105263e-01) to double* %3 + load (2.105263e-01) from double* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z12distInitCommRSt6vectorIlSaIlEES2_l +Round 0 + alias entry %6 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10273 + alias entry %7 = bitcast i64** %6 to i64*, !dbg !10273 + alias entry %9 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10280 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.0"* %1 + load (1.000000e+00) from %"class.std::vector.0"* %1 + Frequency of %"class.std::vector.0"* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..4 +Round 0 + alias entry %29 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %31 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from %"class.std::vector.0"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %5 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z15distInitLouvainRK5GraphRSt6vectorIlSaIlEES5_RS2_IdSaIdEES8_RS2_I4CommSaIS9_EESC_Rdi +Round 0 + alias entry %16 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !10485 + alias entry %20 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10502 + alias entry %22 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10514 + alias entry %24 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %3, i64 0, i32 0, i32 0, i32 1, !dbg !10532 + alias entry %25 = bitcast double** %24 to i64*, !dbg !10532 + alias entry %27 = bitcast %"class.std::vector.10"* %3 to i64*, !dbg !10536 + alias entry %40 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10572 + alias entry %41 = bitcast i64** %40 to i64*, !dbg !10572 + alias entry %43 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10574 + alias entry %56 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %2, i64 0, i32 0, i32 0, i32 1, !dbg !10600 + alias entry %57 = bitcast i64** %56 to i64*, !dbg !10600 + alias entry %59 = bitcast %"class.std::vector.0"* %2 to i64*, !dbg !10601 + alias entry %72 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 1, !dbg !10622 + alias entry %73 = bitcast double** %72 to i64*, !dbg !10622 + alias entry %75 = bitcast %"class.std::vector.10"* %4 to i64*, !dbg !10623 + alias entry %88 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %5, i64 0, i32 0, i32 0, i32 1, !dbg !10654 + alias entry %89 = bitcast %struct.Comm** %88 to i64*, !dbg !10654 + alias entry %91 = bitcast %"class.std::vector.15"* %5 to i64*, !dbg !10658 + alias entry %104 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %6, i64 0, i32 0, i32 0, i32 1, !dbg !10685 + alias entry %105 = bitcast %struct.Comm** %104 to i64*, !dbg !10685 + alias entry %107 = bitcast %"class.std::vector.15"* %6 to i64*, !dbg !10686 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %"class.std::vector.10"* %3 + load (1.000000e+00) from %"class.std::vector.10"* %3 +Warning: wrong traversal order, or recursive call +On function _Z15distGetMaxIndexP7clmap_tRiPdS1_dPK4Commdldllld +Round 0 + alias entry %22 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 %21 + alias entry %28 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 0, !dbg !10320 + alias entry %33 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 1, !dbg !10330 + alias entry %35 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 0, !dbg !10333 + alias entry %37 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 1, !dbg !10335 + alias entry %41 = getelementptr inbounds double, double* %2, i64 %38, !dbg !10340 + alias entry %60 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 1, !dbg !10352 + alias entry %81 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %80, i32 1, !dbg !10330 + alias entry %83 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %80, i32 0, !dbg !10333 + alias entry %89 = getelementptr inbounds double, double* %2, i64 %86, !dbg !10340 + alias entry %126 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %125, i32 1, !dbg !10330 + alias entry %128 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %125, i32 0, !dbg !10333 + alias entry %134 = getelementptr inbounds double, double* %2, i64 %131, !dbg !10340 +Round 1 +Round end + load (1.000000e+00) from double* %2 + load (1.000000e+00) from i32* %3 + load (1.000000e+00) from i32* %1 + load (5.000000e-01) from %struct.clmap_t* %0 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.clmap_t* %0 + load (1.250000e-01) from double* %2 + load (9.984375e+00) from %struct.Comm* %5 + load (9.984375e+00) from %struct.Comm* %5 + load (4.984375e+00) from double* %2 + load (9.984375e+00) from %struct.Comm* %5 + load (9.984375e+00) from %struct.Comm* %5 + load (4.984375e+00) from double* %2 + Frequency of %struct.clmap_t* %0 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 1.109375e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 4.043750e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z24distBuildLocalMapCounterllP7clmap_tRiPdS1_PK4EdgePKllll +Round 0 + alias entry %21 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %20, i32 0, !dbg !10308 + alias entry %22 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %20, i32 1, !dbg !10310 + alias entry %31 = getelementptr inbounds i64, i64* %7, i64 %30, !dbg !10326 + alias entry %39 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %37, i32 0, !dbg !10337 + alias entry %48 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %35, !dbg !10348 + alias entry %58 = getelementptr inbounds double, double* %4, i64 %52, !dbg !10358 + alias entry %64 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %35, i32 0, !dbg !10364 + alias entry %65 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %35, i32 1, !dbg !10367 + alias entry %71 = bitcast double* %22 to i64*, !dbg !10375 + alias entry %74 = getelementptr inbounds double, double* %4, i64 %73, !dbg !10377 + alias entry %75 = bitcast double* %74 to i64*, !dbg !10378 +Round 1 +Round end + load (1.593750e+01) from %struct.Edge* %6 + load (7.937500e+00) from %struct.Edge* %6 + load (1.593750e+01) from i64* %7 + load (1.593750e+01) from i32* %3 + load (1.625000e+02) from %struct.clmap_t* %2 + load (9.937500e+00) from i32* %5 + load (4.937500e+00) from %struct.Edge* %6 + load (4.937500e+00) from double* %4 + store (4.937500e+00) to double* %4 + store (5.437500e+00) to %struct.clmap_t* %2 + store (5.437500e+00) to %struct.clmap_t* %2 + store (5.437500e+00) to i32* %3 + load (1.093750e+01) from i32* %5 + load (5.437500e+00) from %struct.Edge* %6 + store (5.437500e+00) to double* %4 + store (5.437500e+00) to i32* %5 + Frequency of %struct.clmap_t* %2 + load: 1.625000e+02 store: 1.087500e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.593750e+01 store: 5.437500e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 4.937500e+00 store: 1.037500e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %5 + load: 2.087500e+01 store: 5.437500e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %6 + load: 3.425000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 1.593750e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z27distExecuteLouvainIterationlPKlS0_PK4EdgeS0_PlPKdP4CommS8_dPdi +Round 0 + alias entry %18 = getelementptr inbounds i64, i64* %2, i64 %17, !dbg !10316 + alias entry %20 = getelementptr inbounds i64, i64* %4, i64 %0, !dbg !10322 + alias entry %23 = getelementptr inbounds i64, i64* %1, i64 %0, !dbg !10329 + alias entry %26 = getelementptr inbounds i64, i64* %1, i64 %25, !dbg !10332 + alias entry %30 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %22, i32 0, !dbg !10337 + alias entry %32 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %22, i32 1, !dbg !10341 + alias entry %47 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %46, i32 0, !dbg !10401 + alias entry %48 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %46, i32 1, !dbg !10403 + alias entry %57 = getelementptr inbounds i64, i64* %4, i64 %56, !dbg !10414 + alias entry %95 = bitcast double* %48 to i64*, !dbg !10457 + alias entry %118 = getelementptr inbounds double, double* %10, i64 %0, !dbg !10470 + alias entry %122 = getelementptr inbounds double, double* %6, i64 %0, !dbg !10473 + alias entry %140 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %139, i32 1, !dbg !10533 + alias entry %142 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %139, i32 0, !dbg !10534 + alias entry %188 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %187, i32 1, !dbg !10533 + alias entry %190 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %187, i32 0, !dbg !10534 + alias entry %236 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %235, i32 1, !dbg !10572 + alias entry %237 = bitcast double* %236 to i64*, !dbg !10573 + alias entry %248 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %235, i32 0, !dbg !10575 + alias entry %250 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %22, i32 1, !dbg !10578 + alias entry %252 = bitcast double* %250 to i64*, !dbg !10581 + alias entry %263 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %22, i32 0, !dbg !10583 + alias entry %267 = getelementptr inbounds i64, i64* %5, i64 %0, !dbg !10587 + alias entry %270 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %269, i32 1, !dbg !10533 + alias entry %272 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %269, i32 0, !dbg !10534 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (1.000000e+00) from i64* %4 + load (1.000000e+00) from i64* %1 + load (1.000000e+00) from i64* %1 + load (5.000000e-01) from %struct.Comm* %7 + load (5.000000e-01) from %struct.Comm* %7 + load (7.992188e+00) from %struct.Edge* %3 + load (3.992188e+00) from %struct.Edge* %3 + load (7.992188e+00) from i64* %4 + load (2.492188e+00) from %struct.Edge* %3 + load (2.742188e+00) from %struct.Edge* %3 + load (5.000000e-01) from double* %10 + store (5.000000e-01) to double* %10 + load (5.000000e-01) from double* %6 + load (1.250000e-01) from %struct.Comm* %7 + load (1.250000e-01) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + load (2.500000e-01) from %struct.Comm* %8 + load (2.500000e-01) from double* %6 + load (2.500000e-01) from %struct.Comm* %8 + store (1.000000e+00) to i64* %5 + load (4.992188e+00) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + Frequency of i64* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %3 + load: 1.721875e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 8.992188e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 0.000000e+00 store: 1.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %7 + load: 2.121875e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 5.000000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 5.000000e-01 store: 5.000000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z21distComputeModularityRK5GraphP4CommPKddi +Round 0 + alias entry %14 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10288 + alias entry %16 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10304 + base alias entry %35 = bitcast i8** %34 to double**, !dbg !10317 + base alias entry %37 = bitcast i8** %36 to double**, !dbg !10317 + base alias entry %45 = bitcast i8** %44 to %struct.Comm**, !dbg !10317 + base alias entry %47 = bitcast i8** %46 to %struct.Comm**, !dbg !10317 +Round 1 + base alias entry %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias entry %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias entry %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias entry %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Round 2 + base alias offset entry (2) %11 = alloca [5 x i8*], align 8 + base alias offset entry (2) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (-1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 + base alias offset entry (4) %11 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias offset entry (4) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Round 3 + base alias offset entry (4) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (4) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (3) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (3) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (2) %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias offset entry (2) %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias offset entry (1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 +Round 4 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.7 +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to double**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..8 +Round 0 + alias entry %40 = getelementptr inbounds double, double* %6, i64 %39, !dbg !10318 + alias entry %43 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %39, i32 1, !dbg !10321 + alias entry %63 = bitcast double* %5 to i64*, !dbg !10329 + alias entry %75 = bitcast double* %7 to i64*, !dbg !10329 +Round 1 +Round end + load (1.010526e+01) from double* %6 + load (1.010526e+01) from %struct.Comm* %8 + load (2.105263e-01) from double* %5 + store (2.105263e-01) to double* %5 + load (2.105263e-01) from double* %7 + store (2.105263e-01) to double* %7 + load (2.105263e-01) from double* %5 + load (2.105263e-01) from double* %7 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 1.010526e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %7 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 1.010526e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.9 +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to double**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..10 +Round 0 + alias entry %67 = bitcast double* %3 to i64*, !dbg !10310 + alias entry %79 = bitcast double* %5 to i64*, !dbg !10310 +Round 1 +Round end + load (2.916667e-01) from double* %3 + store (2.916667e-01) to double* %3 + load (2.916667e-01) from double* %5 + store (2.916667e-01) to double* %5 + load (3.333333e-01) from double* %3 + load (3.333333e-01) from double* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 6.250000e-01 store: 2.916667e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 6.250000e-01 store: 2.916667e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z20distUpdateLocalCinfolP4CommPKS_ +Round 0 + base alias entry %15 = bitcast i8** %14 to %struct.Comm**, !dbg !10269 + base alias entry %17 = bitcast i8** %16 to %struct.Comm**, !dbg !10269 + base alias entry %20 = bitcast i8** %19 to %struct.Comm**, !dbg !10269 + base alias entry %22 = bitcast i8** %21 to %struct.Comm**, !dbg !10269 +Round 1 + base alias entry %14 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias entry %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 + base alias entry %19 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias entry %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 2 + base alias offset entry (1) %5 = alloca [3 x i8*], align 8 + base alias offset entry (1) %6 = alloca [3 x i8*], align 8 + base alias offset entry (2) %5 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %19 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias offset entry (2) %6 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 3 + base alias offset entry (1) %9 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %9 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %14 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias offset entry (1) %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 +Round 4 +Round end + Frequency of %struct.Comm* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..13 +Round 0 + alias entry %33 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %26, !dbg !10304 + alias entry %36 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %35, i32 1, !dbg !10304 + alias entry %37 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %26, !dbg !10304 + alias entry %38 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %35, i32 1, !dbg !10304 + alias entry %39 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %26, i32 1, !dbg !10304 + alias entry %41 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %40, !dbg !10304 + alias entry %42 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %26, i32 1, !dbg !10304 + alias entry %43 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %40, !dbg !10304 + alias entry %44 = bitcast double* %38 to %struct.Comm*, !dbg !10304 + alias entry %46 = bitcast double* %36 to %struct.Comm*, !dbg !10304 + alias entry %49 = bitcast %struct.Comm* %43 to double*, !dbg !10304 + alias entry %51 = bitcast %struct.Comm* %41 to double*, !dbg !10304 + alias entry %67 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %61, i32 0, !dbg !10304 + alias entry %68 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %62, i32 0, !dbg !10304 + alias entry %69 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %63, i32 0, !dbg !10304 + alias entry %70 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %64, i32 0, !dbg !10304 + alias entry %71 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %65, i32 0, !dbg !10304 + alias entry %72 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %66, i32 0, !dbg !10304 + alias entry %73 = bitcast i64* %67 to <4 x i64>*, !dbg !10304 + alias entry %74 = bitcast i64* %68 to <4 x i64>*, !dbg !10304 + alias entry %75 = bitcast i64* %69 to <4 x i64>*, !dbg !10304 + alias entry %76 = bitcast i64* %70 to <4 x i64>*, !dbg !10304 + alias entry %77 = bitcast i64* %71 to <4 x i64>*, !dbg !10304 + alias entry %78 = bitcast i64* %72 to <4 x i64>*, !dbg !10304 + alias entry %97 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %61, i32 0, !dbg !10307 + alias entry %98 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %62, i32 0, !dbg !10307 + alias entry %99 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %63, i32 0, !dbg !10307 + alias entry %100 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %64, i32 0, !dbg !10307 + alias entry %101 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %65, i32 0, !dbg !10307 + alias entry %102 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %66, i32 0, !dbg !10307 + alias entry %103 = bitcast i64* %97 to <4 x i64>*, !dbg !10307 + alias entry %104 = bitcast i64* %98 to <4 x i64>*, !dbg !10307 + alias entry %105 = bitcast i64* %99 to <4 x i64>*, !dbg !10307 + alias entry %106 = bitcast i64* %100 to <4 x i64>*, !dbg !10307 + alias entry %107 = bitcast i64* %101 to <4 x i64>*, !dbg !10307 + alias entry %108 = bitcast i64* %102 to <4 x i64>*, !dbg !10307 + alias entry %139 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %61, i32 1, !dbg !10309 + alias entry %140 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %62, i32 1, !dbg !10309 + alias entry %141 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %63, i32 1, !dbg !10309 + alias entry %142 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %64, i32 1, !dbg !10309 + alias entry %143 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %65, i32 1, !dbg !10309 + alias entry %144 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %66, i32 1, !dbg !10309 + alias entry %151 = getelementptr inbounds double, double* %139, i64 -1, !dbg !10309 + alias entry %152 = bitcast double* %151 to <4 x double>*, !dbg !10309 + alias entry %153 = getelementptr inbounds double, double* %140, i64 -1, !dbg !10309 + alias entry %154 = bitcast double* %153 to <4 x double>*, !dbg !10309 + alias entry %155 = getelementptr inbounds double, double* %141, i64 -1, !dbg !10309 + alias entry %156 = bitcast double* %155 to <4 x double>*, !dbg !10309 + alias entry %157 = getelementptr inbounds double, double* %142, i64 -1, !dbg !10309 + alias entry %158 = bitcast double* %157 to <4 x double>*, !dbg !10309 + alias entry %159 = getelementptr inbounds double, double* %143, i64 -1, !dbg !10309 + alias entry %160 = bitcast double* %159 to <4 x double>*, !dbg !10309 + alias entry %161 = getelementptr inbounds double, double* %144, i64 -1, !dbg !10309 + alias entry %162 = bitcast double* %161 to <4 x double>*, !dbg !10309 + alias entry %183 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %182, i32 0, !dbg !10304 + alias entry %185 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %182, i32 0, !dbg !10307 + alias entry %188 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %182, i32 1, !dbg !10318 + alias entry %190 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %182, i32 1, !dbg !10309 +Round 1 +Round end + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + load (9.088235e+00) from %struct.Comm* %6 + load (9.088235e+00) from %struct.Comm* %5 + store (9.088235e+00) to %struct.Comm* %5 + load (9.088235e+00) from %struct.Comm* %6 + load (9.088235e+00) from %struct.Comm* %5 + store (9.088235e+00) to %struct.Comm* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 3.317647e+01 store: 3.317647e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 3.317647e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..14 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z16distCleanCWandCUlPdP4Comm +Round 0 + base alias entry %17 = bitcast i8** %16 to double**, !dbg !10269 + base alias entry %19 = bitcast i8** %18 to double**, !dbg !10269 + base alias entry %22 = bitcast i8** %21 to %struct.Comm**, !dbg !10269 + base alias entry %24 = bitcast i8** %23 to %struct.Comm**, !dbg !10269 +Round 1 + base alias entry %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias entry %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 + base alias entry %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias entry %23 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 2 + base alias offset entry (1) %5 = alloca [3 x i8*], align 8 + base alias offset entry (1) %6 = alloca [3 x i8*], align 8 + base alias offset entry (2) %5 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias offset entry (2) %6 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %23 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 3 + base alias offset entry (1) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %13 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %13 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias offset entry (1) %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 +Round 4 +Round end + Frequency of double* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..18 +Round 0 + alias entry %30 = getelementptr inbounds double, double* %5, i64 %29, !dbg !10304 + alias entry %31 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %29, i32 0, !dbg !10309 + alias entry %34 = bitcast i64* %31 to i8*, !dbg !10299 +Round 1 +Round end + store (1.058333e+01) to double* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 0.000000e+00 store: 1.058333e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..19 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z21fillRemoteCommunitiesRK5GraphiiRKmS3_RKSt6vectorIlSaIlEES8_S8_S8_S8_RKS4_I4CommSaIS9_EERSt3mapIlS9_St4lessIlESaISt4pairIKlS9_EEERSt13unordered_mapIllSt4hashIlESt8equal_toIlESaISH_ISI_lEEESM_ +Round 0 + alias entry %126 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !11433 + alias entry %130 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !11449 + alias entry %132 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !11460 + alias entry %190 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 + alias entry %197 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 + alias entry %301 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 2, i32 0, !dbg !11792 + alias entry %302 = bitcast %"struct.std::__detail::_Hash_node_base"* %301 to %"struct.std::__detail::_Hash_node"**, !dbg !11793 + alias entry %312 = bitcast %"class.std::unordered_map"* %12 to i8**, !dbg !11836 + alias entry %314 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 1, !dbg !11842 + alias entry %317 = bitcast %"struct.std::__detail::_Hash_node_base"* %301 to i8*, !dbg !11846 + alias entry %320 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %8, i64 0, i32 0, i32 0, i32 0 + alias entry %321 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0 + alias entry %322 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 0 + alias entry %323 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %324 = bitcast %"class.std::vector.0"* %323 to i64* + alias entry %325 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %326 = bitcast i64** %325 to i64* + alias entry %330 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %9, i64 0, i32 0, i32 0, i32 0 + alias entry %331 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %332 = bitcast %"class.std::vector.0"* %331 to i64* + alias entry %333 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %334 = bitcast i64** %333 to i64* + alias entry %818 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, !dbg !13393 + alias entry %819 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 1, !dbg !13405 + alias entry %820 = bitcast %"struct.std::_Rb_tree_node_base"** %819 to %"struct.std::_Rb_tree_node"**, !dbg !13405 + alias entry %826 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, !dbg !13419 + alias entry %827 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13425 + base alias entry %827 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13425 + alias entry %828 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13435 + base alias entry %828 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13435 + alias entry %829 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 2, !dbg !13437 + alias entry %830 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, !dbg !13442 + alias entry %831 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 1, !dbg !13447 + alias entry %832 = bitcast %"struct.std::_Rb_tree_node_base"** %831 to %"struct.std::_Rb_tree_node"**, !dbg !13447 + alias entry %838 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, !dbg !13452 + alias entry %839 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13455 + base alias entry %839 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13455 + alias entry %840 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13462 + base alias entry %840 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13462 + alias entry %841 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 2, !dbg !13464 + alias entry %846 = bitcast %"struct.std::_Rb_tree_node_base"** %819 to i64* + alias entry %848 = bitcast %"struct.std::_Rb_tree_node_base"* %826 to %"struct.std::_Rb_tree_node"* + alias entry %850 = bitcast %"struct.std::_Rb_tree_node_base"** %831 to i64* + alias entry %852 = bitcast %"struct.std::_Rb_tree_node_base"* %838 to %"struct.std::_Rb_tree_node"* + alias entry %967 = load %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"** %827, align 8, !dbg !14017, !tbaa !14018 + alias entry %1023 = load %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"** %839, align 8, !dbg !14306, !tbaa !14018 +Round 1 +Round end + load (1.000000e+00) from i64* %4 + load (9.999994e-01) from i64* %3 + load (9.999963e-01) from %class.Graph* %0 + load (9.999963e-01) from %class.Graph* %0 + load (9.999963e-01) from %class.Graph* %0 + load (9.999803e+00) from %"class.std::vector.0"* %6 + load (1.999960e+01) from %"class.std::vector.0"* %6 + load (6.249782e+00) from %"class.std::vector.0"* %5 + load (1.249956e+01) from %"class.std::vector.0"* %5 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (1.999809e+01) from %"class.std::vector.0"* %8 + load (1.999807e+01) from %"class.std::unordered_map"* %12 + load (1.999807e+01) from %"class.std::unordered_map"* %12 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..22 +Round 0 + alias entry %31 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %33 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from %"class.std::vector.0"* %4 + load (3.200000e-01) from %"class.std::vector.0"* %6 + load (1.020000e+01) from i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 1.020000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %6 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.24 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..25 +Round 0 + alias entry %33 = getelementptr inbounds %"class.std::vector.29", %"class.std::vector.29"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.29"* %4 + load (3.157895e-01) from %"class.std::vector.0"* %3 + load (2.105263e-01) from i64* %5 + store (2.105263e-01) to i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.29"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.27 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..28 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..30 +Round 0 + alias entry %20 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %2, i64 0, i32 0, i32 0, i32 0, !dbg !10503 + alias entry %34 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %7, i64 0, i32 0, i32 0, i32 0 + alias entry %36 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.0"* %2 + load (2.047500e+02) from %"class.std::vector.0"* %4 + load (2.047500e+02) from %"class.std::vector.15"* %7 + load (2.047500e+02) from %"class.std::vector.52"* %6 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.52"* %6 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %7 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z22createCommunityMPITypev +Round 0 +Round end +On function _Z23destroyCommunityMPITypev +Round 0 +Round end +On function _Z23updateRemoteCommunitiesRK5GraphRSt6vectorI4CommSaIS3_EERKSt3mapIlS3_St4lessIlESaISt4pairIKlS3_EEEii +Round 0 + alias entry %19 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !10869 + alias entry %46 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !11050 + alias entry %48 = getelementptr inbounds %"class.std::map", %"class.std::map"* %2, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !11068 + alias entry %49 = bitcast %"struct.std::_Rb_tree_node_base"** %48 to i64*, !dbg !11068 + alias entry %51 = getelementptr inbounds %"class.std::map", %"class.std::map"* %2, i64 0, i32 0, i32 0, i32 1, !dbg !11085 + alias entry %55 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %56 = bitcast %"class.std::vector.0"* %55 to i64* + alias entry %57 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %58 = bitcast i64** %57 to i64* +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (9.999994e-01) from %class.Graph* %0 + load (9.999994e-01) from %"class.std::map"* %2 + load (1.999985e+01) from %class.Graph* %0 + load (1.999985e+01) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 4.199970e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::map"* %2 + load: 9.999994e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..32 +Round 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.66", %"class.std::vector.66"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %30 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.137255e-01) from %"class.std::vector.66"* %4 + load (3.137255e-01) from %"class.std::vector.0"* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.137255e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.66"* %4 + load: 3.137255e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.34 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to i64**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..35 +Round 0 + alias entry %36 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %38 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (3.157895e-01) from %"class.std::vector.0"* %6 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + load (2.105263e-01) from i64* %5 + store (2.105263e-01) to i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %6 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..37 +Round 0 + alias entry %26 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (6.350000e+00) from %"class.std::vector.52"* %3 + load (6.350000e+00) from %"class.std::vector.15"* %4 + load (6.350000e+00) from i64* %5 + load (2.047500e+02) from i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.52"* %3 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %4 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.111000e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z18exchangeVertexReqsRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ii +Round 0 + alias entry %15 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10306 + alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10319 + alias entry %51 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 1, !dbg !10485 + alias entry %52 = bitcast i64** %51 to i64*, !dbg !10485 + alias entry %54 = bitcast %"class.std::vector.0"* %4 to i64*, !dbg !10489 + alias entry %71 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 1, !dbg !10517 + alias entry %72 = bitcast i64** %71 to i64*, !dbg !10517 + alias entry %74 = bitcast %"class.std::vector.0"* %3 to i64*, !dbg !10518 + alias entry %91 = bitcast %"class.std::vector.0"* %3 to i8** + alias entry %94 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %99 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0, !dbg !10612 + alias entry %100 = bitcast %"class.std::vector.0"* %4 to i8**, !dbg !10612 + alias entry %129 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 1, !dbg !10673 + alias entry %130 = bitcast i64** %129 to i64*, !dbg !10673 + alias entry %132 = bitcast %"class.std::vector.0"* %5 to i64*, !dbg !10674 + alias entry %148 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 1, !dbg !10696 + alias entry %149 = bitcast i64** %148 to i64*, !dbg !10696 + alias entry %151 = bitcast %"class.std::vector.0"* %6 to i64*, !dbg !10697 + alias entry %191 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 + alias entry %251 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 + alias entry %310 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 2, !dbg !11244 + alias entry %311 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 2, !dbg !11245 + alias entry %312 = bitcast i64** %310 to i64*, !dbg !11249 + alias entry %314 = bitcast i64** %311 to i64*, !dbg !11250 + alias entry %320 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 2, !dbg !11279 + alias entry %321 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 2, !dbg !11280 + alias entry %322 = bitcast i64** %320 to i64*, !dbg !11284 + alias entry %324 = bitcast i64** %321 to i64*, !dbg !11285 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (9.999984e-01) from %"class.std::vector.0"* %4 + load (9.999984e-01) from %"class.std::vector.0"* %4 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..39 +Round 0 + alias entry %26 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 0, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 1, i32 0, i32 0, i32 0 + alias entry %28 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 6 + alias entry %29 = bitcast %"class.std::vector.0"* %28 to i64* + alias entry %30 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %31 = bitcast i64** %30 to i64* + alias entry %32 = getelementptr inbounds %"class.std::vector.29", %"class.std::vector.29"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.988141e+02) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (1.590478e+03) from %"class.std::vector.29"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %class.Graph* %3 + load: 9.741684e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.29"* %5 + load: 1.590478e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.41 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..42 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi +Round 0 + alias entry %68 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 2, !dbg !11180 + alias entry %85 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !11380 + alias entry %86 = bitcast i64** %85 to i64*, !dbg !11380 + alias entry %88 = bitcast %class.Graph* %2 to i64*, !dbg !11384 + alias entry %93 = bitcast %class.Graph* %2 to i8**, !dbg !11392 + alias entry %98 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 6, !dbg !11399 + alias entry %99 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 6, i32 0, i32 0, i32 1, !dbg !11402 + alias entry %100 = bitcast i64** %99 to i64*, !dbg !11402 + alias entry %102 = bitcast %"class.std::vector.0"* %98 to i64*, !dbg !11403 + alias entry %107 = bitcast %"class.std::vector.0"* %98 to i8**, !dbg !11410 + alias entry %112 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 1, !dbg !11417 + alias entry %113 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 1, i32 0, i32 0, i32 1, !dbg !11424 + alias entry %114 = bitcast %struct.Edge** %113 to i64*, !dbg !11424 + alias entry %116 = bitcast %"class.std::vector.5"* %112 to i64*, !dbg !11428 + alias entry %121 = bitcast %"class.std::vector.5"* %112 to i8**, !dbg !11440 +Round 1 +Round end + load (9.999981e-01) from %class.Graph* %2 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..45 +Round 0 +Round end + call (1.058333e+01, 2.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %5 + call (1.058333e+01, 1.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %6 + call (1.058333e+01, 1.721875e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Edge* %7 + call (1.058333e+01, 8.992188e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %8 + call (1.058333e+01, 0.000000e+00, 1.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %9 + call (1.058333e+01, 7.500000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using double* %10 + call (1.058333e+01, 2.121875e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %11 + call (1.058333e+01, 5.000000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %12 + call (1.058333e+01, 5.000000e-01, 5.000000e-01, 0.000000e+00, 0.000000e+00) using double* %14 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.116667e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %6 + load: 1.058333e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %7 + load: 1.822318e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %8 + load: 9.516732e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %9 + load: 0.000000e+00 store: 1.058333e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 7.937500e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %11 + load: 2.245651e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %12 + load: 5.291667e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %14 + load: 5.291667e+00 store: 5.291667e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..46 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %5 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %8 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %9 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %10 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %12 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..49 +Round 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from i64** %4 + load (3.200000e-01) from i64** %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64** %4 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64** %5 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function main +Round 0 + base alias entry %14 = alloca i8**, align 8 + alias entry %33 = load i8**, i8*** %14, align 8, !dbg !10342, !tbaa !10335 +Round 1 +Round end + Frequency of i8** %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN11GenerateRGGC2ElP19ompi_communicator_t +Round 0 + alias entry %4 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 0, !dbg !10266 + alias entry %5 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10276 + base alias entry %5 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10276 + alias entry %6 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 5, !dbg !10279 + alias entry %8 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10281, !tbaa !10278 + alias entry %9 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 4, !dbg !10282 + alias entry %11 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 7, !dbg !10284 + alias entry %12 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 6, !dbg !10287 + alias entry %36 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 1, !dbg !10320 + alias entry %101 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10478, !tbaa !10278 + alias entry %172 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10565, !tbaa !10278 + alias entry %184 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2, !dbg !10579 + alias entry %191 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10583, !tbaa !10278 +Round 1 +Round end + store (1.000000e+00) to %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + store (2.500000e-01) to %class.GenerateRGG* %0 + store (3.437500e-01) to %class.GenerateRGG* %0 + store (2.500000e-01) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (6.250000e-01) from %class.GenerateRGG* %0 + load (6.250000e-01) from %class.GenerateRGG* %0 + load (6.250000e-01) from %class.GenerateRGG* %0 + load (7.656250e-01) from %class.GenerateRGG* %0 + load (7.656250e-01) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + Frequency of %class.GenerateRGG* %0 + load: 8.906250e+00 store: 6.843750e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.ompi_communicator_t* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN11GenerateRGG8generateEbbi +Round 0 + alias entry %27 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 1, !dbg !10306 + alias entry %75 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 6, !dbg !10592 + alias entry %112 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 7, !dbg !10709 + alias entry %153 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 0, !dbg !10828 + alias entry %156 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 4, !dbg !10832 + alias entry %160 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 5, !dbg !10836 + alias entry %430 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10915 + alias entry %819 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !11101 + alias entry %895 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 + alias entry %1233 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 + alias entry %1536 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 +Round 1 +Round end + load (1.000000e+00) from %class.GenerateRGG* %0 + load (6.249994e-01) from %class.GenerateRGG* %0 + load (9.999990e-01) from %class.GenerateRGG* %0 + load (4.999995e-01) from %class.GenerateRGG* %0 + load (3.124994e-01) from %class.GenerateRGG* %0 + load (9.999985e-01) from %class.GenerateRGG* %0 + load (4.999993e-01) from %class.GenerateRGG* %0 + load (3.124992e-01) from %class.GenerateRGG* %0 + load (9.999971e-01) from %class.GenerateRGG* %0 + load (9.999971e-01) from %class.GenerateRGG* %0 + load (9.999962e-01) from %class.GenerateRGG* %0 + load (9.999962e-01) from %class.GenerateRGG* %0 + load (4.999966e-01) from %class.GenerateRGG* %0 + load (4.999971e-01) from %class.GenerateRGG* %0 + load (4.999971e-01) from %class.GenerateRGG* %0 + load (4.999966e-01) from %class.GenerateRGG* %0 + load (9.999923e-01) from %class.GenerateRGG* %0 + load (9.999914e-01) from %class.GenerateRGG* %0 + load (3.749968e-01) from %class.GenerateRGG* %0 + load (3.749964e-01) from %class.GenerateRGG* %0 + load (9.999890e-01) from %class.GenerateRGG* %0 + load (9.998746e-01) from %class.GenerateRGG* %0 + load (3.199362e+02) from %class.GenerateRGG* %0 + load (3.199361e+02) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998698e-01) from %class.GenerateRGG* %0 + load (4.999349e-01) from %class.GenerateRGG* %0 + load (2.499674e-01) from %class.GenerateRGG* %0 + load (7.997451e+01) from %class.GenerateRGG* %0 + load (3.998725e+01) from %class.GenerateRGG* %0 + load (3.998725e+01) from %class.GenerateRGG* %0 + load (7.997448e+01) from %class.GenerateRGG* %0 + load (4.999063e-01) from %class.GenerateRGG* %0 + load (2.499531e-01) from %class.GenerateRGG* %0 + load (7.996993e+01) from %class.GenerateRGG* %0 + load (3.998497e+01) from %class.GenerateRGG* %0 + load (3.998497e+01) from %class.GenerateRGG* %0 + load (7.996991e+01) from %class.GenerateRGG* %0 + load (9.998126e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998072e-01) from %class.GenerateRGG* %0 + load (9.998015e-01) from %class.GenerateRGG* %0 + load (6.248724e-01) from %class.GenerateRGG* %0 + load (6.248718e-01) from %class.GenerateRGG* %0 + load (1.952724e-01) from %class.GenerateRGG* %0 + load (3.905445e-01) from %class.GenerateRGG* %0 + load (3.905442e-01) from %class.GenerateRGG* %0 + load (6.248393e-01) from %class.GenerateRGG* %0 + load (1.249644e+01) from %class.GenerateRGG* %0 + load (1.249643e+01) from %class.GenerateRGG* %0 + load (1.171538e+00) from %class.GenerateRGG* %0 + load (5.857690e-01) from %class.GenerateRGG* %0 + load (2.928845e-01) from %class.GenerateRGG* %0 + load (1.464422e-01) from %class.GenerateRGG* %0 + load (6.248387e-01) from %class.GenerateRGG* %0 + load (6.248381e-01) from %class.GenerateRGG* %0 + load (1.249638e+01) from %class.GenerateRGG* %0 + load (6.248253e-01) from %class.GenerateRGG* %0 + load (3.905154e-01) from %class.GenerateRGG* %0 + load (2.440719e-01) from %class.GenerateRGG* %0 + load (6.248247e-01) from %class.GenerateRGG* %0 + load (4.881438e+00) from %class.GenerateRGG* %0 + load (9.997431e-01) from %class.GenerateRGG* %0 + load (9.997421e-01) from %class.GenerateRGG* %0 + load (9.997406e-01) from %class.GenerateRGG* %0 + load (9.997406e-01) from %class.GenerateRGG* %0 + load (6.248378e-01) from %class.GenerateRGG* %0 + load (1.999481e+01) from %class.GenerateRGG* %0 + load (9.997388e-01) from %class.GenerateRGG* %0 + load (9.997385e-01) from %class.GenerateRGG* %0 + Frequency of %class.GenerateRGG* %0 + load: 1.248245e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN14BinaryEdgeList4readEiiiSs +Round 0 + alias entry %39 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 4, !dbg !10380 + alias entry %41 = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %4, i64 0, i32 0, i32 0, !dbg !10388 + alias entry %99 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 0, !dbg !10514 + alias entry %100 = bitcast %class.BinaryEdgeList* %0 to i8*, !dbg !10515 + alias entry %104 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 1, !dbg !10518 + alias entry %105 = bitcast i64* %104 to i8*, !dbg !10519 + alias entry %118 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 2, !dbg !10532 + alias entry %183 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 3, !dbg !10605 +Round 1 +Round end + load (9.999971e-01) from %class.BinaryEdgeList* %0 + load (9.999971e-01) from %"class.std::basic_string"* %4 + load (6.249948e-01) from %class.BinaryEdgeList* %0 + load (9.999905e-01) from %class.BinaryEdgeList* %0 + store (9.999905e-01) to %class.BinaryEdgeList* %0 + load (9.999895e-01) from %class.BinaryEdgeList* %0 + load (9.999886e-01) from %class.BinaryEdgeList* %0 + load (9.999886e-01) from %class.BinaryEdgeList* %0 + load (9.999729e-01) from %class.BinaryEdgeList* %0 + store (9.999729e-01) to %class.BinaryEdgeList* %0 + load (9.999714e-01) from %class.BinaryEdgeList* %0 + load (9.999714e-01) from %class.BinaryEdgeList* %0 + load (9.999547e-01) from %class.BinaryEdgeList* %0 + load (1.999909e+01) from %class.BinaryEdgeList* %0 + Frequency of %class.BinaryEdgeList* %0 + load: 2.962391e+01 store: 1.999963e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::basic_string"* %4 + load: 9.999971e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt8_Rb_treeIlSt4pairIKl4CommESt10_Select1stIS3_ESt4lessIlESaIS3_EE8_M_eraseEPSt13_Rb_tree_nodeIS3_E +Round 0 +Round end +Warning: wrong traversal order, or recursive call +On function _ZN5GraphC2EllllP19ompi_communicator_t +Round 0 + alias entry %8 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, !dbg !10272 + alias entry %9 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 1, !dbg !10272 + alias entry %10 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10309 + alias entry %11 = bitcast %class.Graph* %0 to i8*, !dbg !10309 + alias entry %12 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 3, !dbg !10320 + alias entry %13 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 4, !dbg !10322 + alias entry %14 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 5, !dbg !10324 + alias entry %15 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, !dbg !10272 + alias entry %16 = bitcast %"class.std::vector.0"* %15 to i8*, !dbg !10332 + alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10334 + base alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10334 + alias entry %18 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 9, !dbg !10336 + alias entry %21 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %17, align 8, !dbg !10338, !tbaa !10335 + alias entry %22 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 8, !dbg !10339 + alias entry %28 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !10361 + alias entry %29 = bitcast i64** %28 to i64*, !dbg !10361 + alias entry %31 = bitcast %class.Graph* %0 to i64*, !dbg !10365 + alias entry %45 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 1, i32 0, i32 0, i32 1, !dbg !10416 + alias entry %46 = bitcast %struct.Edge** %45 to i64*, !dbg !10416 + alias entry %48 = bitcast %"class.std::vector.5"* %9 to i64*, !dbg !10420 + alias entry %64 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1, !dbg !10455 + alias entry %65 = bitcast i64** %64 to i64*, !dbg !10455 + alias entry %67 = bitcast %"class.std::vector.0"* %15 to i64*, !dbg !10456 + alias entry %76 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %15, i64 0, i32 0, i32 0, i32 0 + alias entry %111 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %15, i64 0, i32 0, i32 0, i32 0, !dbg !10511 + alias entry %117 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %9, i64 0, i32 0, i32 0, i32 0, !dbg !10547 + alias entry %123 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, i32 0, i32 0, i32 0, !dbg !10576 +Round 1 +Round end + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + load (9.999990e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 +Warning: wrong traversal order, or recursive call +On function _ZN3LCGC2EjPdlP19ompi_communicator_t +Round 0 + alias entry %6 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 3, !dbg !10268 + alias entry %7 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 4, !dbg !10277 + alias entry %8 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 6, !dbg !10279 + base alias entry %8 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 6, !dbg !10279 + alias entry %9 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, !dbg !10281 + alias entry %10 = bitcast %"class.std::vector.0"* %9 to i8*, !dbg !10300 + alias entry %11 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0, !dbg !10302 + base alias entry %11 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0, !dbg !10302 + alias entry %12 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 1, !dbg !10306 + alias entry %15 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %11, align 8, !dbg !10308, !tbaa !10305 + alias entry %16 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 2, !dbg !10309 + alias entry %20 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, i32 0, i32 0, i32 1, !dbg !10326 + alias entry %21 = bitcast i64** %20 to i64*, !dbg !10326 + alias entry %23 = bitcast %"class.std::vector.0"* %9 to i64*, !dbg !10330 + alias entry %42 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10359 + alias entry %45 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %9, i64 0, i32 0, i32 0, i32 0, !dbg !10374 + alias entry %52 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10399 + alias entry %53 = bitcast i64* %52 to i8*, !dbg !10400 + alias entry %54 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %11, align 8, !dbg !10401, !tbaa !10305 +Round 1 +Round end + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + load (9.999989e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 +Warning: wrong traversal order, or recursive call +On function _ZNSt24uniform_int_distributionIiEclISt26linear_congruential_engineImLm16807ELm0ELm2147483647EEEEiRT_RKNS0_10param_typeE +Round 0 + alias entry %5 = getelementptr inbounds %"struct.std::uniform_int_distribution::param_type", %"struct.std::uniform_int_distribution::param_type"* %2, i64 0, i32 1, !dbg !10267 + alias entry %8 = getelementptr inbounds %"struct.std::uniform_int_distribution::param_type", %"struct.std::uniform_int_distribution::param_type"* %2, i64 0, i32 0, !dbg !10279 + alias entry %19 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0 + alias entry %37 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0 + alias entry %51 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0, !dbg !10376 +Round 1 +Round end + load (1.000000e+00) from %"struct.std::uniform_int_distribution::param_type"* %2 + load (1.000000e+00) from %"struct.std::uniform_int_distribution::param_type"* %2 + load (5.000000e-01) from %"class.std::linear_congruential_engine"* %1 + store (5.000000e-01) to %"class.std::linear_congruential_engine"* %1 +Warning: wrong traversal order, or recursive call +On function _ZNSt6vectorIlSaIlEEaSERKS1_ +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10278 + alias entry %6 = bitcast i64** %5 to i64*, !dbg !10278 + alias entry %8 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10285 + alias entry %12 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10294 + alias entry %13 = bitcast i64** %12 to i64*, !dbg !10294 + alias entry %15 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10296 + alias entry %33 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10459 + alias entry %41 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10490 + alias entry %42 = bitcast i64** %41 to i64*, !dbg !10490 + alias entry %53 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 0, !dbg !10573 + alias entry %73 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10633 + alias entry %76 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10635 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %1 + load (9.765625e-02) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %0 + store (6.250000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.695312e+00 store: 1.250000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %1 + load: 1.445312e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorIlSaIlEE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPlS1_EEmRKl +Round 0 + alias entry %8 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10281 + alias entry %9 = bitcast i64** %8 to i64*, !dbg !10281 + alias entry %11 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10288 + alias entry %12 = bitcast i64** %11 to i64*, !dbg !10288 + alias entry %632 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10728 + alias entry %848 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10820 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from i64* %3 + load (9.765625e-02) from %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from i64* %3 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.382812e+00 store: 1.406250e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 6.250000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI4EdgeSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast %struct.Edge** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %87 = bitcast %"class.std::vector.5"* %0 to i64*, !dbg !10375 + alias entry %108 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %115 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10431 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.5"* %0 + load (6.250000e-01) from %"class.std::vector.5"* %0 + load (3.125000e-01) from %"class.std::vector.5"* %0 + load (1.953125e-01) from %"class.std::vector.5"* %0 + load (1.953125e-01) from %"class.std::vector.5"* %0 + load (3.125000e-01) from %"class.std::vector.5"* %0 + store (3.125000e-01) to %"class.std::vector.5"* %0 + store (3.125000e-01) to %"class.std::vector.5"* %0 + Frequency of %"class.std::vector.5"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN3LCG18parallel_prefix_opEv +Round 0 + alias entry %10 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 4, !dbg !10283 + alias entry %169 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 1, !dbg !10361 + alias entry %175 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 2, !dbg !10269 + alias entry %179 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0 + alias entry %188 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10372 + alias entry %252 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, i32 0, i32 0, i32 0, !dbg !10372 +Round 1 +Round end + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + Frequency of %class.LCG* %0 + load: 8.523529e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI9EdgeTupleSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10273 + alias entry %6 = bitcast %struct.EdgeTuple** %5 to i64*, !dbg !10273 + alias entry %8 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10280 + alias entry %65 = bitcast %"class.std::vector.84"* %0 to i64*, !dbg !10369 + alias entry %86 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %93 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10425 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + Frequency of %"class.std::vector.84"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_E_ET_SC_SC_T0_St26random_access_iterator_tag +Round 0 +Round end +On function _ZNSt6vectorI9EdgeTupleSaIS0_EE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPS0_S2_EEEEvS7_T_S8_St20forward_iterator_tag +Round 0 + alias entry %13 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10344 + alias entry %14 = bitcast %struct.EdgeTuple** %13 to i64*, !dbg !10344 + alias entry %16 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10351 + alias entry %17 = bitcast %struct.EdgeTuple** %16 to i64*, !dbg !10351 + alias entry %120 = bitcast %"class.std::vector.84"* %0 to i64*, !dbg !10799 + alias entry %141 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %146 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10851 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + Frequency of %"class.std::vector.84"* %0 + load: 2.675781e+00 store: 1.406250e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZSt16__introsort_loopIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEElZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_T0_T1_ +Round 0 +Round end +On function _ZSt22__final_insertion_sortIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_T0_ +Round 0 +Round end +On function _ZSt13__heap_selectIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_SC_T0_ +Round 0 +Round end +On function _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEElS2_ZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_T0_SD_T1_T2_ +Round 0 +Round end +On function _ZSt22__move_median_to_firstIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_SC_SC_T0_ +Round 0 +Round end +On function _ZNSt6vectorIlSaIlEE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast i64** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %20 = bitcast i64** %8 to i64*, !dbg !10380 + alias entry %21 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10381 + alias entry %42 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %65 = bitcast %"class.std::vector.0"* %0 to i8**, !dbg !10628 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorIdSaIdEE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast double** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %20 = bitcast double** %8 to i64*, !dbg !10381 + alias entry %21 = bitcast %"class.std::vector.10"* %0 to i64*, !dbg !10382 + alias entry %42 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %65 = bitcast %"class.std::vector.10"* %0 to i8**, !dbg !10630 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.10"* %0 + load (6.250000e-01) from %"class.std::vector.10"* %0 + load (3.125000e-01) from %"class.std::vector.10"* %0 + load (3.125000e-01) from %"class.std::vector.10"* %0 + load (1.953125e-01) from %"class.std::vector.10"* %0 + load (1.953125e-01) from %"class.std::vector.10"* %0 + store (3.125000e-01) to %"class.std::vector.10"* %0 + store (3.125000e-01) to %"class.std::vector.10"* %0 + Frequency of %"class.std::vector.10"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI4CommSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10460 + alias entry %6 = bitcast %struct.Comm** %5 to i64*, !dbg !10460 + alias entry %8 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10467 + alias entry %20 = bitcast %"class.std::vector.15"* %0 to i64*, !dbg !10551 + alias entry %41 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %48 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10607 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.15"* %0 + load (6.250000e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + load (1.953125e-01) from %"class.std::vector.15"* %0 + load (1.953125e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + store (3.125000e-01) to %"class.std::vector.15"* %0 + store (3.125000e-01) to %"class.std::vector.15"* %0 + Frequency of %"class.std::vector.15"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt27__uninitialized_default_n_1ILb0EE18__uninit_default_nIPSt13unordered_setIlSt4hashIlESt8equal_toIlESaIlEEmEEvT_T0_ +Round 0 +Round end + Frequency of %"class.std::unordered_set"* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt10_HashtableIlSt4pairIKllESaIS2_ENSt8__detail10_Select1stESt8equal_toIlESt4hashIlENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE21_M_insert_unique_nodeEmmPNS4_10_Hash_nodeIS2_Lb0EEE +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 4, !dbg !10268 + alias entry %6 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 4, i32 1, !dbg !10275 + alias entry %8 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 1, !dbg !10282 + alias entry %10 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 3, !dbg !10288 + alias entry %17 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 0 + alias entry %29 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 2, i32 0, !dbg !10428 + alias entry %30 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to %"struct.std::__detail::_Hash_node"**, !dbg !10429 + alias entry %32 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %29, i64 0, i32 0, !dbg !10432 + alias entry %35 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to i64* + base alias entry %44 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %28, i64 %43, !dbg !10509 + alias entry %61 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10529, !tbaa !10511 + alias entry %62 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %61, i64 0, i32 0, !dbg !10530 + alias entry %77 = bitcast %"class.std::_Hashtable"* %0 to i8**, !dbg !10550 + alias entry %83 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i8*, !dbg !10618 + alias entry %87 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 0, !dbg !10296 + alias entry %94 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, !dbg !10627 + alias entry %95 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i64*, !dbg !10628 + base alias entry %97 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %96, i64 0, i32 0, !dbg !10630 + alias entry %99 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 2, i32 0, !dbg !10639 + alias entry %100 = bitcast %"struct.std::__detail::_Hash_node_base"* %99 to i64*, !dbg !10640 + alias entry %102 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, !dbg !10641 + alias entry %103 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, i32 0, !dbg !10641 + alias entry %104 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i64*, !dbg !10642 + alias entry %105 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %99, i64 0, i32 0, !dbg !10645 + base alias entry %105 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %99, i64 0, i32 0, !dbg !10645 + base alias entry %114 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %85, i64 %113, !dbg !10676 + base alias entry %118 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %117, i64 %86, !dbg !10678 +Round 1 +Warning: the first offset is not constant + alias entry %45 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10509, !tbaa !10511 + alias entry %57 = bitcast %"struct.std::__detail::_Hash_node_base"* %45 to i64*, !dbg !10525 + base alias offset entry (0) %96 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %88, align 8, !dbg !10629, !tbaa !10511 +Warning: the first offset is not constant +Warning: the first offset is not constant +Round 2 +Warning: the first offset is not constant +Warning: the first offset is not constant +Warning: the first offset is not constant +Round end + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (5.000000e-01) from %"class.std::_Hashtable"* %0 + load (4.999995e-01) from %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + load (3.749996e+00) from %"class.std::_Hashtable"* %0 + store (3.749996e+00) to %"class.std::_Hashtable"* %0 + load (6.249994e+00) from %"class.std::_Hashtable"* %0 + store (6.249994e+00) to %"class.std::_Hashtable"* %0 + store (4.768372e-07) to %"class.std::_Hashtable"* %0 + load (4.999995e-01) from %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + store (6.249997e-01) to %"struct.std::__detail::_Hash_node"* %3 + load (3.749998e-01) from %"class.std::_Hashtable"* %0 + store (3.749998e-01) to %"struct.std::__detail::_Hash_node"* %3 + store (3.749998e-01) to %"class.std::_Hashtable"* %0 + load (3.749998e-01) from %"struct.std::__detail::_Hash_node"* %3 + load (2.343749e-01) from %"class.std::_Hashtable"* %0 + load (2.343749e-01) from %"class.std::_Hashtable"* %0 + load (9.999995e-01) from %"class.std::_Hashtable"* %0 + store (9.999995e-01) to %"class.std::_Hashtable"* %0 + Frequency of %"class.std::_Hashtable"* %0 + load: 1.634374e+01 store: 1.287499e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"struct.std::__detail::_Hash_node"* %3 + load: 3.749998e-01 store: 9.999995e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt10_HashtableIllSaIlENSt8__detail9_IdentityESt8equal_toIlESt4hashIlENS1_18_Mod_range_hashingENS1_20_Default_ranged_hashENS1_20_Prime_rehash_policyENS1_17_Hashtable_traitsILb0ELb1ELb1EEEE21_M_insert_unique_nodeEmmPNS1_10_Hash_nodeIlLb0EEE +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 4, !dbg !10268 + alias entry %6 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 4, i32 1, !dbg !10275 + alias entry %8 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 1, !dbg !10282 + alias entry %10 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 3, !dbg !10288 + alias entry %17 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 0 + alias entry %29 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 2, i32 0, !dbg !10428 + alias entry %30 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to %"struct.std::__detail::_Hash_node.61"**, !dbg !10429 + alias entry %32 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %29, i64 0, i32 0, !dbg !10432 + alias entry %35 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to i64* + base alias entry %44 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %28, i64 %43, !dbg !10469 + alias entry %61 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10489, !tbaa !10471 + alias entry %62 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %61, i64 0, i32 0, !dbg !10490 + alias entry %77 = bitcast %"class.std::_Hashtable.34"* %0 to i8**, !dbg !10510 + alias entry %83 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i8*, !dbg !10578 + alias entry %87 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 0, !dbg !10296 + alias entry %94 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, !dbg !10587 + alias entry %95 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i64*, !dbg !10588 + base alias entry %97 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %96, i64 0, i32 0, !dbg !10590 + alias entry %99 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 2, i32 0, !dbg !10599 + alias entry %100 = bitcast %"struct.std::__detail::_Hash_node_base"* %99 to i64*, !dbg !10600 + alias entry %102 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, !dbg !10601 + alias entry %103 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, i32 0, !dbg !10601 + alias entry %104 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i64*, !dbg !10602 + alias entry %105 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %99, i64 0, i32 0, !dbg !10605 + base alias entry %105 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %99, i64 0, i32 0, !dbg !10605 + base alias entry %114 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %85, i64 %113, !dbg !10630 + base alias entry %118 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %117, i64 %86, !dbg !10632 +Round 1 +Warning: the first offset is not constant + alias entry %45 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10469, !tbaa !10471 + alias entry %57 = bitcast %"struct.std::__detail::_Hash_node_base"* %45 to i64*, !dbg !10485 + base alias offset entry (0) %96 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %88, align 8, !dbg !10589, !tbaa !10471 +Warning: the first offset is not constant +Warning: the first offset is not constant +Round 2 +Warning: the first offset is not constant +Warning: the first offset is not constant +Warning: the first offset is not constant +Round end + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (5.000000e-01) from %"class.std::_Hashtable.34"* %0 + load (4.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + load (3.749996e+00) from %"class.std::_Hashtable.34"* %0 + store (3.749996e+00) to %"class.std::_Hashtable.34"* %0 + load (6.249994e+00) from %"class.std::_Hashtable.34"* %0 + store (6.249994e+00) to %"class.std::_Hashtable.34"* %0 + store (4.768372e-07) to %"class.std::_Hashtable.34"* %0 + load (4.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + store (6.249997e-01) to %"struct.std::__detail::_Hash_node.61"* %3 + load (3.749998e-01) from %"class.std::_Hashtable.34"* %0 + store (3.749998e-01) to %"struct.std::__detail::_Hash_node.61"* %3 + store (3.749998e-01) to %"class.std::_Hashtable.34"* %0 + load (3.749998e-01) from %"struct.std::__detail::_Hash_node.61"* %3 + load (2.343749e-01) from %"class.std::_Hashtable.34"* %0 + load (2.343749e-01) from %"class.std::_Hashtable.34"* %0 + load (9.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (9.999995e-01) to %"class.std::_Hashtable.34"* %0 + Frequency of %"class.std::_Hashtable.34"* %0 + load: 1.634374e+01 store: 1.287499e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"struct.std::__detail::_Hash_node.61"* %3 + load: 3.749998e-01 store: 9.999995e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI8CommInfoSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %7 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10273 + alias entry %8 = bitcast %struct.CommInfo** %7 to i64*, !dbg !10273 + alias entry %10 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10280 + alias entry %59 = bitcast %struct.CommInfo** %10 to i64*, !dbg !10394 + alias entry %60 = bitcast %"class.std::vector.52"* %0 to i64*, !dbg !10395 + alias entry %81 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %89 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10449 + alias entry %143 = bitcast %"class.std::vector.52"* %0 to i8**, !dbg !10651 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.52"* %0 + load (6.250000e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + load (1.953125e-01) from %"class.std::vector.52"* %0 + load (1.953125e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + store (3.125000e-01) to %"class.std::vector.52"* %0 + store (3.125000e-01) to %"class.std::vector.52"* %0 + Frequency of %"class.std::vector.52"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _GLOBAL__sub_I_main.cpp +Round 0 +Round end +On function .omp_offloading.descriptor_unreg +Round 0 +Round end + Frequency of i8* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_offloading.descriptor_reg.nvptx64-nvidia-cuda +Round 0 +Round end + ---- Identify Target Regions ---- + target call: %49 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396.region_id, i32 5, i8** nonnull %24, i8** nonnull %26, i64* nonnull %28, i64* getelementptr inbounds ([5 x i64], [5 x i64]* @.offload_maptypes, i64 0, i64 0), i32 0, i32 0), !dbg !10317 + target call: %24 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %9, i8** nonnull %11, i64* nonnull %13, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0), !dbg !10269 + target call: %26 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %11, i8** nonnull %13, i64* nonnull %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0), !dbg !10269 + target call: %258 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0) + to label %259 unwind label %319, !dbg !11559 + target call: %276 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368.region_id, i32 12, i8** nonnull %200, i8** nonnull %202, i64* nonnull %204, i64* getelementptr inbounds ([12 x i64], [12 x i64]* @.offload_maptypes.47, i64 0, i64 0), i32 0, i32 0), !dbg !11584 + target call: %325 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0) + to label %326 unwind label %319, !dbg !11667 + ---- Target Distance Calculation ---- +_Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi converges after 3 iterations +target 0: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 1: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 2: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 3: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 9.152967e+00) (4: 1.000095e+00) (5: 2.000190e+00) +target 4: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 8.152880e+00) (4: 9.091440e+00) (5: 1.000095e+00) +target 5: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 7.152791e+00) (4: 8.091353e+00) (5: 9.029914e+00) + ---- OMP (main.cpp, powerpc64le-unknown-linux-gnu) ---- +new entry %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 +new entry %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 +new entry %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 +new entry %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 +new entry %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 +new entry %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 +new entry %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 +new entry %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 +new entry %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 +Round 0 + base alias entry %130 = bitcast i64** %29 to i8**, !dbg !11450 + base alias entry %142 = bitcast i64** %30 to i8**, !dbg !11479 + alias entry %147 = bitcast i8* %145 to %struct.Comm*, !dbg !11487 + alias entry %158 = bitcast i8* %156 to double*, !dbg !11511 + base alias entry %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias entry %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 + base alias entry %192 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 2 + base alias entry %193 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 2 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias entry %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias entry %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias entry %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias entry %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias entry %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias entry %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias entry %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias entry %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias entry %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias entry %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias entry %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias entry %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias entry %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias entry %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 +Warning: reach to function declaration __kmpc_fork_teams + alias entry (func arg) %struct.Comm* %1 + alias entry (func arg) double* %2 +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 1 +Round 1 + base alias entry %35 = bitcast i8** %34 to double**, !dbg !10317 + base alias entry %37 = bitcast i8** %36 to double**, !dbg !10317 + base alias entry %45 = bitcast i8** %44 to %struct.Comm**, !dbg !10317 + base alias entry %47 = bitcast i8** %46 to %struct.Comm**, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %29 = alloca i64*, align 8 + base alias entry %30 = alloca i64*, align 8 + base alias offset entry (1) %16 = alloca [3 x i8*], align 8 + base alias offset entry (1) %17 = alloca [3 x i8*], align 8 + base alias offset entry (2) %16 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %192 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 2 + base alias offset entry (2) %17 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %193 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 2 + base alias offset entry (1) %31 = alloca [12 x i8*], align 8 + base alias offset entry (1) %32 = alloca [12 x i8*], align 8 + base alias offset entry (2) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (2) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-2) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (-1) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (3) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-2) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (-1) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (-3) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-2) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-1) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-3) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-2) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-1) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-4) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-3) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-2) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-4) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-3) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-2) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (6) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-5) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-4) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-3) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (6) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-5) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-4) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-3) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (7) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-6) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-5) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-4) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-1) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (7) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-6) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-5) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-4) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-1) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (8) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-7) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-6) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-5) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-2) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-1) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (8) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-7) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-6) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-5) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-2) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-1) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-8) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-7) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-6) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-3) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-2) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-1) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-8) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-7) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-6) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-3) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-2) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-1) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (10) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-9) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-8) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-7) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-4) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-3) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-2) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (10) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-9) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-8) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-7) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-4) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-3) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-2) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-10) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-9) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-8) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-5) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-4) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-3) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-1) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-10) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-9) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-8) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-5) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-4) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-3) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-1) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams + alias entry %263 = load i64*, i64** %29, align 8, !dbg !11584, !tbaa !11451 + alias entry %264 = load i64*, i64** %30, align 8, !dbg !11584, !tbaa !11451 + alias entry %274 = ptrtoint i64* %263 to i64, !dbg !11584 + alias entry %275 = ptrtoint i64* %264 to i64, !dbg !11584 + base alias entry %215 = bitcast i8** %214 to i64* + base alias entry %217 = bitcast i8** %216 to i64* + base alias entry %220 = bitcast i8** %219 to i64* + base alias entry %222 = bitcast i8** %221 to i64* +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 2 +Warning: reach to function declaration __kmpc_fork_call +Round 2 + base alias entry %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias entry %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias entry %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias entry %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (2) %11 = alloca [5 x i8*], align 8 + base alias offset entry (2) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (-1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 + base alias offset entry (4) %11 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias offset entry (4) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %126 = bitcast i64** %29 to i8*, !dbg !11447 + base alias entry %139 = bitcast i64** %30 to i8*, !dbg !11477 + base alias offset entry (1) %184 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 0 + base alias offset entry (2) %184 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 0 + base alias offset entry (1) %186 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 0 + base alias offset entry (2) %186 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 0 + base alias offset entry (1) %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias offset entry (1) %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 + base alias offset entry (1) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (2) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (3) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (6) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (7) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (8) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (10) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (1) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (2) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (3) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (6) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (7) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (8) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (10) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (1) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (2) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (5) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (6) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (7) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (9) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (1) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (2) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (5) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (6) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (7) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (9) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (1) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (4) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (5) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (6) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (8) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (1) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (4) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (5) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (6) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (8) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (4) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (5) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (7) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (3) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (4) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (5) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (7) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (2) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (3) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (4) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (6) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias entry %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (2) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (3) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (4) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (6) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias entry %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (1) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (2) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (3) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (5) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias entry %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (1) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (2) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (3) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (5) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias entry %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (1) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (2) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (4) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (1) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (2) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (4) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (1) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (3) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (1) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (3) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (2) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (2) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (1) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (1) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 3 +Warning: reach to function declaration __kmpc_fork_call +Round 3 + base alias offset entry (4) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (4) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (3) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (3) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (2) %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias offset entry (2) %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias offset entry (1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (4) %31 = alloca [12 x i8*], align 8 + base alias offset entry (4) %32 = alloca [12 x i8*], align 8 + base alias offset entry (5) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (5) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-2) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-1) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-2) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-1) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-3) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-2) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-3) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-2) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-4) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-3) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-4) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-3) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-5) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-4) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-5) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-4) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-6) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-5) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-6) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-5) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-7) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-6) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-7) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-6) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 4 +Warning: reach to function declaration __kmpc_fork_call +Round 4 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (4) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (5) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (4) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (5) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (3) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (4) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (3) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (4) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (2) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (3) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (2) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (1) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (2) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (1) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (2) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (1) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (1) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 5 +Warning: reach to function declaration __kmpc_fork_call +Round 5 +Warning: reach to function declaration __kmpc_fork_teams +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 6 +Warning: reach to function declaration __kmpc_fork_call +Round 6 +Warning: reach to function declaration __kmpc_fork_teams +Round end + ---- Access Frequency Analysis ---- + target call (1.625206e+01, 0.000000e+00, 5.076920e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625206e+01, 0.000000e+00, 1.015380e+01) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + target call (1.625204e+01, 1.015380e+01, 0.000000e+00) using %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + target call (1.625204e+01, 5.076920e+00, 0.000000e+00) using %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + target call (1.625204e+01, 8.757690e+01, 0.000000e+00) using %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + target call (1.625204e+01, 4.569230e+01, 0.000000e+00) using %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + target call (1.625204e+01, 0.000000e+00, 5.076920e+00) using %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + target call (1.625204e+01, 3.807690e+00, 0.000000e+00) using %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + target call (1.625204e+01, 1.078710e+02, 0.000000e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625204e+01, 2.538460e+00, 0.000000e+00) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + target call (1.625204e+01, 2.538460e+00, 2.538460e+00) using %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + target call (1.625202e+01, 1.015380e+01, 1.015380e+01) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625202e+01, 1.015380e+01, 0.000000e+00) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + call (1.625199e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + call (1.625199e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 +Frequency of %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.650200e+02 store: 0.000000e+00 (target) +Frequency of %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 8.251031e+01 store: 0.000000e+00 (target) +Frequency of %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.423303e+03 store: 0.000000e+00 (target) +Frequency of %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 7.425931e+02 store: 0.000000e+00 (target) +Frequency of %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 6.188273e+01 store: 0.000000e+00 (target) +Frequency of %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 8.251031e+01 (target) +Frequency of %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.918144e+03 store: 2.475302e+02 (target) +Frequency of %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 2.062750e+02 store: 1.650201e+02 (target) +Frequency of %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 4.125515e+01 store: 4.125515e+01 (target) + ---- Optimization Preparation ---- +Rank 9 for %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 6.188273e+01 store: 0.000000e+00 (target) +Rank 8 for %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 8.251031e+01 store: 0.000000e+00 (target) +Rank 7 for %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 8.251031e+01 (target) +Rank 6 for %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 4.125515e+01 store: 4.125515e+01 (target) +Rank 5 for %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.650200e+02 store: 0.000000e+00 (target) +Rank 4 for %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 2.062750e+02 store: 1.650201e+02 (target) +Rank 3 for %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 7.425931e+02 store: 0.000000e+00 (target) +Rank 2 for %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.423303e+03 store: 0.000000e+00 (target) +Rank 1 for %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.918144e+03 store: 2.475302e+02 (target) + ---- Data Mapping Optimization ---- + target call: %49 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396.region_id, i32 5, i8** nonnull %24, i8** nonnull %26, i64* nonnull %28, i64* getelementptr inbounds ([5 x i64], [5 x i64]* @.offload_maptypes, i64 0, i64 0), i32 0, i32 0), !dbg !10317 +@.offload_maptypes = private unnamed_addr constant [5 x i64] [i64 800, i64 547, i64 33, i64 547, i64 33] + arg 2 (0.000000e+00, 0.000000e+00; 4.125515e+01, 4.125515e+01) is %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x06 + local reuse is 1.600380e+02, 1.280304e+03 after adjustment; scaled local reuse is 0x500 + reuse distance is 0x01 + arg 4 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 1.600380e+02, 2.560608e+03 after adjustment; scaled local reuse is 0xa00 + reuse distance is 0x01 + map type changed: @.offload_maptypes.0 = private unnamed_addr constant [5 x i64] [i64 800, i64 547, i64 1100853829665, i64 547, i64 1102195986465] + target call: %24 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %9, i8** nonnull %11, i64* nonnull %13, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0), !dbg !10269 +@.offload_maptypes.15 = private unnamed_addr constant [3 x i64] [i64 800, i64 35, i64 33] + target call: %26 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %11, i8** nonnull %13, i64* nonnull %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0), !dbg !10269 +@.offload_maptypes.20 = private unnamed_addr constant [3 x i64] [i64 800, i64 34, i64 34] + target call: %258 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0) + to label %259 unwind label %319, !dbg !11559 +@.offload_maptypes.20 = private unnamed_addr constant [3 x i64] [i64 800, i64 34, i64 34] + arg 1 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x01 + arg 2 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 1.015380e+01, 1.624608e+02 after adjustment; scaled local reuse is 0x0a2 + reuse distance is 0x01 + map type changed: @.offload_maptypes.20.1 = private unnamed_addr constant [3 x i64] [i64 800, i64 1099553574946, i64 1099681513506] + target call: %276 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368.region_id, i32 12, i8** nonnull %200, i8** nonnull %202, i64* nonnull %204, i64* getelementptr inbounds ([12 x i64], [12 x i64]* @.offload_maptypes.47, i64 0, i64 0), i32 0, i32 0), !dbg !11584 +@.offload_maptypes.47 = private unnamed_addr constant [12 x i64] [i64 800, i64 33, i64 33, i64 33, i64 33, i64 34, i64 33, i64 33, i64 35, i64 800, i64 35, i64 800] + arg 1 (0.000000e+00, 0.000000e+00; 1.650200e+02, 0.000000e+00) is %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + size is %90 = sub i64 %87, %89, !dbg !11386 + global reuse is 0x05 + local reuse is 1.015380e+01, 8.123040e+01 after adjustment; scaled local reuse is 0x051 + reuse distance is 0x09 + arg 2 (0.000000e+00, 0.000000e+00; 8.251031e+01, 0.000000e+00) is %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + size is %104 = sub i64 %101, %103, !dbg !11404 + global reuse is 0x08 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + arg 3 (0.000000e+00, 0.000000e+00; 1.423303e+03, 0.000000e+00) is %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + size is %118 = sub i64 %115, %117, !dbg !11430 + global reuse is 0x02 + local reuse is 8.757690e+01, 1.401230e+03 after adjustment; scaled local reuse is 0x579 + reuse distance is 0x09 + arg 4 (0.000000e+00, 0.000000e+00; 7.425931e+02, 0.000000e+00) is %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x03 + local reuse is 4.569230e+01, 3.655384e+02 after adjustment; scaled local reuse is 0x16d + reuse distance is 0x09 + arg 5 (0.000000e+00, 0.000000e+00; 0.000000e+00, 8.251031e+01) is %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x07 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + arg 6 (0.000000e+00, 0.000000e+00; 6.188273e+01, 0.000000e+00) is %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x09 + local reuse is 3.807690e+00, 3.046152e+01 after adjustment; scaled local reuse is 0x01e + reuse distance is 0x09 + arg 7 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 1.078710e+02, 1.725936e+03 after adjustment; scaled local reuse is 0x6bd + reuse distance is 0x01 + arg 8 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 2.538460e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x01 + arg 10 (0.000000e+00, 0.000000e+00; 4.125515e+01, 4.125515e+01) is %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x06 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + map type changed: @.offload_maptypes.47.2 = private unnamed_addr constant [12 x i64] [i64 800, i64 9895689605153, i64 9895646625825, i64 9897073713185, i64 9895987392545, i64 9895646621730, i64 9895636144161, i64 1101320425505, i64 1099553587235, i64 800, i64 9895646617635, i64 800] + target call: %325 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0) + to label %326 unwind label %319, !dbg !11667 +@.offload_maptypes.15 = private unnamed_addr constant [3 x i64] [i64 800, i64 35, i64 33] + arg 1 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 2.030760e+01, 3.249216e+02 after adjustment; scaled local reuse is 0x144 + reuse distance is 0x07 + arg 2 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 1.015380e+01, 1.624608e+02 after adjustment; scaled local reuse is 0x0a2 + reuse distance is 0x07 + map type changed: @.offload_maptypes.15.3 = private unnamed_addr constant [3 x i64] [i64 800, i64 7696921137187, i64 7696751280161] +1 warning generated. +In file included from main.cpp:58: +In file included from ./dspl_gpu_kernel.hpp:58: +In file included from ./graph.hpp:56: +./utils.hpp:263:56: warning: using floating point absolute value function 'fabs' when argument is of integer type [-Wabsolute-value] + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult); // 0-1 + ^ +./utils.hpp:263:56: note: use function 'std::abs' instead + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult); // 0-1 + ^~~~ + std::abs +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 + ---- Function Argument Access Frequency CG Analysis ---- +On function __omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396 +Round 0 + alias entry %71 = getelementptr inbounds double, double* %2, i64 %68, !dbg !45 + alias entry %74 = getelementptr inbounds %struct.Comm, %struct.Comm* %4, i64 %68, i32 1, !dbg !52 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (1.600385e+02) from double* %2 + load (1.600385e+02) from %struct.Comm* %4 + load (6.227106e-02) from double* %1 + store (6.227106e-02) to double* %1 + load (6.227106e-02) from double* %3 + store (6.227106e-02) to double* %3 + Frequency of double* %1 + load: 6.227106e-02 store: 6.227106e-02 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 1.600385e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 6.227106e-02 store: 6.227106e-02 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 1.600385e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436 +Round 0 + alias entry %41 = getelementptr inbounds %struct.Comm, %struct.Comm* %2, i64 %40, i32 0, !dbg !45 + alias entry %43 = getelementptr inbounds %struct.Comm, %struct.Comm* %1, i64 %40, i32 0, !dbg !53 + alias entry %46 = getelementptr inbounds %struct.Comm, %struct.Comm* %2, i64 %40, i32 1, !dbg !55 + alias entry %48 = getelementptr inbounds %struct.Comm, %struct.Comm* %1, i64 %40, i32 1, !dbg !57 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (5.076923e+00) from %struct.Comm* %2 + load (5.076923e+00) from %struct.Comm* %1 + store (5.076923e+00) to %struct.Comm* %1 + load (5.076923e+00) from %struct.Comm* %2 + load (5.076923e+00) from %struct.Comm* %1 + store (5.076923e+00) to %struct.Comm* %1 + Frequency of %struct.Comm* %1 + load: 1.015385e+01 store: 1.015385e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 1.015385e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455 +Round 0 + alias entry %41 = getelementptr inbounds double, double* %1, i64 %40, !dbg !45 + alias entry %42 = getelementptr inbounds %struct.Comm, %struct.Comm* %2, i64 %40, i32 1, !dbg !52 + alias entry %43 = getelementptr inbounds %struct.Comm, %struct.Comm* %2, i64 %40, i32 0, !dbg !57 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + store (5.076923e+00) to double* %1 + store (5.076923e+00) to %struct.Comm* %2 + store (5.076923e+00) to %struct.Comm* %2 + Frequency of double* %1 + load: 0.000000e+00 store: 5.076923e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 1.015385e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368 +Round 0 +Round end +change loop scale from 32.0 to 1.0 +Warning: wrong traversal order, or recursive call +On function _Z27distExecuteLouvainIterationlPKlS0_PK4EdgeS0_PlPKdP4CommS8_dPdi +Round 0 + alias entry %91 = getelementptr inbounds i64, i64* %2, i64 %90, !dbg !35 + alias entry %93 = getelementptr inbounds i64, i64* %4, i64 %0, !dbg !38 + alias entry %96 = getelementptr inbounds i64, i64* %1, i64 %0, !dbg !40 + alias entry %99 = getelementptr inbounds i64, i64* %1, i64 %98, !dbg !42 + alias entry %103 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %95, i32 0, !dbg !45 + alias entry %105 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %95, i32 1, !dbg !49 + base alias entry %178 = select i1 %119, %struct.Edge** %13, %struct.Edge** %177 + alias entry %188 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %187, i32 0, !dbg !69 + alias entry %189 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %187, i32 1, !dbg !70 + alias entry %198 = getelementptr inbounds i64, i64* %4, i64 %197, !dbg !77 + alias entry %239 = bitcast double* %189 to i64*, !dbg !109 + alias entry %282 = getelementptr inbounds double, double* %10, i64 %0, !dbg !122 + alias entry %286 = getelementptr inbounds double, double* %6, i64 %0, !dbg !125 + alias entry %307 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %306, i32 1, !dbg !136 + alias entry %309 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %306, i32 0, !dbg !137 + alias entry %355 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %354, i32 1, !dbg !136 + alias entry %357 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %354, i32 0, !dbg !137 + alias entry %403 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %402, i32 1, !dbg !167 + alias entry %404 = bitcast double* %403 to i64*, !dbg !168 + alias entry %415 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %402, i32 0, !dbg !170 + alias entry %417 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %95, i32 1, !dbg !172 + alias entry %419 = bitcast double* %417 to i64*, !dbg !174 + alias entry %430 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %95, i32 0, !dbg !176 + alias entry %434 = getelementptr inbounds i64, i64* %5, i64 %0, !dbg !179 + alias entry %462 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %461, i32 1, !dbg !136 + alias entry %464 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %461, i32 0, !dbg !137 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (1.000000e+00) from i64* %2 + load (1.000000e+00) from i64* %4 + load (1.000000e+00) from i64* %1 + load (1.000000e+00) from i64* %1 + load (5.000000e-01) from %struct.Comm* %7 + load (5.000000e-01) from %struct.Comm* %7 + load (8.000000e+00) from %struct.Edge* %3 + load (4.000000e+00) from %struct.Edge* %3 + load (8.000000e+00) from i64* %4 + load (2.500000e+00) from %struct.Edge* %3 + load (2.750000e+00) from %struct.Edge* %3 + load (5.000000e-01) from double* %10 + store (5.000000e-01) to double* %10 + load (5.000000e-01) from double* %6 + load (1.236264e-01) from %struct.Comm* %7 + load (1.236264e-01) from %struct.Comm* %7 + load (5.000000e+00) from %struct.Comm* %7 + load (5.000000e+00) from %struct.Comm* %7 + load (2.500000e-01) from %struct.Comm* %8 + load (2.500000e-01) from double* %6 + load (2.500000e-01) from %struct.Comm* %8 + store (1.000000e+00) to i64* %5 + load (5.000000e+00) from %struct.Comm* %7 + load (5.000000e+00) from %struct.Comm* %7 + Frequency of i64* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %3 + load: 1.725000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 9.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 0.000000e+00 store: 1.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %7 + load: 2.124725e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 5.000000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 5.000000e-01 store: 5.000000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z24distBuildLocalMapCounterllP7clmap_tRiPdS1_PK4EdgePKllll +Round 0 + base alias entry %83 = select i1 %16, %struct.Edge** %12, %struct.Edge** %82 + alias entry %93 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %92, i32 0, !dbg !38 + alias entry %94 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %92, i32 1, !dbg !39 + alias entry %103 = getelementptr inbounds i64, i64* %7, i64 %102, !dbg !48 + alias entry %111 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %110, i32 0, !dbg !53 + alias entry %121 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %120, !dbg !61 + alias entry %131 = getelementptr inbounds double, double* %4, i64 %125, !dbg !70 + alias entry %138 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %120, i32 1, !dbg !75 + alias entry %139 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %120, i32 0, !dbg !76 + alias entry %146 = getelementptr inbounds double, double* %4, i64 %145, !dbg !83 + alias entry %147 = bitcast double* %146 to i64*, !dbg !84 + alias entry %148 = bitcast double* %94 to i64*, !dbg !85 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (5.000000e-01) from %struct.Edge* %6 + load (2.472527e-01) from %struct.Edge* %6 + load (5.000000e-01) from i64* %7 + load (5.000000e-01) from i32* %3 + load (5.076923e+00) from %struct.clmap_t* %2 + load (3.076923e-01) from i32* %5 + load (1.538462e-01) from %struct.Edge* %6 + load (1.538462e-01) from double* %4 + store (1.538462e-01) to double* %4 + store (1.703297e-01) to %struct.clmap_t* %2 + store (1.703297e-01) to %struct.clmap_t* %2 + store (1.703297e-01) to i32* %3 + load (3.406593e-01) from i32* %5 + load (1.703297e-01) from %struct.Edge* %6 + store (1.703297e-01) to double* %4 + store (1.703297e-01) to i32* %5 + Frequency of %struct.clmap_t* %2 + load: 5.076923e+00 store: 3.406593e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 5.000000e-01 store: 1.703297e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 1.538462e-01 store: 3.241758e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %5 + load: 6.483516e-01 store: 1.703297e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %6 + load: 1.071429e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 5.000000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z15distGetMaxIndexP7clmap_tRiPdS1_dPK4Commdldllld +Round 0 + alias entry %22 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 %21 + alias entry %28 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 0, !dbg !36 + alias entry %33 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 1, !dbg !43 + alias entry %35 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 0, !dbg !46 + alias entry %37 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 1, !dbg !48 + alias entry %41 = getelementptr inbounds double, double* %2, i64 %38, !dbg !52 + alias entry %60 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 1, !dbg !62 + alias entry %81 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %80, i32 1, !dbg !43 + alias entry %83 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %80, i32 0, !dbg !46 + alias entry %89 = getelementptr inbounds double, double* %2, i64 %86, !dbg !52 + alias entry %126 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %125, i32 1, !dbg !43 + alias entry %128 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %125, i32 0, !dbg !46 + alias entry %134 = getelementptr inbounds double, double* %2, i64 %131, !dbg !52 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (1.000000e+00) from double* %2 + load (1.000000e+00) from i32* %3 + load (1.000000e+00) from i32* %1 + load (5.000000e-01) from %struct.clmap_t* %0 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.clmap_t* %0 + load (1.250000e-01) from double* %2 + load (3.125000e-01) from %struct.Comm* %5 + load (3.125000e-01) from %struct.Comm* %5 + load (1.562500e-01) from double* %2 + load (3.125000e-01) from %struct.Comm* %5 + load (3.125000e-01) from %struct.Comm* %5 + load (1.562500e-01) from double* %2 + Frequency of %struct.clmap_t* %0 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 1.437500e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 1.750000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368 +Round 0 +Round end +change loop scale from 32.0 to 1.0 + call (5.076923e+00, 2.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %1 + call (5.076923e+00, 1.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %2 + call (5.076923e+00, 1.725000e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Edge* %3 + call (5.076923e+00, 9.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %4 + call (5.076923e+00, 0.000000e+00, 1.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %5 + call (5.076923e+00, 7.500000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using double* %6 + call (5.076923e+00, 2.124725e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %7 + call (5.076923e+00, 5.000000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %8 + call (5.076923e+00, 5.000000e-01, 5.000000e-01, 0.000000e+00, 0.000000e+00) using double* %10 + Frequency of i64* %1 + load: 1.015385e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 5.076923e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %3 + load: 8.757692e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 4.569231e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 0.000000e+00 store: 5.076923e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 3.807692e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %7 + load: 1.078707e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 2.538462e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 2.538462e+00 store: 2.538462e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + ---- Identify Target Regions ---- + ---- OMP (main.cpp, nvptx64-nvidia-cuda) ---- +Info: ignore malloc +Info: ignore malloc +Info: ignore malloc +Round 0 +Round end + ---- Access Frequency Analysis ---- + ---- Optimization Preparation ---- + ---- Data Mapping Optimization ---- +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +1 warning generated. + ---- Function Argument Access Frequency CG Analysis ---- +On function _Z7is_pwr2i +Round 0 +Round end +On function _Z8reseederj +Round 0 +Round end +On function _ZNSt8seed_seq8generateIN9__gnu_cxx17__normal_iteratorIPjSt6vectorIjSaIjEEEEEEvT_S8_ +Round 0 + alias entry %18 = getelementptr inbounds %"class.std::seed_seq", %"class.std::seed_seq"* %0, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !10369 + alias entry %19 = bitcast i32** %18 to i64*, !dbg !10369 + alias entry %21 = bitcast %"class.std::seed_seq"* %0 to i64*, !dbg !10376 +Round 1 +Round end + load (6.274510e-01) from %"class.std::seed_seq"* %0 + load (6.274510e-01) from %"class.std::seed_seq"* %0 + Frequency of %"class.std::seed_seq"* %0 + load: 1.254902e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z4lockv +Round 0 +Round end +On function _Z6unlockv +Round 0 +Round end +On function _Z19distSumVertexDegreeRK5GraphRSt6vectorIdSaIdEERS2_I4CommSaIS6_EE +Round 0 + alias entry %6 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10459 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __clang_call_terminate +Round 0 +Round end + Frequency of i8* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined. +Round 0 + alias entry %25 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 0, i32 0, i32 0, i32 0 + alias entry %26 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 1, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (6.350000e+00) from %class.Graph* %3 + load (6.350000e+00) from %class.Graph* %3 + load (6.350000e+00) from %"class.std::vector.10"* %4 + load (6.350000e+00) from %"class.std::vector.15"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %class.Graph* %3 + load: 1.270000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %4 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %5 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z29distCalcConstantForSecondTermRKSt6vectorIdSaIdEEP19ompi_communicator_t +Round 0 + alias entry %9 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10283 + alias entry %10 = bitcast double** %9 to i64*, !dbg !10283 + alias entry %12 = bitcast %"class.std::vector.10"* %0 to i64*, !dbg !10288 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.10"* %0 + load (1.000000e+00) from %"class.std::vector.10"* %0 + Frequency of %"class.std::vector.10"* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.ompi_communicator_t* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..2 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %98 = bitcast double* %3 to i64*, !dbg !10325 +Round 1 +Round end + load (3.157895e-01) from %"class.std::vector.10"* %4 + load (2.105263e-01) from double* %3 + store (2.105263e-01) to double* %3 + load (2.105263e-01) from double* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z12distInitCommRSt6vectorIlSaIlEES2_l +Round 0 + alias entry %6 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10273 + alias entry %7 = bitcast i64** %6 to i64*, !dbg !10273 + alias entry %9 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10280 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.0"* %1 + load (1.000000e+00) from %"class.std::vector.0"* %1 + Frequency of %"class.std::vector.0"* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..4 +Round 0 + alias entry %29 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %31 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from %"class.std::vector.0"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %5 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z15distInitLouvainRK5GraphRSt6vectorIlSaIlEES5_RS2_IdSaIdEES8_RS2_I4CommSaIS9_EESC_Rdi +Round 0 + alias entry %16 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !10485 + alias entry %20 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10502 + alias entry %22 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10514 + alias entry %24 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %3, i64 0, i32 0, i32 0, i32 1, !dbg !10532 + alias entry %25 = bitcast double** %24 to i64*, !dbg !10532 + alias entry %27 = bitcast %"class.std::vector.10"* %3 to i64*, !dbg !10536 + alias entry %40 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10572 + alias entry %41 = bitcast i64** %40 to i64*, !dbg !10572 + alias entry %43 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10574 + alias entry %56 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %2, i64 0, i32 0, i32 0, i32 1, !dbg !10600 + alias entry %57 = bitcast i64** %56 to i64*, !dbg !10600 + alias entry %59 = bitcast %"class.std::vector.0"* %2 to i64*, !dbg !10601 + alias entry %72 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 1, !dbg !10622 + alias entry %73 = bitcast double** %72 to i64*, !dbg !10622 + alias entry %75 = bitcast %"class.std::vector.10"* %4 to i64*, !dbg !10623 + alias entry %88 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %5, i64 0, i32 0, i32 0, i32 1, !dbg !10654 + alias entry %89 = bitcast %struct.Comm** %88 to i64*, !dbg !10654 + alias entry %91 = bitcast %"class.std::vector.15"* %5 to i64*, !dbg !10658 + alias entry %104 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %6, i64 0, i32 0, i32 0, i32 1, !dbg !10685 + alias entry %105 = bitcast %struct.Comm** %104 to i64*, !dbg !10685 + alias entry %107 = bitcast %"class.std::vector.15"* %6 to i64*, !dbg !10686 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %"class.std::vector.10"* %3 + load (1.000000e+00) from %"class.std::vector.10"* %3 +Warning: wrong traversal order, or recursive call +On function _Z15distGetMaxIndexP7clmap_tRiPdS1_dPK4Commdldllld +Round 0 + alias entry %22 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 %21 + alias entry %28 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 0, !dbg !10320 + alias entry %33 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 1, !dbg !10330 + alias entry %35 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 0, !dbg !10333 + alias entry %37 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 1, !dbg !10335 + alias entry %41 = getelementptr inbounds double, double* %2, i64 %38, !dbg !10340 + alias entry %60 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 1, !dbg !10352 + alias entry %80 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %79, i32 1, !dbg !10330 + alias entry %82 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %79, i32 0, !dbg !10333 + alias entry %88 = getelementptr inbounds double, double* %2, i64 %85, !dbg !10340 + alias entry %124 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %123, i32 1, !dbg !10330 + alias entry %126 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %123, i32 0, !dbg !10333 + alias entry %132 = getelementptr inbounds double, double* %2, i64 %129, !dbg !10340 +Round 1 +Round end + load (1.000000e+00) from double* %2 + load (1.000000e+00) from i32* %3 + load (1.000000e+00) from i32* %1 + load (5.000000e-01) from %struct.clmap_t* %0 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.clmap_t* %0 + load (1.250000e-01) from double* %2 + load (9.984375e+00) from %struct.Comm* %5 + load (9.984375e+00) from %struct.Comm* %5 + load (4.984375e+00) from double* %2 + load (9.984375e+00) from %struct.Comm* %5 + load (9.984375e+00) from %struct.Comm* %5 + load (4.984375e+00) from double* %2 + Frequency of %struct.clmap_t* %0 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 1.109375e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 4.043750e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z24distBuildLocalMapCounterllP7clmap_tRiPdS1_PK4EdgePKllll +Round 0 + alias entry %20 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %19, i32 0, !dbg !10308 + alias entry %21 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %19, i32 1, !dbg !10310 + alias entry %30 = getelementptr inbounds i64, i64* %7, i64 %29, !dbg !10326 + alias entry %37 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %35, i32 0, !dbg !10337 + alias entry %45 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %34, !dbg !10348 + alias entry %55 = getelementptr inbounds double, double* %4, i64 %49, !dbg !10358 + alias entry %61 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %34, i32 0, !dbg !10364 + alias entry %62 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %34, i32 1, !dbg !10367 + alias entry %68 = bitcast double* %21 to i64*, !dbg !10375 + alias entry %71 = getelementptr inbounds double, double* %4, i64 %70, !dbg !10377 + alias entry %72 = bitcast double* %71 to i64*, !dbg !10378 +Round 1 +Round end + load (1.593750e+01) from %struct.Edge* %6 + load (7.937500e+00) from %struct.Edge* %6 + load (1.593750e+01) from i64* %7 + load (1.593750e+01) from i32* %3 + load (1.625000e+02) from %struct.clmap_t* %2 + load (9.937500e+00) from i32* %5 + load (4.937500e+00) from %struct.Edge* %6 + load (4.937500e+00) from double* %4 + store (4.937500e+00) to double* %4 + store (5.437500e+00) to %struct.clmap_t* %2 + store (5.437500e+00) to %struct.clmap_t* %2 + store (5.437500e+00) to i32* %3 + load (1.093750e+01) from i32* %5 + load (5.437500e+00) from %struct.Edge* %6 + store (5.437500e+00) to double* %4 + store (5.437500e+00) to i32* %5 + Frequency of %struct.clmap_t* %2 + load: 1.625000e+02 store: 1.087500e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.593750e+01 store: 5.437500e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 4.937500e+00 store: 1.037500e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %5 + load: 2.087500e+01 store: 5.437500e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %6 + load: 3.425000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 1.593750e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z27distExecuteLouvainIterationlPKlS0_PK4EdgeS0_PlPKdP4CommS8_dPdi +Round 0 + alias entry %18 = getelementptr inbounds i64, i64* %2, i64 %17, !dbg !10316 + alias entry %20 = getelementptr inbounds i64, i64* %4, i64 %0, !dbg !10322 + alias entry %23 = getelementptr inbounds i64, i64* %1, i64 %0, !dbg !10329 + alias entry %26 = getelementptr inbounds i64, i64* %1, i64 %25, !dbg !10332 + alias entry %30 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %22, i32 0, !dbg !10337 + alias entry %32 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %22, i32 1, !dbg !10341 + alias entry %47 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %46, i32 0, !dbg !10401 + alias entry %48 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %46, i32 1, !dbg !10403 + alias entry %57 = getelementptr inbounds i64, i64* %4, i64 %56, !dbg !10414 + alias entry %93 = bitcast double* %48 to i64*, !dbg !10457 + alias entry %116 = getelementptr inbounds double, double* %10, i64 %0, !dbg !10470 + alias entry %120 = getelementptr inbounds double, double* %6, i64 %0, !dbg !10473 + alias entry %137 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %136, i32 1, !dbg !10533 + alias entry %139 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %136, i32 0, !dbg !10534 + alias entry %183 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %182, i32 1, !dbg !10533 + alias entry %185 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %182, i32 0, !dbg !10534 + alias entry %230 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %229, i32 1, !dbg !10572 + alias entry %231 = bitcast double* %230 to i64*, !dbg !10573 + alias entry %242 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %229, i32 0, !dbg !10575 + alias entry %244 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %22, i32 1, !dbg !10578 + alias entry %246 = bitcast double* %244 to i64*, !dbg !10581 + alias entry %257 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %22, i32 0, !dbg !10583 + alias entry %261 = getelementptr inbounds i64, i64* %5, i64 %0, !dbg !10587 + alias entry %264 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %263, i32 1, !dbg !10533 + alias entry %266 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %263, i32 0, !dbg !10534 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (1.000000e+00) from i64* %4 + load (1.000000e+00) from i64* %1 + load (1.000000e+00) from i64* %1 + load (5.000000e-01) from %struct.Comm* %7 + load (5.000000e-01) from %struct.Comm* %7 + load (7.992188e+00) from %struct.Edge* %3 + load (3.992188e+00) from %struct.Edge* %3 + load (7.992188e+00) from i64* %4 + load (2.492188e+00) from %struct.Edge* %3 + load (2.742188e+00) from %struct.Edge* %3 + load (5.000000e-01) from double* %10 + store (5.000000e-01) to double* %10 + load (5.000000e-01) from double* %6 + load (1.250000e-01) from %struct.Comm* %7 + load (1.250000e-01) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + load (2.500000e-01) from %struct.Comm* %8 + load (2.500000e-01) from double* %6 + load (2.500000e-01) from %struct.Comm* %8 + store (1.000000e+00) to i64* %5 + load (4.992188e+00) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + Frequency of i64* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %3 + load: 1.721875e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 8.992188e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 0.000000e+00 store: 1.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %7 + load: 2.121875e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 5.000000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 5.000000e-01 store: 5.000000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z21distComputeModularityRK5GraphP4CommPKddi +Round 0 + alias entry %14 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10288 + alias entry %16 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10304 + base alias entry %35 = bitcast i8** %34 to double**, !dbg !10317 + base alias entry %37 = bitcast i8** %36 to double**, !dbg !10317 + base alias entry %45 = bitcast i8** %44 to %struct.Comm**, !dbg !10317 + base alias entry %47 = bitcast i8** %46 to %struct.Comm**, !dbg !10317 +Round 1 + base alias entry %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias entry %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias entry %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias entry %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Round 2 + base alias offset entry (2) %11 = alloca [5 x i8*], align 8 + base alias offset entry (2) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (-1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 + base alias offset entry (4) %11 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias offset entry (4) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Round 3 + base alias offset entry (4) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (4) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (3) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (3) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (2) %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias offset entry (2) %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias offset entry (1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 +Round 4 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.7 +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to double**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..8 +Round 0 + alias entry %39 = getelementptr inbounds double, double* %6, i64 %38, !dbg !10318 + alias entry %42 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %38, i32 1, !dbg !10321 + alias entry %62 = bitcast double* %5 to i64*, !dbg !10329 + alias entry %74 = bitcast double* %7 to i64*, !dbg !10329 +Round 1 +Round end + load (1.010526e+01) from double* %6 + load (1.010526e+01) from %struct.Comm* %8 + load (2.105263e-01) from double* %5 + store (2.105263e-01) to double* %5 + load (2.105263e-01) from double* %7 + store (2.105263e-01) to double* %7 + load (2.105263e-01) from double* %5 + load (2.105263e-01) from double* %7 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 1.010526e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %7 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 1.010526e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.9 +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to double**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..10 +Round 0 + alias entry %65 = bitcast double* %3 to i64*, !dbg !10310 + alias entry %77 = bitcast double* %5 to i64*, !dbg !10310 +Round 1 +Round end + load (2.916667e-01) from double* %3 + store (2.916667e-01) to double* %3 + load (2.916667e-01) from double* %5 + store (2.916667e-01) to double* %5 + load (3.333333e-01) from double* %3 + load (3.333333e-01) from double* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 6.250000e-01 store: 2.916667e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 6.250000e-01 store: 2.916667e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z20distUpdateLocalCinfolP4CommPKS_ +Round 0 + base alias entry %15 = bitcast i8** %14 to %struct.Comm**, !dbg !10269 + base alias entry %17 = bitcast i8** %16 to %struct.Comm**, !dbg !10269 + base alias entry %20 = bitcast i8** %19 to %struct.Comm**, !dbg !10269 + base alias entry %22 = bitcast i8** %21 to %struct.Comm**, !dbg !10269 +Round 1 + base alias entry %14 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias entry %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 + base alias entry %19 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias entry %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 2 + base alias offset entry (1) %5 = alloca [3 x i8*], align 8 + base alias offset entry (1) %6 = alloca [3 x i8*], align 8 + base alias offset entry (2) %5 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %19 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias offset entry (2) %6 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 3 + base alias offset entry (1) %9 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %9 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %14 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias offset entry (1) %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 +Round 4 +Round end + Frequency of %struct.Comm* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..13 +Round 0 + alias entry %33 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %26, !dbg !10304 + alias entry %34 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %25, i32 1, !dbg !10304 + alias entry %35 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %26, !dbg !10304 + alias entry %36 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %25, i32 1, !dbg !10304 + alias entry %37 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %26, i32 1, !dbg !10304 + alias entry %38 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %29, !dbg !10304 + alias entry %39 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %26, i32 1, !dbg !10304 + alias entry %40 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %29, !dbg !10304 + alias entry %41 = bitcast double* %36 to %struct.Comm*, !dbg !10304 + alias entry %43 = bitcast double* %34 to %struct.Comm*, !dbg !10304 + alias entry %46 = bitcast %struct.Comm* %40 to double*, !dbg !10304 + alias entry %48 = bitcast %struct.Comm* %38 to double*, !dbg !10304 + alias entry %63 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %57, i32 0, !dbg !10304 + alias entry %64 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %58, i32 0, !dbg !10304 + alias entry %65 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %59, i32 0, !dbg !10304 + alias entry %66 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %60, i32 0, !dbg !10304 + alias entry %67 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %61, i32 0, !dbg !10304 + alias entry %68 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %62, i32 0, !dbg !10304 + alias entry %69 = bitcast i64* %63 to <4 x i64>*, !dbg !10304 + alias entry %70 = bitcast i64* %64 to <4 x i64>*, !dbg !10304 + alias entry %71 = bitcast i64* %65 to <4 x i64>*, !dbg !10304 + alias entry %72 = bitcast i64* %66 to <4 x i64>*, !dbg !10304 + alias entry %73 = bitcast i64* %67 to <4 x i64>*, !dbg !10304 + alias entry %74 = bitcast i64* %68 to <4 x i64>*, !dbg !10304 + alias entry %93 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %57, i32 0, !dbg !10307 + alias entry %94 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %58, i32 0, !dbg !10307 + alias entry %95 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %59, i32 0, !dbg !10307 + alias entry %96 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %60, i32 0, !dbg !10307 + alias entry %97 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %61, i32 0, !dbg !10307 + alias entry %98 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %62, i32 0, !dbg !10307 + alias entry %99 = bitcast i64* %93 to <4 x i64>*, !dbg !10307 + alias entry %100 = bitcast i64* %94 to <4 x i64>*, !dbg !10307 + alias entry %101 = bitcast i64* %95 to <4 x i64>*, !dbg !10307 + alias entry %102 = bitcast i64* %96 to <4 x i64>*, !dbg !10307 + alias entry %103 = bitcast i64* %97 to <4 x i64>*, !dbg !10307 + alias entry %104 = bitcast i64* %98 to <4 x i64>*, !dbg !10307 + alias entry %135 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %57, i32 1, !dbg !10309 + alias entry %136 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %58, i32 1, !dbg !10309 + alias entry %137 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %59, i32 1, !dbg !10309 + alias entry %138 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %60, i32 1, !dbg !10309 + alias entry %139 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %61, i32 1, !dbg !10309 + alias entry %140 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %62, i32 1, !dbg !10309 + alias entry %147 = getelementptr inbounds double, double* %135, i64 -1, !dbg !10309 + alias entry %148 = bitcast double* %147 to <4 x double>*, !dbg !10309 + alias entry %149 = getelementptr inbounds double, double* %136, i64 -1, !dbg !10309 + alias entry %150 = bitcast double* %149 to <4 x double>*, !dbg !10309 + alias entry %151 = getelementptr inbounds double, double* %137, i64 -1, !dbg !10309 + alias entry %152 = bitcast double* %151 to <4 x double>*, !dbg !10309 + alias entry %153 = getelementptr inbounds double, double* %138, i64 -1, !dbg !10309 + alias entry %154 = bitcast double* %153 to <4 x double>*, !dbg !10309 + alias entry %155 = getelementptr inbounds double, double* %139, i64 -1, !dbg !10309 + alias entry %156 = bitcast double* %155 to <4 x double>*, !dbg !10309 + alias entry %157 = getelementptr inbounds double, double* %140, i64 -1, !dbg !10309 + alias entry %158 = bitcast double* %157 to <4 x double>*, !dbg !10309 + alias entry %178 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %177, i32 0, !dbg !10304 + alias entry %180 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %177, i32 0, !dbg !10307 + alias entry %183 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %177, i32 1, !dbg !10318 + alias entry %185 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %177, i32 1, !dbg !10309 +Round 1 +Round end + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + load (9.088235e+00) from %struct.Comm* %6 + load (9.088235e+00) from %struct.Comm* %5 + store (9.088235e+00) to %struct.Comm* %5 + load (9.088235e+00) from %struct.Comm* %6 + load (9.088235e+00) from %struct.Comm* %5 + store (9.088235e+00) to %struct.Comm* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 3.317647e+01 store: 3.317647e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 3.317647e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..14 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z16distCleanCWandCUlPdP4Comm +Round 0 + base alias entry %17 = bitcast i8** %16 to double**, !dbg !10269 + base alias entry %19 = bitcast i8** %18 to double**, !dbg !10269 + base alias entry %22 = bitcast i8** %21 to %struct.Comm**, !dbg !10269 + base alias entry %24 = bitcast i8** %23 to %struct.Comm**, !dbg !10269 +Round 1 + base alias entry %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias entry %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 + base alias entry %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias entry %23 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 2 + base alias offset entry (1) %5 = alloca [3 x i8*], align 8 + base alias offset entry (1) %6 = alloca [3 x i8*], align 8 + base alias offset entry (2) %5 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias offset entry (2) %6 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %23 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 3 + base alias offset entry (1) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %13 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %13 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias offset entry (1) %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 +Round 4 +Round end + Frequency of double* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..18 +Round 0 + alias entry %29 = getelementptr inbounds double, double* %5, i64 %28, !dbg !10304 + alias entry %30 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %28, i32 0, !dbg !10309 + alias entry %33 = bitcast i64* %30 to i8*, !dbg !10299 +Round 1 +Round end + store (1.058333e+01) to double* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 0.000000e+00 store: 1.058333e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..19 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z21fillRemoteCommunitiesRK5GraphiiRKmS3_RKSt6vectorIlSaIlEES8_S8_S8_S8_RKS4_I4CommSaIS9_EERSt3mapIlS9_St4lessIlESaISt4pairIKlS9_EEERSt13unordered_mapIllSt4hashIlESt8equal_toIlESaISH_ISI_lEEESM_ +Round 0 + alias entry %126 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !11433 + alias entry %130 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !11449 + alias entry %132 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !11460 + alias entry %190 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 + alias entry %197 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 + alias entry %299 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 2, i32 0, !dbg !11792 + alias entry %300 = bitcast %"struct.std::__detail::_Hash_node_base"* %299 to %"struct.std::__detail::_Hash_node"**, !dbg !11793 + alias entry %308 = bitcast %"class.std::unordered_map"* %12 to i8**, !dbg !11836 + alias entry %310 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 1, !dbg !11842 + alias entry %313 = bitcast %"struct.std::__detail::_Hash_node_base"* %299 to i8*, !dbg !11846 + alias entry %316 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %8, i64 0, i32 0, i32 0, i32 0 + alias entry %317 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0 + alias entry %318 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 0 + alias entry %319 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %320 = bitcast %"class.std::vector.0"* %319 to i64* + alias entry %321 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %322 = bitcast i64** %321 to i64* + alias entry %325 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %9, i64 0, i32 0, i32 0, i32 0 + alias entry %326 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %327 = bitcast %"class.std::vector.0"* %326 to i64* + alias entry %328 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %329 = bitcast i64** %328 to i64* + alias entry %800 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, !dbg !13393 + alias entry %801 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 1, !dbg !13405 + alias entry %802 = bitcast %"struct.std::_Rb_tree_node_base"** %801 to %"struct.std::_Rb_tree_node"**, !dbg !13405 + alias entry %808 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, !dbg !13419 + alias entry %809 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13425 + base alias entry %809 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13425 + alias entry %810 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13435 + base alias entry %810 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13435 + alias entry %811 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 2, !dbg !13437 + alias entry %812 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, !dbg !13442 + alias entry %813 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 1, !dbg !13447 + alias entry %814 = bitcast %"struct.std::_Rb_tree_node_base"** %813 to %"struct.std::_Rb_tree_node"**, !dbg !13447 + alias entry %820 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, !dbg !13452 + alias entry %821 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13455 + base alias entry %821 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13455 + alias entry %822 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13462 + base alias entry %822 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13462 + alias entry %823 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 2, !dbg !13464 + alias entry %828 = bitcast %"struct.std::_Rb_tree_node_base"** %801 to i64* + alias entry %830 = bitcast %"struct.std::_Rb_tree_node_base"* %808 to %"struct.std::_Rb_tree_node"* + alias entry %832 = bitcast %"struct.std::_Rb_tree_node_base"** %813 to i64* + alias entry %834 = bitcast %"struct.std::_Rb_tree_node_base"* %820 to %"struct.std::_Rb_tree_node"* + alias entry %943 = load %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"** %809, align 8, !dbg !14017, !tbaa !14018 + alias entry %998 = load %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"** %821, align 8, !dbg !14306, !tbaa !14018 +Round 1 +Round end + load (1.000000e+00) from i64* %4 + load (9.999994e-01) from i64* %3 + load (9.999963e-01) from %class.Graph* %0 + load (9.999963e-01) from %class.Graph* %0 + load (9.999963e-01) from %class.Graph* %0 + load (9.999803e+00) from %"class.std::vector.0"* %6 + load (1.999960e+01) from %"class.std::vector.0"* %6 + load (6.249782e+00) from %"class.std::vector.0"* %5 + load (1.249956e+01) from %"class.std::vector.0"* %5 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (1.999809e+01) from %"class.std::vector.0"* %8 + load (1.999807e+01) from %"class.std::unordered_map"* %12 + load (1.999807e+01) from %"class.std::unordered_map"* %12 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..22 +Round 0 + alias entry %31 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %33 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from %"class.std::vector.0"* %4 + load (3.200000e-01) from %"class.std::vector.0"* %6 + load (1.020000e+01) from i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 1.020000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %6 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.24 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..25 +Round 0 + alias entry %33 = getelementptr inbounds %"class.std::vector.29", %"class.std::vector.29"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.29"* %4 + load (3.157895e-01) from %"class.std::vector.0"* %3 + load (2.105263e-01) from i64* %5 + store (2.105263e-01) to i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.29"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.27 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..28 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..30 +Round 0 + alias entry %20 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %2, i64 0, i32 0, i32 0, i32 0, !dbg !10503 + alias entry %34 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %7, i64 0, i32 0, i32 0, i32 0 + alias entry %36 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.0"* %2 + load (2.047500e+02) from %"class.std::vector.0"* %4 + load (2.047500e+02) from %"class.std::vector.15"* %7 + load (2.047500e+02) from %"class.std::vector.52"* %6 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.52"* %6 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %7 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z22createCommunityMPITypev +Round 0 +Round end +On function _Z23destroyCommunityMPITypev +Round 0 +Round end +On function _Z23updateRemoteCommunitiesRK5GraphRSt6vectorI4CommSaIS3_EERKSt3mapIlS3_St4lessIlESaISt4pairIKlS3_EEEii +Round 0 + alias entry %19 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !10869 + alias entry %46 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !11050 + alias entry %48 = getelementptr inbounds %"class.std::map", %"class.std::map"* %2, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !11068 + alias entry %49 = bitcast %"struct.std::_Rb_tree_node_base"** %48 to i64*, !dbg !11068 + alias entry %51 = getelementptr inbounds %"class.std::map", %"class.std::map"* %2, i64 0, i32 0, i32 0, i32 1, !dbg !11085 + alias entry %55 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %56 = bitcast %"class.std::vector.0"* %55 to i64* + alias entry %57 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %58 = bitcast i64** %57 to i64* +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (9.999994e-01) from %class.Graph* %0 + load (9.999994e-01) from %"class.std::map"* %2 + load (1.999985e+01) from %class.Graph* %0 + load (1.999985e+01) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 4.199970e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::map"* %2 + load: 9.999994e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..32 +Round 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.66", %"class.std::vector.66"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %30 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.137255e-01) from %"class.std::vector.66"* %4 + load (3.137255e-01) from %"class.std::vector.0"* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.137255e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.66"* %4 + load: 3.137255e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.34 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to i64**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..35 +Round 0 + alias entry %36 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %38 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (3.157895e-01) from %"class.std::vector.0"* %6 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + load (2.105263e-01) from i64* %5 + store (2.105263e-01) to i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %6 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..37 +Round 0 + alias entry %26 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (6.350000e+00) from %"class.std::vector.52"* %3 + load (6.350000e+00) from %"class.std::vector.15"* %4 + load (6.350000e+00) from i64* %5 + load (2.047500e+02) from i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.52"* %3 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %4 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.111000e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z18exchangeVertexReqsRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ii +Round 0 + alias entry %15 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10306 + alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10319 + alias entry %51 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 1, !dbg !10485 + alias entry %52 = bitcast i64** %51 to i64*, !dbg !10485 + alias entry %54 = bitcast %"class.std::vector.0"* %4 to i64*, !dbg !10489 + alias entry %71 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 1, !dbg !10517 + alias entry %72 = bitcast i64** %71 to i64*, !dbg !10517 + alias entry %74 = bitcast %"class.std::vector.0"* %3 to i64*, !dbg !10518 + alias entry %91 = bitcast %"class.std::vector.0"* %3 to i8** + alias entry %94 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %98 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0, !dbg !10598 + alias entry %99 = bitcast %"class.std::vector.0"* %4 to i8**, !dbg !10598 + alias entry %128 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 1, !dbg !10673 + alias entry %129 = bitcast i64** %128 to i64*, !dbg !10673 + alias entry %131 = bitcast %"class.std::vector.0"* %5 to i64*, !dbg !10674 + alias entry %147 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 1, !dbg !10696 + alias entry %148 = bitcast i64** %147 to i64*, !dbg !10696 + alias entry %150 = bitcast %"class.std::vector.0"* %6 to i64*, !dbg !10697 + alias entry %190 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 + alias entry %249 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 + alias entry %306 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 2, !dbg !11244 + alias entry %307 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 2, !dbg !11245 + alias entry %308 = bitcast i64** %306 to i64*, !dbg !11249 + alias entry %310 = bitcast i64** %307 to i64*, !dbg !11250 + alias entry %316 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 2, !dbg !11279 + alias entry %317 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 2, !dbg !11280 + alias entry %318 = bitcast i64** %316 to i64*, !dbg !11284 + alias entry %320 = bitcast i64** %317 to i64*, !dbg !11285 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (9.999984e-01) from %"class.std::vector.0"* %4 + load (9.999984e-01) from %"class.std::vector.0"* %4 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..39 +Round 0 + alias entry %26 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 0, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 1, i32 0, i32 0, i32 0 + alias entry %28 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 6 + alias entry %29 = bitcast %"class.std::vector.0"* %28 to i64* + alias entry %30 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %31 = bitcast i64** %30 to i64* + alias entry %32 = getelementptr inbounds %"class.std::vector.29", %"class.std::vector.29"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.988141e+02) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (1.590478e+03) from %"class.std::vector.29"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %class.Graph* %3 + load: 9.741684e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.29"* %5 + load: 1.590478e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.41 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..42 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi +Round 0 + alias entry %68 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 2, !dbg !11180 + alias entry %85 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !11380 + alias entry %86 = bitcast i64** %85 to i64*, !dbg !11380 + alias entry %88 = bitcast %class.Graph* %2 to i64*, !dbg !11384 + alias entry %93 = bitcast %class.Graph* %2 to i8**, !dbg !11392 + alias entry %98 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 6, !dbg !11399 + alias entry %99 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 6, i32 0, i32 0, i32 1, !dbg !11402 + alias entry %100 = bitcast i64** %99 to i64*, !dbg !11402 + alias entry %102 = bitcast %"class.std::vector.0"* %98 to i64*, !dbg !11403 + alias entry %107 = bitcast %"class.std::vector.0"* %98 to i8**, !dbg !11410 + alias entry %112 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 1, !dbg !11417 + alias entry %113 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 1, i32 0, i32 0, i32 1, !dbg !11424 + alias entry %114 = bitcast %struct.Edge** %113 to i64*, !dbg !11424 + alias entry %116 = bitcast %"class.std::vector.5"* %112 to i64*, !dbg !11428 + alias entry %121 = bitcast %"class.std::vector.5"* %112 to i8**, !dbg !11440 +Round 1 +Round end + load (9.999981e-01) from %class.Graph* %2 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..45 +Round 0 +Round end + call (1.058333e+01, 2.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %5 + call (1.058333e+01, 1.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %6 + call (1.058333e+01, 1.721875e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Edge* %7 + call (1.058333e+01, 8.992188e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %8 + call (1.058333e+01, 0.000000e+00, 1.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %9 + call (1.058333e+01, 7.500000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using double* %10 + call (1.058333e+01, 2.121875e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %11 + call (1.058333e+01, 5.000000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %12 + call (1.058333e+01, 5.000000e-01, 5.000000e-01, 0.000000e+00, 0.000000e+00) using double* %14 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.116667e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %6 + load: 1.058333e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %7 + load: 1.822318e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %8 + load: 9.516732e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %9 + load: 0.000000e+00 store: 1.058333e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 7.937500e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %11 + load: 2.245651e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %12 + load: 5.291667e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %14 + load: 5.291667e+00 store: 5.291667e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..46 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %5 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %8 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %9 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %10 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %12 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..49 +Round 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from i64** %4 + load (3.200000e-01) from i64** %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64** %4 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64** %5 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function main +Round 0 + base alias entry %14 = alloca i8**, align 8 + alias entry %33 = load i8**, i8*** %14, align 8, !dbg !10342, !tbaa !10335 +Round 1 +Round end + Frequency of i8** %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN11GenerateRGGC2ElP19ompi_communicator_t +Round 0 + alias entry %4 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 0, !dbg !10266 + alias entry %5 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10276 + base alias entry %5 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10276 + alias entry %6 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 5, !dbg !10279 + alias entry %8 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10281, !tbaa !10278 + alias entry %9 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 4, !dbg !10282 + alias entry %11 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 7, !dbg !10284 + alias entry %12 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 6, !dbg !10287 + alias entry %36 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 1, !dbg !10320 + alias entry %100 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10478, !tbaa !10278 + alias entry %171 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10565, !tbaa !10278 + alias entry %183 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2, !dbg !10579 + alias entry %190 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10583, !tbaa !10278 +Round 1 +Round end + store (1.000000e+00) to %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + store (2.500000e-01) to %class.GenerateRGG* %0 + store (3.437500e-01) to %class.GenerateRGG* %0 + store (2.500000e-01) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + load (7.656250e-01) from %class.GenerateRGG* %0 + load (7.656250e-01) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + Frequency of %class.GenerateRGG* %0 + load: 8.531250e+00 store: 6.843750e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.ompi_communicator_t* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN11GenerateRGG8generateEbbi +Round 0 + alias entry %27 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 1, !dbg !10306 + alias entry %75 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 6, !dbg !10592 + alias entry %112 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 7, !dbg !10709 + alias entry %153 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 0, !dbg !10828 + alias entry %156 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 4, !dbg !10832 + alias entry %160 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 5, !dbg !10836 + alias entry %362 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10915 + alias entry %696 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !11101 + alias entry %772 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 + alias entry %1095 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 + alias entry %1388 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 +Round 1 +Round end + load (1.000000e+00) from %class.GenerateRGG* %0 + load (6.249994e-01) from %class.GenerateRGG* %0 + load (9.999990e-01) from %class.GenerateRGG* %0 + load (4.999995e-01) from %class.GenerateRGG* %0 + load (3.124994e-01) from %class.GenerateRGG* %0 + load (9.999985e-01) from %class.GenerateRGG* %0 + load (4.999993e-01) from %class.GenerateRGG* %0 + load (3.124992e-01) from %class.GenerateRGG* %0 + load (9.999971e-01) from %class.GenerateRGG* %0 + load (9.999971e-01) from %class.GenerateRGG* %0 + load (9.999962e-01) from %class.GenerateRGG* %0 + load (9.999962e-01) from %class.GenerateRGG* %0 + load (4.999966e-01) from %class.GenerateRGG* %0 + load (4.999971e-01) from %class.GenerateRGG* %0 + load (4.999971e-01) from %class.GenerateRGG* %0 + load (4.999966e-01) from %class.GenerateRGG* %0 + load (9.999923e-01) from %class.GenerateRGG* %0 + load (9.999914e-01) from %class.GenerateRGG* %0 + load (3.749968e-01) from %class.GenerateRGG* %0 + load (3.749964e-01) from %class.GenerateRGG* %0 + load (9.999890e-01) from %class.GenerateRGG* %0 + load (9.998746e-01) from %class.GenerateRGG* %0 + load (3.199362e+02) from %class.GenerateRGG* %0 + load (3.199361e+02) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998698e-01) from %class.GenerateRGG* %0 + load (4.999349e-01) from %class.GenerateRGG* %0 + load (2.499674e-01) from %class.GenerateRGG* %0 + load (7.997451e+01) from %class.GenerateRGG* %0 + load (3.998725e+01) from %class.GenerateRGG* %0 + load (3.998725e+01) from %class.GenerateRGG* %0 + load (7.997448e+01) from %class.GenerateRGG* %0 + load (4.999063e-01) from %class.GenerateRGG* %0 + load (2.499531e-01) from %class.GenerateRGG* %0 + load (7.996993e+01) from %class.GenerateRGG* %0 + load (3.998497e+01) from %class.GenerateRGG* %0 + load (3.998497e+01) from %class.GenerateRGG* %0 + load (7.996991e+01) from %class.GenerateRGG* %0 + load (9.998126e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998072e-01) from %class.GenerateRGG* %0 + load (9.998015e-01) from %class.GenerateRGG* %0 + load (6.248724e-01) from %class.GenerateRGG* %0 + load (6.248718e-01) from %class.GenerateRGG* %0 + load (1.952724e-01) from %class.GenerateRGG* %0 + load (3.905445e-01) from %class.GenerateRGG* %0 + load (3.905442e-01) from %class.GenerateRGG* %0 + load (6.248393e-01) from %class.GenerateRGG* %0 + load (1.249644e+01) from %class.GenerateRGG* %0 + load (1.249643e+01) from %class.GenerateRGG* %0 + load (1.171538e+00) from %class.GenerateRGG* %0 + load (5.857690e-01) from %class.GenerateRGG* %0 + load (2.928845e-01) from %class.GenerateRGG* %0 + load (1.464422e-01) from %class.GenerateRGG* %0 + load (6.248387e-01) from %class.GenerateRGG* %0 + load (6.248381e-01) from %class.GenerateRGG* %0 + load (1.249638e+01) from %class.GenerateRGG* %0 + load (6.248253e-01) from %class.GenerateRGG* %0 + load (3.905154e-01) from %class.GenerateRGG* %0 + load (2.440719e-01) from %class.GenerateRGG* %0 + load (6.248247e-01) from %class.GenerateRGG* %0 + load (4.881438e+00) from %class.GenerateRGG* %0 + load (9.997431e-01) from %class.GenerateRGG* %0 + load (9.997421e-01) from %class.GenerateRGG* %0 + load (9.997406e-01) from %class.GenerateRGG* %0 + load (9.997406e-01) from %class.GenerateRGG* %0 + load (1.999481e+01) from %class.GenerateRGG* %0 + load (9.997388e-01) from %class.GenerateRGG* %0 + load (9.997385e-01) from %class.GenerateRGG* %0 + Frequency of %class.GenerateRGG* %0 + load: 1.246995e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN14BinaryEdgeList4readEiiiSs +Round 0 + alias entry %39 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 4, !dbg !10380 + alias entry %41 = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %4, i64 0, i32 0, i32 0, !dbg !10388 + alias entry %99 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 0, !dbg !10514 + alias entry %100 = bitcast %class.BinaryEdgeList* %0 to i8*, !dbg !10515 + alias entry %104 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 1, !dbg !10518 + alias entry %105 = bitcast i64* %104 to i8*, !dbg !10519 + alias entry %118 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 2, !dbg !10532 + alias entry %182 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 3, !dbg !10605 +Round 1 +Round end + load (9.999971e-01) from %class.BinaryEdgeList* %0 + load (9.999971e-01) from %"class.std::basic_string"* %4 + load (6.249948e-01) from %class.BinaryEdgeList* %0 + load (9.999905e-01) from %class.BinaryEdgeList* %0 + store (9.999905e-01) to %class.BinaryEdgeList* %0 + load (9.999895e-01) from %class.BinaryEdgeList* %0 + load (9.999886e-01) from %class.BinaryEdgeList* %0 + load (9.999886e-01) from %class.BinaryEdgeList* %0 + load (9.999729e-01) from %class.BinaryEdgeList* %0 + store (9.999729e-01) to %class.BinaryEdgeList* %0 + load (9.999714e-01) from %class.BinaryEdgeList* %0 + load (9.999714e-01) from %class.BinaryEdgeList* %0 + load (9.999547e-01) from %class.BinaryEdgeList* %0 + load (1.999909e+01) from %class.BinaryEdgeList* %0 + Frequency of %class.BinaryEdgeList* %0 + load: 2.962391e+01 store: 1.999963e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::basic_string"* %4 + load: 9.999971e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt8_Rb_treeIlSt4pairIKl4CommESt10_Select1stIS3_ESt4lessIlESaIS3_EE8_M_eraseEPSt13_Rb_tree_nodeIS3_E +Round 0 +Round end +Warning: wrong traversal order, or recursive call +On function _ZN5GraphC2EllllP19ompi_communicator_t +Round 0 + alias entry %8 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, !dbg !10272 + alias entry %9 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 1, !dbg !10272 + alias entry %10 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10309 + alias entry %11 = bitcast %class.Graph* %0 to i8*, !dbg !10309 + alias entry %12 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 3, !dbg !10320 + alias entry %13 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 4, !dbg !10322 + alias entry %14 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 5, !dbg !10324 + alias entry %15 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, !dbg !10272 + alias entry %16 = bitcast %"class.std::vector.0"* %15 to i8*, !dbg !10332 + alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10334 + base alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10334 + alias entry %18 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 9, !dbg !10336 + alias entry %21 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %17, align 8, !dbg !10338, !tbaa !10335 + alias entry %22 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 8, !dbg !10339 + alias entry %28 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !10361 + alias entry %29 = bitcast i64** %28 to i64*, !dbg !10361 + alias entry %31 = bitcast %class.Graph* %0 to i64*, !dbg !10365 + alias entry %45 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 1, i32 0, i32 0, i32 1, !dbg !10416 + alias entry %46 = bitcast %struct.Edge** %45 to i64*, !dbg !10416 + alias entry %48 = bitcast %"class.std::vector.5"* %9 to i64*, !dbg !10420 + alias entry %64 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1, !dbg !10455 + alias entry %65 = bitcast i64** %64 to i64*, !dbg !10455 + alias entry %67 = bitcast %"class.std::vector.0"* %15 to i64*, !dbg !10456 + alias entry %76 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %15, i64 0, i32 0, i32 0, i32 0 + alias entry %110 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %15, i64 0, i32 0, i32 0, i32 0, !dbg !10511 + alias entry %116 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %9, i64 0, i32 0, i32 0, i32 0, !dbg !10547 + alias entry %122 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, i32 0, i32 0, i32 0, !dbg !10576 +Round 1 +Round end + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + load (9.999990e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 +Warning: wrong traversal order, or recursive call +On function _ZN3LCGC2EjPdlP19ompi_communicator_t +Round 0 + alias entry %6 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 3, !dbg !10268 + alias entry %7 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 4, !dbg !10277 + alias entry %8 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 6, !dbg !10279 + base alias entry %8 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 6, !dbg !10279 + alias entry %9 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, !dbg !10281 + alias entry %10 = bitcast %"class.std::vector.0"* %9 to i8*, !dbg !10300 + alias entry %11 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0, !dbg !10302 + base alias entry %11 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0, !dbg !10302 + alias entry %12 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 1, !dbg !10306 + alias entry %15 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %11, align 8, !dbg !10308, !tbaa !10305 + alias entry %16 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 2, !dbg !10309 + alias entry %20 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, i32 0, i32 0, i32 1, !dbg !10326 + alias entry %21 = bitcast i64** %20 to i64*, !dbg !10326 + alias entry %23 = bitcast %"class.std::vector.0"* %9 to i64*, !dbg !10330 + alias entry %42 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10359 + alias entry %45 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %9, i64 0, i32 0, i32 0, i32 0, !dbg !10374 + alias entry %52 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10399 + alias entry %53 = bitcast i64* %52 to i8*, !dbg !10400 + alias entry %54 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %11, align 8, !dbg !10401, !tbaa !10305 +Round 1 +Round end + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + load (9.999989e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 +Warning: wrong traversal order, or recursive call +On function _ZNSt24uniform_int_distributionIiEclISt26linear_congruential_engineImLm16807ELm0ELm2147483647EEEEiRT_RKNS0_10param_typeE +Round 0 + alias entry %5 = getelementptr inbounds %"struct.std::uniform_int_distribution::param_type", %"struct.std::uniform_int_distribution::param_type"* %2, i64 0, i32 1, !dbg !10267 + alias entry %8 = getelementptr inbounds %"struct.std::uniform_int_distribution::param_type", %"struct.std::uniform_int_distribution::param_type"* %2, i64 0, i32 0, !dbg !10279 + alias entry %19 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0 + alias entry %37 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0 + alias entry %51 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0, !dbg !10376 +Round 1 +Round end + load (1.000000e+00) from %"struct.std::uniform_int_distribution::param_type"* %2 + load (1.000000e+00) from %"struct.std::uniform_int_distribution::param_type"* %2 + load (5.000000e-01) from %"class.std::linear_congruential_engine"* %1 + store (5.000000e-01) to %"class.std::linear_congruential_engine"* %1 +Warning: wrong traversal order, or recursive call +On function _ZNSt6vectorIlSaIlEEaSERKS1_ +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10278 + alias entry %6 = bitcast i64** %5 to i64*, !dbg !10278 + alias entry %8 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10285 + alias entry %12 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10294 + alias entry %13 = bitcast i64** %12 to i64*, !dbg !10294 + alias entry %15 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10296 + alias entry %.phi.trans.insert = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10460 + alias entry %42 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10490 + alias entry %43 = bitcast i64** %42 to i64*, !dbg !10490 + alias entry %54 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 0, !dbg !10573 + alias entry %74 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10633 + alias entry %77 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10635 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %1 + load (9.765625e-02) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %0 + store (6.250000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.578125e+00 store: 1.250000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %1 + load: 1.445312e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorIlSaIlEE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPlS1_EEmRKl +Round 0 + alias entry %8 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10281 + alias entry %9 = bitcast i64** %8 to i64*, !dbg !10281 + alias entry %11 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10288 + alias entry %12 = bitcast i64** %11 to i64*, !dbg !10288 + alias entry %543 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10728 + alias entry %729 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10820 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from i64* %3 + load (9.765625e-02) from %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from i64* %3 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.382812e+00 store: 1.406250e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 6.250000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI4EdgeSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast %struct.Edge** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %83 = bitcast %"class.std::vector.5"* %0 to i64*, !dbg !10375 + alias entry %104 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %111 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10431 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.5"* %0 + load (6.250000e-01) from %"class.std::vector.5"* %0 + load (3.125000e-01) from %"class.std::vector.5"* %0 + load (1.953125e-01) from %"class.std::vector.5"* %0 + load (1.953125e-01) from %"class.std::vector.5"* %0 + load (3.125000e-01) from %"class.std::vector.5"* %0 + store (3.125000e-01) to %"class.std::vector.5"* %0 + store (3.125000e-01) to %"class.std::vector.5"* %0 + Frequency of %"class.std::vector.5"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN3LCG18parallel_prefix_opEv +Round 0 + alias entry %10 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 4, !dbg !10283 + alias entry %168 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 1, !dbg !10362 + alias entry %174 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 2, !dbg !10269 + alias entry %178 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0 + alias entry %186 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10373 + alias entry %250 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, i32 0, i32 0, i32 0, !dbg !10373 +Round 1 +Round end + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + Frequency of %class.LCG* %0 + load: 8.523529e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI9EdgeTupleSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10273 + alias entry %6 = bitcast %struct.EdgeTuple** %5 to i64*, !dbg !10273 + alias entry %8 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10280 + alias entry %60 = bitcast %"class.std::vector.84"* %0 to i64*, !dbg !10369 + alias entry %81 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %88 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10425 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + Frequency of %"class.std::vector.84"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_E_ET_SC_SC_T0_St26random_access_iterator_tag +Round 0 +Round end +On function _ZNSt6vectorI9EdgeTupleSaIS0_EE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPS0_S2_EEEEvS7_T_S8_St20forward_iterator_tag +Round 0 + alias entry %13 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10344 + alias entry %14 = bitcast %struct.EdgeTuple** %13 to i64*, !dbg !10344 + alias entry %16 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10351 + alias entry %17 = bitcast %struct.EdgeTuple** %16 to i64*, !dbg !10351 + alias entry %116 = bitcast %"class.std::vector.84"* %0 to i64*, !dbg !10799 + alias entry %137 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %142 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10851 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + Frequency of %"class.std::vector.84"* %0 + load: 2.675781e+00 store: 1.406250e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZSt16__introsort_loopIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEElZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_T0_T1_ +Round 0 +Round end +On function _ZSt22__final_insertion_sortIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_T0_ +Round 0 +Round end +On function _ZSt13__heap_selectIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_SC_T0_ +Round 0 +Round end +On function _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEElS2_ZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_T0_SD_T1_T2_ +Round 0 +Round end +On function _ZSt22__move_median_to_firstIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_SC_SC_T0_ +Round 0 +Round end +On function _ZNSt6vectorIlSaIlEE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast i64** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %20 = bitcast i64** %8 to i64*, !dbg !10380 + alias entry %21 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10381 + alias entry %42 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %65 = bitcast %"class.std::vector.0"* %0 to i8**, !dbg !10628 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorIdSaIdEE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast double** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %20 = bitcast double** %8 to i64*, !dbg !10381 + alias entry %21 = bitcast %"class.std::vector.10"* %0 to i64*, !dbg !10382 + alias entry %42 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %65 = bitcast %"class.std::vector.10"* %0 to i8**, !dbg !10630 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.10"* %0 + load (6.250000e-01) from %"class.std::vector.10"* %0 + load (3.125000e-01) from %"class.std::vector.10"* %0 + load (3.125000e-01) from %"class.std::vector.10"* %0 + load (1.953125e-01) from %"class.std::vector.10"* %0 + load (1.953125e-01) from %"class.std::vector.10"* %0 + store (3.125000e-01) to %"class.std::vector.10"* %0 + store (3.125000e-01) to %"class.std::vector.10"* %0 + Frequency of %"class.std::vector.10"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI4CommSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10460 + alias entry %6 = bitcast %struct.Comm** %5 to i64*, !dbg !10460 + alias entry %8 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10467 + alias entry %20 = bitcast %"class.std::vector.15"* %0 to i64*, !dbg !10551 + alias entry %41 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %48 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10607 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.15"* %0 + load (6.250000e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + load (1.953125e-01) from %"class.std::vector.15"* %0 + load (1.953125e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + store (3.125000e-01) to %"class.std::vector.15"* %0 + store (3.125000e-01) to %"class.std::vector.15"* %0 + Frequency of %"class.std::vector.15"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt27__uninitialized_default_n_1ILb0EE18__uninit_default_nIPSt13unordered_setIlSt4hashIlESt8equal_toIlESaIlEEmEEvT_T0_ +Round 0 +Round end + Frequency of %"class.std::unordered_set"* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt10_HashtableIlSt4pairIKllESaIS2_ENSt8__detail10_Select1stESt8equal_toIlESt4hashIlENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE21_M_insert_unique_nodeEmmPNS4_10_Hash_nodeIS2_Lb0EEE +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 4, !dbg !10268 + alias entry %6 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 4, i32 1, !dbg !10275 + alias entry %8 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 1, !dbg !10282 + alias entry %10 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 3, !dbg !10288 + alias entry %17 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 0 + alias entry %29 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 2, i32 0, !dbg !10428 + alias entry %30 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to %"struct.std::__detail::_Hash_node"**, !dbg !10429 + alias entry %32 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %29, i64 0, i32 0, !dbg !10432 + alias entry %35 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to i64* + base alias entry %44 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %28, i64 %43, !dbg !10509 + alias entry %61 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10529, !tbaa !10511 + alias entry %62 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %61, i64 0, i32 0, !dbg !10530 + alias entry %76 = bitcast %"class.std::_Hashtable"* %0 to i8**, !dbg !10550 + alias entry %82 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i8*, !dbg !10618 + alias entry %86 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 0, !dbg !10296 + alias entry %93 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, !dbg !10627 + alias entry %94 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i64*, !dbg !10628 + base alias entry %96 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %95, i64 0, i32 0, !dbg !10630 + alias entry %98 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 2, i32 0, !dbg !10639 + alias entry %99 = bitcast %"struct.std::__detail::_Hash_node_base"* %98 to i64*, !dbg !10640 + alias entry %101 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, !dbg !10641 + alias entry %102 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, i32 0, !dbg !10641 + alias entry %103 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i64*, !dbg !10642 + alias entry %104 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %98, i64 0, i32 0, !dbg !10645 + base alias entry %104 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %98, i64 0, i32 0, !dbg !10645 + base alias entry %113 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %84, i64 %112, !dbg !10676 + base alias entry %117 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %116, i64 %85, !dbg !10678 +Round 1 +Warning: the first offset is not constant + alias entry %45 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10509, !tbaa !10511 + alias entry %57 = bitcast %"struct.std::__detail::_Hash_node_base"* %45 to i64*, !dbg !10525 + base alias offset entry (0) %95 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %87, align 8, !dbg !10629, !tbaa !10511 +Warning: the first offset is not constant +Warning: the first offset is not constant +Round 2 +Warning: the first offset is not constant +Warning: the first offset is not constant +Warning: the first offset is not constant +Round end + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (5.000000e-01) from %"class.std::_Hashtable"* %0 + load (4.999995e-01) from %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + load (3.749996e+00) from %"class.std::_Hashtable"* %0 + store (3.749996e+00) to %"class.std::_Hashtable"* %0 + load (6.249994e+00) from %"class.std::_Hashtable"* %0 + store (6.249994e+00) to %"class.std::_Hashtable"* %0 + store (4.768372e-07) to %"class.std::_Hashtable"* %0 + load (4.999995e-01) from %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + store (6.249997e-01) to %"struct.std::__detail::_Hash_node"* %3 + load (3.749998e-01) from %"class.std::_Hashtable"* %0 + store (3.749998e-01) to %"struct.std::__detail::_Hash_node"* %3 + store (3.749998e-01) to %"class.std::_Hashtable"* %0 + load (3.749998e-01) from %"struct.std::__detail::_Hash_node"* %3 + load (2.343749e-01) from %"class.std::_Hashtable"* %0 + load (2.343749e-01) from %"class.std::_Hashtable"* %0 + load (9.999995e-01) from %"class.std::_Hashtable"* %0 + store (9.999995e-01) to %"class.std::_Hashtable"* %0 + Frequency of %"class.std::_Hashtable"* %0 + load: 1.634374e+01 store: 1.287499e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"struct.std::__detail::_Hash_node"* %3 + load: 3.749998e-01 store: 9.999995e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt10_HashtableIllSaIlENSt8__detail9_IdentityESt8equal_toIlESt4hashIlENS1_18_Mod_range_hashingENS1_20_Default_ranged_hashENS1_20_Prime_rehash_policyENS1_17_Hashtable_traitsILb0ELb1ELb1EEEE21_M_insert_unique_nodeEmmPNS1_10_Hash_nodeIlLb0EEE +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 4, !dbg !10268 + alias entry %6 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 4, i32 1, !dbg !10275 + alias entry %8 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 1, !dbg !10282 + alias entry %10 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 3, !dbg !10288 + alias entry %17 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 0 + alias entry %29 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 2, i32 0, !dbg !10428 + alias entry %30 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to %"struct.std::__detail::_Hash_node.61"**, !dbg !10429 + alias entry %32 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %29, i64 0, i32 0, !dbg !10432 + alias entry %35 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to i64* + base alias entry %44 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %28, i64 %43, !dbg !10469 + alias entry %61 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10489, !tbaa !10471 + alias entry %62 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %61, i64 0, i32 0, !dbg !10490 + alias entry %76 = bitcast %"class.std::_Hashtable.34"* %0 to i8**, !dbg !10510 + alias entry %82 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i8*, !dbg !10578 + alias entry %86 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 0, !dbg !10296 + alias entry %93 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, !dbg !10587 + alias entry %94 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i64*, !dbg !10588 + base alias entry %96 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %95, i64 0, i32 0, !dbg !10590 + alias entry %98 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 2, i32 0, !dbg !10599 + alias entry %99 = bitcast %"struct.std::__detail::_Hash_node_base"* %98 to i64*, !dbg !10600 + alias entry %101 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, !dbg !10601 + alias entry %102 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, i32 0, !dbg !10601 + alias entry %103 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i64*, !dbg !10602 + alias entry %104 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %98, i64 0, i32 0, !dbg !10605 + base alias entry %104 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %98, i64 0, i32 0, !dbg !10605 + base alias entry %113 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %84, i64 %112, !dbg !10630 + base alias entry %117 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %116, i64 %85, !dbg !10632 +Round 1 +Warning: the first offset is not constant + alias entry %45 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10469, !tbaa !10471 + alias entry %57 = bitcast %"struct.std::__detail::_Hash_node_base"* %45 to i64*, !dbg !10485 + base alias offset entry (0) %95 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %87, align 8, !dbg !10589, !tbaa !10471 +Warning: the first offset is not constant +Warning: the first offset is not constant +Round 2 +Warning: the first offset is not constant +Warning: the first offset is not constant +Warning: the first offset is not constant +Round end + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (5.000000e-01) from %"class.std::_Hashtable.34"* %0 + load (4.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + load (3.749996e+00) from %"class.std::_Hashtable.34"* %0 + store (3.749996e+00) to %"class.std::_Hashtable.34"* %0 + load (6.249994e+00) from %"class.std::_Hashtable.34"* %0 + store (6.249994e+00) to %"class.std::_Hashtable.34"* %0 + store (4.768372e-07) to %"class.std::_Hashtable.34"* %0 + load (4.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + store (6.249997e-01) to %"struct.std::__detail::_Hash_node.61"* %3 + load (3.749998e-01) from %"class.std::_Hashtable.34"* %0 + store (3.749998e-01) to %"struct.std::__detail::_Hash_node.61"* %3 + store (3.749998e-01) to %"class.std::_Hashtable.34"* %0 + load (3.749998e-01) from %"struct.std::__detail::_Hash_node.61"* %3 + load (2.343749e-01) from %"class.std::_Hashtable.34"* %0 + load (2.343749e-01) from %"class.std::_Hashtable.34"* %0 + load (9.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (9.999995e-01) to %"class.std::_Hashtable.34"* %0 + Frequency of %"class.std::_Hashtable.34"* %0 + load: 1.634374e+01 store: 1.287499e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"struct.std::__detail::_Hash_node.61"* %3 + load: 3.749998e-01 store: 9.999995e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI8CommInfoSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %7 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10273 + alias entry %8 = bitcast %struct.CommInfo** %7 to i64*, !dbg !10273 + alias entry %10 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10280 + alias entry %54 = bitcast %struct.CommInfo** %10 to i64*, !dbg !10394 + alias entry %55 = bitcast %"class.std::vector.52"* %0 to i64*, !dbg !10395 + alias entry %76 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %84 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10449 + alias entry %133 = bitcast %"class.std::vector.52"* %0 to i8**, !dbg !10651 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.52"* %0 + load (6.250000e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + load (1.953125e-01) from %"class.std::vector.52"* %0 + load (1.953125e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + store (3.125000e-01) to %"class.std::vector.52"* %0 + store (3.125000e-01) to %"class.std::vector.52"* %0 + Frequency of %"class.std::vector.52"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _GLOBAL__sub_I_main.cpp +Round 0 +Round end +On function .omp_offloading.descriptor_unreg +Round 0 +Round end + Frequency of i8* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_offloading.descriptor_reg.nvptx64-nvidia-cuda +Round 0 +Round end + ---- Identify Target Regions ---- + target call: %49 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396.region_id, i32 5, i8** nonnull %24, i8** nonnull %26, i64* nonnull %28, i64* getelementptr inbounds ([5 x i64], [5 x i64]* @.offload_maptypes.0, i64 0, i64 0), i32 0, i32 0), !dbg !10317 + target call: %24 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %9, i8** nonnull %11, i64* nonnull %13, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0), !dbg !10269 + target call: %26 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %11, i8** nonnull %13, i64* nonnull %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0), !dbg !10269 + target call: %258 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20.1, i64 0, i64 0), i32 0, i32 0) + to label %259 unwind label %319, !dbg !11559 + target call: %276 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368.region_id, i32 12, i8** nonnull %200, i8** nonnull %202, i64* nonnull %204, i64* getelementptr inbounds ([12 x i64], [12 x i64]* @.offload_maptypes.47.2, i64 0, i64 0), i32 0, i32 0), !dbg !11584 + target call: %325 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15.3, i64 0, i64 0), i32 0, i32 0) + to label %326 unwind label %319, !dbg !11667 + ---- Target Distance Calculation ---- +_Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi converges after 3 iterations +target 0: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 1: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 2: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 3: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 9.152967e+00) (4: 1.000095e+00) (5: 2.000190e+00) +target 4: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 8.152880e+00) (4: 9.091440e+00) (5: 1.000095e+00) +target 5: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 7.152791e+00) (4: 8.091353e+00) (5: 9.029914e+00) + ---- OMP (/tmp/main-7b3dc0.bc, powerpc64le-unknown-linux-gnu) ---- +new entry %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 +new entry %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 +new entry %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 +new entry %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 +new entry %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 +new entry %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 +new entry %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 +new entry %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 +new entry %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 +Round 0 + base alias entry %130 = bitcast i64** %29 to i8**, !dbg !11450 + base alias entry %142 = bitcast i64** %30 to i8**, !dbg !11479 + alias entry %147 = bitcast i8* %145 to %struct.Comm*, !dbg !11487 + alias entry %158 = bitcast i8* %156 to double*, !dbg !11511 + base alias entry %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias entry %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 + base alias entry %192 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 2 + base alias entry %193 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 2 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias entry %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias entry %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias entry %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias entry %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias entry %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias entry %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias entry %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias entry %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias entry %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias entry %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias entry %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias entry %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias entry %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias entry %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 +Warning: reach to function declaration __kmpc_fork_teams + alias entry (func arg) %struct.Comm* %1 + alias entry (func arg) double* %2 +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 1 +Round 1 + base alias entry %35 = bitcast i8** %34 to double**, !dbg !10317 + base alias entry %37 = bitcast i8** %36 to double**, !dbg !10317 + base alias entry %45 = bitcast i8** %44 to %struct.Comm**, !dbg !10317 + base alias entry %47 = bitcast i8** %46 to %struct.Comm**, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %29 = alloca i64*, align 8 + base alias entry %30 = alloca i64*, align 8 + base alias offset entry (1) %16 = alloca [3 x i8*], align 8 + base alias offset entry (1) %17 = alloca [3 x i8*], align 8 + base alias offset entry (2) %16 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %192 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 2 + base alias offset entry (2) %17 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %193 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 2 + base alias offset entry (1) %31 = alloca [12 x i8*], align 8 + base alias offset entry (1) %32 = alloca [12 x i8*], align 8 + base alias offset entry (2) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (2) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-2) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (-1) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (3) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-2) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (-1) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (-3) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-2) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-1) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-3) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-2) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-1) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-4) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-3) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-2) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-4) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-3) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-2) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (6) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-5) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-4) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-3) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (6) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-5) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-4) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-3) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (7) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-6) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-5) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-4) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-1) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (7) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-6) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-5) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-4) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-1) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (8) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-7) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-6) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-5) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-2) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-1) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (8) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-7) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-6) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-5) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-2) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-1) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-8) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-7) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-6) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-3) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-2) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-1) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-8) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-7) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-6) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-3) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-2) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-1) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (10) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-9) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-8) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-7) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-4) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-3) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-2) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (10) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-9) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-8) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-7) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-4) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-3) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-2) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-10) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-9) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-8) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-5) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-4) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-3) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-1) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-10) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-9) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-8) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-5) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-4) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-3) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-1) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams + alias entry %263 = load i64*, i64** %29, align 8, !dbg !11584, !tbaa !11451 + alias entry %264 = load i64*, i64** %30, align 8, !dbg !11584, !tbaa !11451 + alias entry %274 = ptrtoint i64* %263 to i64, !dbg !11584 + alias entry %275 = ptrtoint i64* %264 to i64, !dbg !11584 + base alias entry %215 = bitcast i8** %214 to i64* + base alias entry %217 = bitcast i8** %216 to i64* + base alias entry %220 = bitcast i8** %219 to i64* + base alias entry %222 = bitcast i8** %221 to i64* +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 2 +Warning: reach to function declaration __kmpc_fork_call +Round 2 + base alias entry %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias entry %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias entry %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias entry %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (2) %11 = alloca [5 x i8*], align 8 + base alias offset entry (2) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (-1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 + base alias offset entry (4) %11 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias offset entry (4) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %126 = bitcast i64** %29 to i8*, !dbg !11447 + base alias entry %139 = bitcast i64** %30 to i8*, !dbg !11477 + base alias offset entry (1) %184 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 0 + base alias offset entry (2) %184 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 0 + base alias offset entry (1) %186 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 0 + base alias offset entry (2) %186 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 0 + base alias offset entry (1) %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias offset entry (1) %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 + base alias offset entry (1) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (2) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (3) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (6) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (7) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (8) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (10) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (1) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (2) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (3) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (6) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (7) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (8) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (10) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (1) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (2) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (5) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (6) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (7) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (9) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (1) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (2) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (5) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (6) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (7) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (9) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (1) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (4) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (5) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (6) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (8) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (1) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (4) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (5) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (6) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (8) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (4) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (5) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (7) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (3) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (4) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (5) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (7) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (2) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (3) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (4) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (6) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias entry %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (2) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (3) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (4) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (6) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias entry %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (1) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (2) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (3) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (5) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias entry %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (1) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (2) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (3) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (5) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias entry %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (1) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (2) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (4) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (1) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (2) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (4) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (1) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (3) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (1) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (3) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (2) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (2) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (1) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (1) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 3 +Warning: reach to function declaration __kmpc_fork_call +Round 3 + base alias offset entry (4) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (4) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (3) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (3) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (2) %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias offset entry (2) %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias offset entry (1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (4) %31 = alloca [12 x i8*], align 8 + base alias offset entry (4) %32 = alloca [12 x i8*], align 8 + base alias offset entry (5) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (5) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-2) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-1) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-2) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-1) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-3) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-2) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-3) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-2) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-4) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-3) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-4) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-3) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-5) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-4) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-5) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-4) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-6) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-5) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-6) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-5) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-7) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-6) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-7) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-6) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 4 +Warning: reach to function declaration __kmpc_fork_call +Round 4 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (4) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (5) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (4) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (5) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (3) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (4) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (3) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (4) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (2) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (3) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (2) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (1) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (2) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (1) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (2) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (1) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (1) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 5 +Warning: reach to function declaration __kmpc_fork_call +Round 5 +Warning: reach to function declaration __kmpc_fork_teams +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 6 +Warning: reach to function declaration __kmpc_fork_call +Round 6 +Warning: reach to function declaration __kmpc_fork_teams +Round end + ---- Access Frequency Analysis ---- + target call (1.625206e+01, 0.000000e+00, 5.076920e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625206e+01, 0.000000e+00, 1.015380e+01) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + target call (1.625204e+01, 1.015380e+01, 0.000000e+00) using %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + target call (1.625204e+01, 5.076920e+00, 0.000000e+00) using %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + target call (1.625204e+01, 8.757690e+01, 0.000000e+00) using %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + target call (1.625204e+01, 4.569230e+01, 0.000000e+00) using %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + target call (1.625204e+01, 0.000000e+00, 5.076920e+00) using %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + target call (1.625204e+01, 3.807690e+00, 0.000000e+00) using %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + target call (1.625204e+01, 1.078710e+02, 0.000000e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625204e+01, 2.538460e+00, 0.000000e+00) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + target call (1.625204e+01, 2.538460e+00, 2.538460e+00) using %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + target call (1.625202e+01, 1.015380e+01, 1.015380e+01) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625202e+01, 1.015380e+01, 0.000000e+00) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + call (1.625199e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + call (1.625199e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 +Frequency of %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.650200e+02 store: 0.000000e+00 (target) +Frequency of %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 8.251031e+01 store: 0.000000e+00 (target) +Frequency of %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.423303e+03 store: 0.000000e+00 (target) +Frequency of %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 7.425931e+02 store: 0.000000e+00 (target) +Frequency of %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 6.188273e+01 store: 0.000000e+00 (target) +Frequency of %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 8.251031e+01 (target) +Frequency of %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.918144e+03 store: 2.475302e+02 (target) +Frequency of %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 2.062750e+02 store: 1.650201e+02 (target) +Frequency of %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 4.125515e+01 store: 4.125515e+01 (target) + ---- Optimization Preparation ---- +Rank 9 for %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 6.188273e+01 store: 0.000000e+00 (target) +Rank 8 for %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 8.251031e+01 store: 0.000000e+00 (target) +Rank 7 for %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 8.251031e+01 (target) +Rank 6 for %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 4.125515e+01 store: 4.125515e+01 (target) +Rank 5 for %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.650200e+02 store: 0.000000e+00 (target) +Rank 4 for %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 2.062750e+02 store: 1.650201e+02 (target) +Rank 3 for %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 7.425931e+02 store: 0.000000e+00 (target) +Rank 2 for %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.423303e+03 store: 0.000000e+00 (target) +Rank 1 for %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.918144e+03 store: 2.475302e+02 (target) + ---- Data Mapping Optimization ---- + target call: %49 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396.region_id, i32 5, i8** nonnull %24, i8** nonnull %26, i64* nonnull %28, i64* getelementptr inbounds ([5 x i64], [5 x i64]* @.offload_maptypes.0, i64 0, i64 0), i32 0, i32 0), !dbg !10317 +@.offload_maptypes.0 = private unnamed_addr constant [5 x i64] [i64 800, i64 547, i64 1100853829665, i64 547, i64 1102195986465] + arg 2 (0.000000e+00, 0.000000e+00; 4.125515e+01, 4.125515e+01) is %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x06 + local reuse is 1.600380e+02, 1.280304e+03 after adjustment; scaled local reuse is 0x500 + reuse distance is 0x01 + arg 4 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 1.600380e+02, 2.560608e+03 after adjustment; scaled local reuse is 0xa00 + reuse distance is 0x01 + target call: %24 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %9, i8** nonnull %11, i64* nonnull %13, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0), !dbg !10269 +@.offload_maptypes.15 = private unnamed_addr constant [3 x i64] [i64 800, i64 35, i64 33] + target call: %26 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %11, i8** nonnull %13, i64* nonnull %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0), !dbg !10269 +@.offload_maptypes.20 = private unnamed_addr constant [3 x i64] [i64 800, i64 34, i64 34] + target call: %258 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20.1, i64 0, i64 0), i32 0, i32 0) + to label %259 unwind label %319, !dbg !11559 +@.offload_maptypes.20.1 = private unnamed_addr constant [3 x i64] [i64 800, i64 1099553574946, i64 1099681513506] + arg 1 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x01 + arg 2 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 1.015380e+01, 1.624608e+02 after adjustment; scaled local reuse is 0x0a2 + reuse distance is 0x01 + target call: %276 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368.region_id, i32 12, i8** nonnull %200, i8** nonnull %202, i64* nonnull %204, i64* getelementptr inbounds ([12 x i64], [12 x i64]* @.offload_maptypes.47.2, i64 0, i64 0), i32 0, i32 0), !dbg !11584 +@.offload_maptypes.47.2 = private unnamed_addr constant [12 x i64] [i64 800, i64 9895689605153, i64 9895646625825, i64 9897073713185, i64 9895987392545, i64 9895646621730, i64 9895636144161, i64 1101320425505, i64 1099553587235, i64 800, i64 9895646617635, i64 800] + arg 1 (0.000000e+00, 0.000000e+00; 1.650200e+02, 0.000000e+00) is %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + size is %90 = sub i64 %87, %89, !dbg !11386 + global reuse is 0x05 + local reuse is 1.015380e+01, 8.123040e+01 after adjustment; scaled local reuse is 0x051 + reuse distance is 0x09 + arg 2 (0.000000e+00, 0.000000e+00; 8.251031e+01, 0.000000e+00) is %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + size is %104 = sub i64 %101, %103, !dbg !11404 + global reuse is 0x08 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + arg 3 (0.000000e+00, 0.000000e+00; 1.423303e+03, 0.000000e+00) is %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + size is %118 = sub i64 %115, %117, !dbg !11430 + global reuse is 0x02 + local reuse is 8.757690e+01, 1.401230e+03 after adjustment; scaled local reuse is 0x579 + reuse distance is 0x09 + arg 4 (0.000000e+00, 0.000000e+00; 7.425931e+02, 0.000000e+00) is %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x03 + local reuse is 4.569230e+01, 3.655384e+02 after adjustment; scaled local reuse is 0x16d + reuse distance is 0x09 + arg 5 (0.000000e+00, 0.000000e+00; 0.000000e+00, 8.251031e+01) is %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x07 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + arg 6 (0.000000e+00, 0.000000e+00; 6.188273e+01, 0.000000e+00) is %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x09 + local reuse is 3.807690e+00, 3.046152e+01 after adjustment; scaled local reuse is 0x01e + reuse distance is 0x09 + arg 7 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 1.078710e+02, 1.725936e+03 after adjustment; scaled local reuse is 0x6bd + reuse distance is 0x01 + arg 8 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 2.538460e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x01 + arg 10 (0.000000e+00, 0.000000e+00; 4.125515e+01, 4.125515e+01) is %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x06 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + target call: %325 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15.3, i64 0, i64 0), i32 0, i32 0) + to label %326 unwind label %319, !dbg !11667 +@.offload_maptypes.15.3 = private unnamed_addr constant [3 x i64] [i64 800, i64 7696921137187, i64 7696751280161] + arg 1 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 2.030760e+01, 3.249216e+02 after adjustment; scaled local reuse is 0x144 + reuse distance is 0x07 + arg 2 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 1.015380e+01, 1.624608e+02 after adjustment; scaled local reuse is 0x0a2 + reuse distance is 0x07 +mpicxx main.o -O3 -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda -DOMP_GPU -DOMP_GPU_ALLOC -DCHECK_NUM_EDGES -o miniVite diff --git a/miniVite/logcmplll b/miniVite/logcmplll new file mode 100644 index 0000000..2c49c24 --- /dev/null +++ b/miniVite/logcmplll @@ -0,0 +1,5651 @@ +mpicxx -std=c++11 -g -O3 -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda -DOMP_GPU -DOMP_GPU_ALLOC -DCHECK_NUM_EDGES -Xclang -load -Xclang ~/git/unifiedmem/code/llvm-pass/build/uvm/libOMPPass.so -emit-llvm -S -c -o main.ll main.cpp +In file included from main.cpp:58: +In file included from ./dspl_gpu_kernel.hpp:58: +In file included from ./graph.hpp:56: +./utils.hpp:263:56: warning: using floating point absolute value function 'fabs' when argument is of integer type [-Wabsolute-value] + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult); // 0-1 + ^ +./utils.hpp:263:56: note: use function 'std::abs' instead + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult); // 0-1 + ^~~~ + std::abs + ---- Function Argument Access Frequency CG Analysis ---- +On function _Z7is_pwr2i +Round 0 +Round end +On function _Z8reseederj +Round 0 +Round end +On function _ZNSt8seed_seq8generateIN9__gnu_cxx17__normal_iteratorIPjSt6vectorIjSaIjEEEEEEvT_S8_ +Round 0 + alias entry %18 = getelementptr inbounds %"class.std::seed_seq", %"class.std::seed_seq"* %0, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !10369 + alias entry %19 = bitcast i32** %18 to i64*, !dbg !10369 + alias entry %21 = bitcast %"class.std::seed_seq"* %0 to i64*, !dbg !10376 +Round 1 +Round end + load (6.274510e-01) from %"class.std::seed_seq"* %0 + load (6.274510e-01) from %"class.std::seed_seq"* %0 + Frequency of %"class.std::seed_seq"* %0 + load: 1.254902e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z4lockv +Round 0 +Round end +On function _Z6unlockv +Round 0 +Round end +On function _Z19distSumVertexDegreeRK5GraphRSt6vectorIdSaIdEERS2_I4CommSaIS6_EE +Round 0 + alias entry %6 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10459 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __clang_call_terminate +Round 0 +Round end + Frequency of i8* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined. +Round 0 + alias entry %25 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 0, i32 0, i32 0, i32 0 + alias entry %26 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 1, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (6.350000e+00) from %class.Graph* %3 + load (6.350000e+00) from %class.Graph* %3 + load (6.350000e+00) from %"class.std::vector.10"* %4 + load (6.350000e+00) from %"class.std::vector.15"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %class.Graph* %3 + load: 1.270000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %4 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %5 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z29distCalcConstantForSecondTermRKSt6vectorIdSaIdEEP19ompi_communicator_t +Round 0 + alias entry %9 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10283 + alias entry %10 = bitcast double** %9 to i64*, !dbg !10283 + alias entry %12 = bitcast %"class.std::vector.10"* %0 to i64*, !dbg !10288 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.10"* %0 + load (1.000000e+00) from %"class.std::vector.10"* %0 + Frequency of %"class.std::vector.10"* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.ompi_communicator_t* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..2 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %102 = bitcast double* %3 to i64*, !dbg !10325 +Round 1 +Round end + load (3.157895e-01) from %"class.std::vector.10"* %4 + load (2.105263e-01) from double* %3 + store (2.105263e-01) to double* %3 + load (2.105263e-01) from double* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z12distInitCommRSt6vectorIlSaIlEES2_l +Round 0 + alias entry %6 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10273 + alias entry %7 = bitcast i64** %6 to i64*, !dbg !10273 + alias entry %9 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10280 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.0"* %1 + load (1.000000e+00) from %"class.std::vector.0"* %1 + Frequency of %"class.std::vector.0"* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..4 +Round 0 + alias entry %29 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %31 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from %"class.std::vector.0"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %5 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z15distInitLouvainRK5GraphRSt6vectorIlSaIlEES5_RS2_IdSaIdEES8_RS2_I4CommSaIS9_EESC_Rdi +Round 0 + alias entry %16 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !10485 + alias entry %20 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10502 + alias entry %22 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10514 + alias entry %24 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %3, i64 0, i32 0, i32 0, i32 1, !dbg !10532 + alias entry %25 = bitcast double** %24 to i64*, !dbg !10532 + alias entry %27 = bitcast %"class.std::vector.10"* %3 to i64*, !dbg !10536 + alias entry %40 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10572 + alias entry %41 = bitcast i64** %40 to i64*, !dbg !10572 + alias entry %43 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10574 + alias entry %56 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %2, i64 0, i32 0, i32 0, i32 1, !dbg !10600 + alias entry %57 = bitcast i64** %56 to i64*, !dbg !10600 + alias entry %59 = bitcast %"class.std::vector.0"* %2 to i64*, !dbg !10601 + alias entry %72 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 1, !dbg !10622 + alias entry %73 = bitcast double** %72 to i64*, !dbg !10622 + alias entry %75 = bitcast %"class.std::vector.10"* %4 to i64*, !dbg !10623 + alias entry %88 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %5, i64 0, i32 0, i32 0, i32 1, !dbg !10654 + alias entry %89 = bitcast %struct.Comm** %88 to i64*, !dbg !10654 + alias entry %91 = bitcast %"class.std::vector.15"* %5 to i64*, !dbg !10658 + alias entry %104 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %6, i64 0, i32 0, i32 0, i32 1, !dbg !10685 + alias entry %105 = bitcast %struct.Comm** %104 to i64*, !dbg !10685 + alias entry %107 = bitcast %"class.std::vector.15"* %6 to i64*, !dbg !10686 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %"class.std::vector.10"* %3 + load (1.000000e+00) from %"class.std::vector.10"* %3 +Warning: wrong traversal order, or recursive call +On function _Z15distGetMaxIndexP7clmap_tRiPdS1_dPK4Commdldllld +Round 0 + alias entry %22 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 %21 + alias entry %28 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 0, !dbg !10320 + alias entry %33 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 1, !dbg !10330 + alias entry %35 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 0, !dbg !10333 + alias entry %37 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 1, !dbg !10335 + alias entry %41 = getelementptr inbounds double, double* %2, i64 %38, !dbg !10340 + alias entry %60 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 1, !dbg !10352 + alias entry %81 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %80, i32 1, !dbg !10330 + alias entry %83 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %80, i32 0, !dbg !10333 + alias entry %89 = getelementptr inbounds double, double* %2, i64 %86, !dbg !10340 + alias entry %126 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %125, i32 1, !dbg !10330 + alias entry %128 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %125, i32 0, !dbg !10333 + alias entry %134 = getelementptr inbounds double, double* %2, i64 %131, !dbg !10340 +Round 1 +Round end + load (1.000000e+00) from double* %2 + load (1.000000e+00) from i32* %3 + load (1.000000e+00) from i32* %1 + load (5.000000e-01) from %struct.clmap_t* %0 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.clmap_t* %0 + load (1.250000e-01) from double* %2 + load (9.984375e+00) from %struct.Comm* %5 + load (9.984375e+00) from %struct.Comm* %5 + load (4.984375e+00) from double* %2 + load (9.984375e+00) from %struct.Comm* %5 + load (9.984375e+00) from %struct.Comm* %5 + load (4.984375e+00) from double* %2 + Frequency of %struct.clmap_t* %0 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 1.109375e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 4.043750e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z24distBuildLocalMapCounterllP7clmap_tRiPdS1_PK4EdgePKllll +Round 0 + alias entry %21 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %20, i32 0, !dbg !10308 + alias entry %22 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %20, i32 1, !dbg !10310 + alias entry %31 = getelementptr inbounds i64, i64* %7, i64 %30, !dbg !10326 + alias entry %39 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %37, i32 0, !dbg !10337 + alias entry %48 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %35, !dbg !10348 + alias entry %58 = getelementptr inbounds double, double* %4, i64 %52, !dbg !10358 + alias entry %64 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %35, i32 0, !dbg !10364 + alias entry %65 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %35, i32 1, !dbg !10367 + alias entry %71 = bitcast double* %22 to i64*, !dbg !10375 + alias entry %74 = getelementptr inbounds double, double* %4, i64 %73, !dbg !10377 + alias entry %75 = bitcast double* %74 to i64*, !dbg !10378 +Round 1 +Round end + load (1.593750e+01) from %struct.Edge* %6 + load (7.937500e+00) from %struct.Edge* %6 + load (1.593750e+01) from i64* %7 + load (1.593750e+01) from i32* %3 + load (1.625000e+02) from %struct.clmap_t* %2 + load (9.937500e+00) from i32* %5 + load (4.937500e+00) from %struct.Edge* %6 + load (4.937500e+00) from double* %4 + store (4.937500e+00) to double* %4 + store (5.437500e+00) to %struct.clmap_t* %2 + store (5.437500e+00) to %struct.clmap_t* %2 + store (5.437500e+00) to i32* %3 + load (1.093750e+01) from i32* %5 + load (5.437500e+00) from %struct.Edge* %6 + store (5.437500e+00) to double* %4 + store (5.437500e+00) to i32* %5 + Frequency of %struct.clmap_t* %2 + load: 1.625000e+02 store: 1.087500e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.593750e+01 store: 5.437500e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 4.937500e+00 store: 1.037500e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %5 + load: 2.087500e+01 store: 5.437500e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %6 + load: 3.425000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 1.593750e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z27distExecuteLouvainIterationlPKlS0_PK4EdgeS0_PlPKdP4CommS8_dPdi +Round 0 + alias entry %18 = getelementptr inbounds i64, i64* %2, i64 %17, !dbg !10316 + alias entry %20 = getelementptr inbounds i64, i64* %4, i64 %0, !dbg !10322 + alias entry %23 = getelementptr inbounds i64, i64* %1, i64 %0, !dbg !10329 + alias entry %26 = getelementptr inbounds i64, i64* %1, i64 %25, !dbg !10332 + alias entry %30 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %22, i32 0, !dbg !10337 + alias entry %32 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %22, i32 1, !dbg !10341 + alias entry %47 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %46, i32 0, !dbg !10401 + alias entry %48 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %46, i32 1, !dbg !10403 + alias entry %57 = getelementptr inbounds i64, i64* %4, i64 %56, !dbg !10414 + alias entry %95 = bitcast double* %48 to i64*, !dbg !10457 + alias entry %118 = getelementptr inbounds double, double* %10, i64 %0, !dbg !10470 + alias entry %122 = getelementptr inbounds double, double* %6, i64 %0, !dbg !10473 + alias entry %140 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %139, i32 1, !dbg !10533 + alias entry %142 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %139, i32 0, !dbg !10534 + alias entry %188 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %187, i32 1, !dbg !10533 + alias entry %190 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %187, i32 0, !dbg !10534 + alias entry %236 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %235, i32 1, !dbg !10572 + alias entry %237 = bitcast double* %236 to i64*, !dbg !10573 + alias entry %248 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %235, i32 0, !dbg !10575 + alias entry %250 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %22, i32 1, !dbg !10578 + alias entry %252 = bitcast double* %250 to i64*, !dbg !10581 + alias entry %263 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %22, i32 0, !dbg !10583 + alias entry %267 = getelementptr inbounds i64, i64* %5, i64 %0, !dbg !10587 + alias entry %270 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %269, i32 1, !dbg !10533 + alias entry %272 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %269, i32 0, !dbg !10534 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (1.000000e+00) from i64* %4 + load (1.000000e+00) from i64* %1 + load (1.000000e+00) from i64* %1 + load (5.000000e-01) from %struct.Comm* %7 + load (5.000000e-01) from %struct.Comm* %7 + load (7.992188e+00) from %struct.Edge* %3 + load (3.992188e+00) from %struct.Edge* %3 + load (7.992188e+00) from i64* %4 + load (2.492188e+00) from %struct.Edge* %3 + load (2.742188e+00) from %struct.Edge* %3 + load (5.000000e-01) from double* %10 + store (5.000000e-01) to double* %10 + load (5.000000e-01) from double* %6 + load (1.250000e-01) from %struct.Comm* %7 + load (1.250000e-01) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + load (2.500000e-01) from %struct.Comm* %8 + load (2.500000e-01) from double* %6 + load (2.500000e-01) from %struct.Comm* %8 + store (1.000000e+00) to i64* %5 + load (4.992188e+00) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + Frequency of i64* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %3 + load: 1.721875e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 8.992188e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 0.000000e+00 store: 1.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %7 + load: 2.121875e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 5.000000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 5.000000e-01 store: 5.000000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z21distComputeModularityRK5GraphP4CommPKddi +Round 0 + alias entry %14 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10288 + alias entry %16 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10304 + base alias entry %35 = bitcast i8** %34 to double**, !dbg !10317 + base alias entry %37 = bitcast i8** %36 to double**, !dbg !10317 + base alias entry %45 = bitcast i8** %44 to %struct.Comm**, !dbg !10317 + base alias entry %47 = bitcast i8** %46 to %struct.Comm**, !dbg !10317 +Round 1 + base alias entry %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias entry %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias entry %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias entry %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Round 2 + base alias offset entry (2) %11 = alloca [5 x i8*], align 8 + base alias offset entry (2) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (-1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 + base alias offset entry (4) %11 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias offset entry (4) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Round 3 + base alias offset entry (4) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (4) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (3) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (3) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (2) %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias offset entry (2) %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias offset entry (1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 +Round 4 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.7 +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to double**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..8 +Round 0 + alias entry %40 = getelementptr inbounds double, double* %6, i64 %39, !dbg !10318 + alias entry %43 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %39, i32 1, !dbg !10321 + alias entry %63 = bitcast double* %5 to i64*, !dbg !10329 + alias entry %75 = bitcast double* %7 to i64*, !dbg !10329 +Round 1 +Round end + load (1.010526e+01) from double* %6 + load (1.010526e+01) from %struct.Comm* %8 + load (2.105263e-01) from double* %5 + store (2.105263e-01) to double* %5 + load (2.105263e-01) from double* %7 + store (2.105263e-01) to double* %7 + load (2.105263e-01) from double* %5 + load (2.105263e-01) from double* %7 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 1.010526e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %7 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 1.010526e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.9 +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to double**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..10 +Round 0 + alias entry %67 = bitcast double* %3 to i64*, !dbg !10310 + alias entry %79 = bitcast double* %5 to i64*, !dbg !10310 +Round 1 +Round end + load (2.916667e-01) from double* %3 + store (2.916667e-01) to double* %3 + load (2.916667e-01) from double* %5 + store (2.916667e-01) to double* %5 + load (3.333333e-01) from double* %3 + load (3.333333e-01) from double* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 6.250000e-01 store: 2.916667e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 6.250000e-01 store: 2.916667e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z20distUpdateLocalCinfolP4CommPKS_ +Round 0 + base alias entry %15 = bitcast i8** %14 to %struct.Comm**, !dbg !10269 + base alias entry %17 = bitcast i8** %16 to %struct.Comm**, !dbg !10269 + base alias entry %20 = bitcast i8** %19 to %struct.Comm**, !dbg !10269 + base alias entry %22 = bitcast i8** %21 to %struct.Comm**, !dbg !10269 +Round 1 + base alias entry %14 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias entry %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 + base alias entry %19 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias entry %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 2 + base alias offset entry (1) %5 = alloca [3 x i8*], align 8 + base alias offset entry (1) %6 = alloca [3 x i8*], align 8 + base alias offset entry (2) %5 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %19 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias offset entry (2) %6 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 3 + base alias offset entry (1) %9 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %9 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %14 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias offset entry (1) %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 +Round 4 +Round end + Frequency of %struct.Comm* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..13 +Round 0 + alias entry %33 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %26, !dbg !10304 + alias entry %36 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %35, i32 1, !dbg !10304 + alias entry %37 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %26, !dbg !10304 + alias entry %38 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %35, i32 1, !dbg !10304 + alias entry %39 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %26, i32 1, !dbg !10304 + alias entry %41 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %40, !dbg !10304 + alias entry %42 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %26, i32 1, !dbg !10304 + alias entry %43 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %40, !dbg !10304 + alias entry %44 = bitcast double* %38 to %struct.Comm*, !dbg !10304 + alias entry %46 = bitcast double* %36 to %struct.Comm*, !dbg !10304 + alias entry %49 = bitcast %struct.Comm* %43 to double*, !dbg !10304 + alias entry %51 = bitcast %struct.Comm* %41 to double*, !dbg !10304 + alias entry %67 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %61, i32 0, !dbg !10304 + alias entry %68 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %62, i32 0, !dbg !10304 + alias entry %69 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %63, i32 0, !dbg !10304 + alias entry %70 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %64, i32 0, !dbg !10304 + alias entry %71 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %65, i32 0, !dbg !10304 + alias entry %72 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %66, i32 0, !dbg !10304 + alias entry %73 = bitcast i64* %67 to <4 x i64>*, !dbg !10304 + alias entry %74 = bitcast i64* %68 to <4 x i64>*, !dbg !10304 + alias entry %75 = bitcast i64* %69 to <4 x i64>*, !dbg !10304 + alias entry %76 = bitcast i64* %70 to <4 x i64>*, !dbg !10304 + alias entry %77 = bitcast i64* %71 to <4 x i64>*, !dbg !10304 + alias entry %78 = bitcast i64* %72 to <4 x i64>*, !dbg !10304 + alias entry %97 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %61, i32 0, !dbg !10307 + alias entry %98 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %62, i32 0, !dbg !10307 + alias entry %99 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %63, i32 0, !dbg !10307 + alias entry %100 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %64, i32 0, !dbg !10307 + alias entry %101 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %65, i32 0, !dbg !10307 + alias entry %102 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %66, i32 0, !dbg !10307 + alias entry %103 = bitcast i64* %97 to <4 x i64>*, !dbg !10307 + alias entry %104 = bitcast i64* %98 to <4 x i64>*, !dbg !10307 + alias entry %105 = bitcast i64* %99 to <4 x i64>*, !dbg !10307 + alias entry %106 = bitcast i64* %100 to <4 x i64>*, !dbg !10307 + alias entry %107 = bitcast i64* %101 to <4 x i64>*, !dbg !10307 + alias entry %108 = bitcast i64* %102 to <4 x i64>*, !dbg !10307 + alias entry %139 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %61, i32 1, !dbg !10309 + alias entry %140 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %62, i32 1, !dbg !10309 + alias entry %141 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %63, i32 1, !dbg !10309 + alias entry %142 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %64, i32 1, !dbg !10309 + alias entry %143 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %65, i32 1, !dbg !10309 + alias entry %144 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %66, i32 1, !dbg !10309 + alias entry %151 = getelementptr inbounds double, double* %139, i64 -1, !dbg !10309 + alias entry %152 = bitcast double* %151 to <4 x double>*, !dbg !10309 + alias entry %153 = getelementptr inbounds double, double* %140, i64 -1, !dbg !10309 + alias entry %154 = bitcast double* %153 to <4 x double>*, !dbg !10309 + alias entry %155 = getelementptr inbounds double, double* %141, i64 -1, !dbg !10309 + alias entry %156 = bitcast double* %155 to <4 x double>*, !dbg !10309 + alias entry %157 = getelementptr inbounds double, double* %142, i64 -1, !dbg !10309 + alias entry %158 = bitcast double* %157 to <4 x double>*, !dbg !10309 + alias entry %159 = getelementptr inbounds double, double* %143, i64 -1, !dbg !10309 + alias entry %160 = bitcast double* %159 to <4 x double>*, !dbg !10309 + alias entry %161 = getelementptr inbounds double, double* %144, i64 -1, !dbg !10309 + alias entry %162 = bitcast double* %161 to <4 x double>*, !dbg !10309 + alias entry %183 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %182, i32 0, !dbg !10304 + alias entry %185 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %182, i32 0, !dbg !10307 + alias entry %188 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %182, i32 1, !dbg !10318 + alias entry %190 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %182, i32 1, !dbg !10309 +Round 1 +Round end + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + load (9.088235e+00) from %struct.Comm* %6 + load (9.088235e+00) from %struct.Comm* %5 + store (9.088235e+00) to %struct.Comm* %5 + load (9.088235e+00) from %struct.Comm* %6 + load (9.088235e+00) from %struct.Comm* %5 + store (9.088235e+00) to %struct.Comm* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 3.317647e+01 store: 3.317647e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 3.317647e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..14 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z16distCleanCWandCUlPdP4Comm +Round 0 + base alias entry %17 = bitcast i8** %16 to double**, !dbg !10269 + base alias entry %19 = bitcast i8** %18 to double**, !dbg !10269 + base alias entry %22 = bitcast i8** %21 to %struct.Comm**, !dbg !10269 + base alias entry %24 = bitcast i8** %23 to %struct.Comm**, !dbg !10269 +Round 1 + base alias entry %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias entry %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 + base alias entry %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias entry %23 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 2 + base alias offset entry (1) %5 = alloca [3 x i8*], align 8 + base alias offset entry (1) %6 = alloca [3 x i8*], align 8 + base alias offset entry (2) %5 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias offset entry (2) %6 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %23 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 3 + base alias offset entry (1) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %13 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %13 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias offset entry (1) %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 +Round 4 +Round end + Frequency of double* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..18 +Round 0 + alias entry %30 = getelementptr inbounds double, double* %5, i64 %29, !dbg !10304 + alias entry %31 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %29, i32 0, !dbg !10309 + alias entry %34 = bitcast i64* %31 to i8*, !dbg !10299 +Round 1 +Round end + store (1.058333e+01) to double* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 0.000000e+00 store: 1.058333e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..19 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z21fillRemoteCommunitiesRK5GraphiiRKmS3_RKSt6vectorIlSaIlEES8_S8_S8_S8_RKS4_I4CommSaIS9_EERSt3mapIlS9_St4lessIlESaISt4pairIKlS9_EEERSt13unordered_mapIllSt4hashIlESt8equal_toIlESaISH_ISI_lEEESM_ +Round 0 + alias entry %126 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !11433 + alias entry %130 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !11449 + alias entry %132 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !11460 + alias entry %190 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 + alias entry %197 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 + alias entry %301 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 2, i32 0, !dbg !11792 + alias entry %302 = bitcast %"struct.std::__detail::_Hash_node_base"* %301 to %"struct.std::__detail::_Hash_node"**, !dbg !11793 + alias entry %312 = bitcast %"class.std::unordered_map"* %12 to i8**, !dbg !11836 + alias entry %314 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 1, !dbg !11842 + alias entry %317 = bitcast %"struct.std::__detail::_Hash_node_base"* %301 to i8*, !dbg !11846 + alias entry %320 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %8, i64 0, i32 0, i32 0, i32 0 + alias entry %321 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0 + alias entry %322 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 0 + alias entry %323 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %324 = bitcast %"class.std::vector.0"* %323 to i64* + alias entry %325 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %326 = bitcast i64** %325 to i64* + alias entry %330 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %9, i64 0, i32 0, i32 0, i32 0 + alias entry %331 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %332 = bitcast %"class.std::vector.0"* %331 to i64* + alias entry %333 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %334 = bitcast i64** %333 to i64* + alias entry %818 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, !dbg !13393 + alias entry %819 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 1, !dbg !13405 + alias entry %820 = bitcast %"struct.std::_Rb_tree_node_base"** %819 to %"struct.std::_Rb_tree_node"**, !dbg !13405 + alias entry %826 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, !dbg !13419 + alias entry %827 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13425 + base alias entry %827 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13425 + alias entry %828 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13435 + base alias entry %828 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13435 + alias entry %829 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 2, !dbg !13437 + alias entry %830 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, !dbg !13442 + alias entry %831 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 1, !dbg !13447 + alias entry %832 = bitcast %"struct.std::_Rb_tree_node_base"** %831 to %"struct.std::_Rb_tree_node"**, !dbg !13447 + alias entry %838 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, !dbg !13452 + alias entry %839 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13455 + base alias entry %839 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13455 + alias entry %840 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13462 + base alias entry %840 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13462 + alias entry %841 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 2, !dbg !13464 + alias entry %846 = bitcast %"struct.std::_Rb_tree_node_base"** %819 to i64* + alias entry %848 = bitcast %"struct.std::_Rb_tree_node_base"* %826 to %"struct.std::_Rb_tree_node"* + alias entry %850 = bitcast %"struct.std::_Rb_tree_node_base"** %831 to i64* + alias entry %852 = bitcast %"struct.std::_Rb_tree_node_base"* %838 to %"struct.std::_Rb_tree_node"* + alias entry %967 = load %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"** %827, align 8, !dbg !14017, !tbaa !14018 + alias entry %1023 = load %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"** %839, align 8, !dbg !14306, !tbaa !14018 +Round 1 +Round end + load (1.000000e+00) from i64* %4 + load (9.999994e-01) from i64* %3 + load (9.999963e-01) from %class.Graph* %0 + load (9.999963e-01) from %class.Graph* %0 + load (9.999963e-01) from %class.Graph* %0 + load (9.999803e+00) from %"class.std::vector.0"* %6 + load (1.999960e+01) from %"class.std::vector.0"* %6 + load (6.249782e+00) from %"class.std::vector.0"* %5 + load (1.249956e+01) from %"class.std::vector.0"* %5 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (1.999809e+01) from %"class.std::vector.0"* %8 + load (1.999807e+01) from %"class.std::unordered_map"* %12 + load (1.999807e+01) from %"class.std::unordered_map"* %12 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..22 +Round 0 + alias entry %31 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %33 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from %"class.std::vector.0"* %4 + load (3.200000e-01) from %"class.std::vector.0"* %6 + load (1.020000e+01) from i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 1.020000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %6 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.24 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..25 +Round 0 + alias entry %33 = getelementptr inbounds %"class.std::vector.29", %"class.std::vector.29"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.29"* %4 + load (3.157895e-01) from %"class.std::vector.0"* %3 + load (2.105263e-01) from i64* %5 + store (2.105263e-01) to i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.29"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.27 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..28 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..30 +Round 0 + alias entry %20 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %2, i64 0, i32 0, i32 0, i32 0, !dbg !10503 + alias entry %34 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %7, i64 0, i32 0, i32 0, i32 0 + alias entry %36 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.0"* %2 + load (2.047500e+02) from %"class.std::vector.0"* %4 + load (2.047500e+02) from %"class.std::vector.15"* %7 + load (2.047500e+02) from %"class.std::vector.52"* %6 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.52"* %6 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %7 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z22createCommunityMPITypev +Round 0 +Round end +On function _Z23destroyCommunityMPITypev +Round 0 +Round end +On function _Z23updateRemoteCommunitiesRK5GraphRSt6vectorI4CommSaIS3_EERKSt3mapIlS3_St4lessIlESaISt4pairIKlS3_EEEii +Round 0 + alias entry %19 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !10869 + alias entry %46 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !11050 + alias entry %48 = getelementptr inbounds %"class.std::map", %"class.std::map"* %2, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !11068 + alias entry %49 = bitcast %"struct.std::_Rb_tree_node_base"** %48 to i64*, !dbg !11068 + alias entry %51 = getelementptr inbounds %"class.std::map", %"class.std::map"* %2, i64 0, i32 0, i32 0, i32 1, !dbg !11085 + alias entry %55 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %56 = bitcast %"class.std::vector.0"* %55 to i64* + alias entry %57 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %58 = bitcast i64** %57 to i64* +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (9.999994e-01) from %class.Graph* %0 + load (9.999994e-01) from %"class.std::map"* %2 + load (1.999985e+01) from %class.Graph* %0 + load (1.999985e+01) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 4.199970e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::map"* %2 + load: 9.999994e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..32 +Round 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.66", %"class.std::vector.66"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %30 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.137255e-01) from %"class.std::vector.66"* %4 + load (3.137255e-01) from %"class.std::vector.0"* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.137255e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.66"* %4 + load: 3.137255e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.34 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to i64**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..35 +Round 0 + alias entry %36 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %38 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (3.157895e-01) from %"class.std::vector.0"* %6 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + load (2.105263e-01) from i64* %5 + store (2.105263e-01) to i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %6 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..37 +Round 0 + alias entry %26 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (6.350000e+00) from %"class.std::vector.52"* %3 + load (6.350000e+00) from %"class.std::vector.15"* %4 + load (6.350000e+00) from i64* %5 + load (2.047500e+02) from i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.52"* %3 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %4 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.111000e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z18exchangeVertexReqsRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ii +Round 0 + alias entry %15 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10306 + alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10319 + alias entry %51 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 1, !dbg !10485 + alias entry %52 = bitcast i64** %51 to i64*, !dbg !10485 + alias entry %54 = bitcast %"class.std::vector.0"* %4 to i64*, !dbg !10489 + alias entry %71 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 1, !dbg !10517 + alias entry %72 = bitcast i64** %71 to i64*, !dbg !10517 + alias entry %74 = bitcast %"class.std::vector.0"* %3 to i64*, !dbg !10518 + alias entry %91 = bitcast %"class.std::vector.0"* %3 to i8** + alias entry %94 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %99 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0, !dbg !10612 + alias entry %100 = bitcast %"class.std::vector.0"* %4 to i8**, !dbg !10612 + alias entry %129 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 1, !dbg !10673 + alias entry %130 = bitcast i64** %129 to i64*, !dbg !10673 + alias entry %132 = bitcast %"class.std::vector.0"* %5 to i64*, !dbg !10674 + alias entry %148 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 1, !dbg !10696 + alias entry %149 = bitcast i64** %148 to i64*, !dbg !10696 + alias entry %151 = bitcast %"class.std::vector.0"* %6 to i64*, !dbg !10697 + alias entry %191 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 + alias entry %251 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 + alias entry %310 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 2, !dbg !11244 + alias entry %311 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 2, !dbg !11245 + alias entry %312 = bitcast i64** %310 to i64*, !dbg !11249 + alias entry %314 = bitcast i64** %311 to i64*, !dbg !11250 + alias entry %320 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 2, !dbg !11279 + alias entry %321 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 2, !dbg !11280 + alias entry %322 = bitcast i64** %320 to i64*, !dbg !11284 + alias entry %324 = bitcast i64** %321 to i64*, !dbg !11285 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (9.999984e-01) from %"class.std::vector.0"* %4 + load (9.999984e-01) from %"class.std::vector.0"* %4 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..39 +Round 0 + alias entry %26 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 0, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 1, i32 0, i32 0, i32 0 + alias entry %28 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 6 + alias entry %29 = bitcast %"class.std::vector.0"* %28 to i64* + alias entry %30 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %31 = bitcast i64** %30 to i64* + alias entry %32 = getelementptr inbounds %"class.std::vector.29", %"class.std::vector.29"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.988141e+02) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (1.590478e+03) from %"class.std::vector.29"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %class.Graph* %3 + load: 9.741684e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.29"* %5 + load: 1.590478e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.41 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..42 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi +Round 0 + alias entry %68 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 2, !dbg !11180 + alias entry %85 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !11380 + alias entry %86 = bitcast i64** %85 to i64*, !dbg !11380 + alias entry %88 = bitcast %class.Graph* %2 to i64*, !dbg !11384 + alias entry %93 = bitcast %class.Graph* %2 to i8**, !dbg !11392 + alias entry %98 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 6, !dbg !11399 + alias entry %99 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 6, i32 0, i32 0, i32 1, !dbg !11402 + alias entry %100 = bitcast i64** %99 to i64*, !dbg !11402 + alias entry %102 = bitcast %"class.std::vector.0"* %98 to i64*, !dbg !11403 + alias entry %107 = bitcast %"class.std::vector.0"* %98 to i8**, !dbg !11410 + alias entry %112 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 1, !dbg !11417 + alias entry %113 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 1, i32 0, i32 0, i32 1, !dbg !11424 + alias entry %114 = bitcast %struct.Edge** %113 to i64*, !dbg !11424 + alias entry %116 = bitcast %"class.std::vector.5"* %112 to i64*, !dbg !11428 + alias entry %121 = bitcast %"class.std::vector.5"* %112 to i8**, !dbg !11440 +Round 1 +Round end + load (9.999981e-01) from %class.Graph* %2 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..45 +Round 0 +Round end + call (1.058333e+01, 2.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %5 + call (1.058333e+01, 1.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %6 + call (1.058333e+01, 1.721875e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Edge* %7 + call (1.058333e+01, 8.992188e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %8 + call (1.058333e+01, 0.000000e+00, 1.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %9 + call (1.058333e+01, 7.500000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using double* %10 + call (1.058333e+01, 2.121875e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %11 + call (1.058333e+01, 5.000000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %12 + call (1.058333e+01, 5.000000e-01, 5.000000e-01, 0.000000e+00, 0.000000e+00) using double* %14 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.116667e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %6 + load: 1.058333e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %7 + load: 1.822318e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %8 + load: 9.516732e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %9 + load: 0.000000e+00 store: 1.058333e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 7.937500e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %11 + load: 2.245651e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %12 + load: 5.291667e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %14 + load: 5.291667e+00 store: 5.291667e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..46 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %5 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %8 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %9 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %10 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %12 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..49 +Round 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from i64** %4 + load (3.200000e-01) from i64** %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64** %4 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64** %5 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function main +Round 0 + base alias entry %14 = alloca i8**, align 8 + alias entry %33 = load i8**, i8*** %14, align 8, !dbg !10342, !tbaa !10335 +Round 1 +Round end + Frequency of i8** %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN11GenerateRGGC2ElP19ompi_communicator_t +Round 0 + alias entry %4 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 0, !dbg !10266 + alias entry %5 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10276 + base alias entry %5 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10276 + alias entry %6 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 5, !dbg !10279 + alias entry %8 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10281, !tbaa !10278 + alias entry %9 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 4, !dbg !10282 + alias entry %11 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 7, !dbg !10284 + alias entry %12 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 6, !dbg !10287 + alias entry %36 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 1, !dbg !10320 + alias entry %101 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10478, !tbaa !10278 + alias entry %172 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10565, !tbaa !10278 + alias entry %184 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2, !dbg !10579 + alias entry %191 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10583, !tbaa !10278 +Round 1 +Round end + store (1.000000e+00) to %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + store (2.500000e-01) to %class.GenerateRGG* %0 + store (3.437500e-01) to %class.GenerateRGG* %0 + store (2.500000e-01) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (6.250000e-01) from %class.GenerateRGG* %0 + load (6.250000e-01) from %class.GenerateRGG* %0 + load (6.250000e-01) from %class.GenerateRGG* %0 + load (7.656250e-01) from %class.GenerateRGG* %0 + load (7.656250e-01) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + Frequency of %class.GenerateRGG* %0 + load: 8.906250e+00 store: 6.843750e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.ompi_communicator_t* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN11GenerateRGG8generateEbbi +Round 0 + alias entry %27 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 1, !dbg !10306 + alias entry %75 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 6, !dbg !10592 + alias entry %112 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 7, !dbg !10709 + alias entry %153 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 0, !dbg !10828 + alias entry %156 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 4, !dbg !10832 + alias entry %160 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 5, !dbg !10836 + alias entry %430 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10915 + alias entry %819 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !11101 + alias entry %895 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 + alias entry %1233 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 + alias entry %1536 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 +Round 1 +Round end + load (1.000000e+00) from %class.GenerateRGG* %0 + load (6.249994e-01) from %class.GenerateRGG* %0 + load (9.999990e-01) from %class.GenerateRGG* %0 + load (4.999995e-01) from %class.GenerateRGG* %0 + load (3.124994e-01) from %class.GenerateRGG* %0 + load (9.999985e-01) from %class.GenerateRGG* %0 + load (4.999993e-01) from %class.GenerateRGG* %0 + load (3.124992e-01) from %class.GenerateRGG* %0 + load (9.999971e-01) from %class.GenerateRGG* %0 + load (9.999971e-01) from %class.GenerateRGG* %0 + load (9.999962e-01) from %class.GenerateRGG* %0 + load (9.999962e-01) from %class.GenerateRGG* %0 + load (4.999966e-01) from %class.GenerateRGG* %0 + load (4.999971e-01) from %class.GenerateRGG* %0 + load (4.999971e-01) from %class.GenerateRGG* %0 + load (4.999966e-01) from %class.GenerateRGG* %0 + load (9.999923e-01) from %class.GenerateRGG* %0 + load (9.999914e-01) from %class.GenerateRGG* %0 + load (3.749968e-01) from %class.GenerateRGG* %0 + load (3.749964e-01) from %class.GenerateRGG* %0 + load (9.999890e-01) from %class.GenerateRGG* %0 + load (9.998746e-01) from %class.GenerateRGG* %0 + load (3.199362e+02) from %class.GenerateRGG* %0 + load (3.199361e+02) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998698e-01) from %class.GenerateRGG* %0 + load (4.999349e-01) from %class.GenerateRGG* %0 + load (2.499674e-01) from %class.GenerateRGG* %0 + load (7.997451e+01) from %class.GenerateRGG* %0 + load (3.998725e+01) from %class.GenerateRGG* %0 + load (3.998725e+01) from %class.GenerateRGG* %0 + load (7.997448e+01) from %class.GenerateRGG* %0 + load (4.999063e-01) from %class.GenerateRGG* %0 + load (2.499531e-01) from %class.GenerateRGG* %0 + load (7.996993e+01) from %class.GenerateRGG* %0 + load (3.998497e+01) from %class.GenerateRGG* %0 + load (3.998497e+01) from %class.GenerateRGG* %0 + load (7.996991e+01) from %class.GenerateRGG* %0 + load (9.998126e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998072e-01) from %class.GenerateRGG* %0 + load (9.998015e-01) from %class.GenerateRGG* %0 + load (6.248724e-01) from %class.GenerateRGG* %0 + load (6.248718e-01) from %class.GenerateRGG* %0 + load (1.952724e-01) from %class.GenerateRGG* %0 + load (3.905445e-01) from %class.GenerateRGG* %0 + load (3.905442e-01) from %class.GenerateRGG* %0 + load (6.248393e-01) from %class.GenerateRGG* %0 + load (1.249644e+01) from %class.GenerateRGG* %0 + load (1.249643e+01) from %class.GenerateRGG* %0 + load (1.171538e+00) from %class.GenerateRGG* %0 + load (5.857690e-01) from %class.GenerateRGG* %0 + load (2.928845e-01) from %class.GenerateRGG* %0 + load (1.464422e-01) from %class.GenerateRGG* %0 + load (6.248387e-01) from %class.GenerateRGG* %0 + load (6.248381e-01) from %class.GenerateRGG* %0 + load (1.249638e+01) from %class.GenerateRGG* %0 + load (6.248253e-01) from %class.GenerateRGG* %0 + load (3.905154e-01) from %class.GenerateRGG* %0 + load (2.440719e-01) from %class.GenerateRGG* %0 + load (6.248247e-01) from %class.GenerateRGG* %0 + load (4.881438e+00) from %class.GenerateRGG* %0 + load (9.997431e-01) from %class.GenerateRGG* %0 + load (9.997421e-01) from %class.GenerateRGG* %0 + load (9.997406e-01) from %class.GenerateRGG* %0 + load (9.997406e-01) from %class.GenerateRGG* %0 + load (6.248378e-01) from %class.GenerateRGG* %0 + load (1.999481e+01) from %class.GenerateRGG* %0 + load (9.997388e-01) from %class.GenerateRGG* %0 + load (9.997385e-01) from %class.GenerateRGG* %0 + Frequency of %class.GenerateRGG* %0 + load: 1.248245e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN14BinaryEdgeList4readEiiiSs +Round 0 + alias entry %39 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 4, !dbg !10380 + alias entry %41 = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %4, i64 0, i32 0, i32 0, !dbg !10388 + alias entry %99 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 0, !dbg !10514 + alias entry %100 = bitcast %class.BinaryEdgeList* %0 to i8*, !dbg !10515 + alias entry %104 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 1, !dbg !10518 + alias entry %105 = bitcast i64* %104 to i8*, !dbg !10519 + alias entry %118 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 2, !dbg !10532 + alias entry %183 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 3, !dbg !10605 +Round 1 +Round end + load (9.999971e-01) from %class.BinaryEdgeList* %0 + load (9.999971e-01) from %"class.std::basic_string"* %4 + load (6.249948e-01) from %class.BinaryEdgeList* %0 + load (9.999905e-01) from %class.BinaryEdgeList* %0 + store (9.999905e-01) to %class.BinaryEdgeList* %0 + load (9.999895e-01) from %class.BinaryEdgeList* %0 + load (9.999886e-01) from %class.BinaryEdgeList* %0 + load (9.999886e-01) from %class.BinaryEdgeList* %0 + load (9.999729e-01) from %class.BinaryEdgeList* %0 + store (9.999729e-01) to %class.BinaryEdgeList* %0 + load (9.999714e-01) from %class.BinaryEdgeList* %0 + load (9.999714e-01) from %class.BinaryEdgeList* %0 + load (9.999547e-01) from %class.BinaryEdgeList* %0 + load (1.999909e+01) from %class.BinaryEdgeList* %0 + Frequency of %class.BinaryEdgeList* %0 + load: 2.962391e+01 store: 1.999963e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::basic_string"* %4 + load: 9.999971e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt8_Rb_treeIlSt4pairIKl4CommESt10_Select1stIS3_ESt4lessIlESaIS3_EE8_M_eraseEPSt13_Rb_tree_nodeIS3_E +Round 0 +Round end +Warning: wrong traversal order, or recursive call +On function _ZN5GraphC2EllllP19ompi_communicator_t +Round 0 + alias entry %8 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, !dbg !10272 + alias entry %9 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 1, !dbg !10272 + alias entry %10 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10309 + alias entry %11 = bitcast %class.Graph* %0 to i8*, !dbg !10309 + alias entry %12 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 3, !dbg !10320 + alias entry %13 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 4, !dbg !10322 + alias entry %14 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 5, !dbg !10324 + alias entry %15 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, !dbg !10272 + alias entry %16 = bitcast %"class.std::vector.0"* %15 to i8*, !dbg !10332 + alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10334 + base alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10334 + alias entry %18 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 9, !dbg !10336 + alias entry %21 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %17, align 8, !dbg !10338, !tbaa !10335 + alias entry %22 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 8, !dbg !10339 + alias entry %28 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !10361 + alias entry %29 = bitcast i64** %28 to i64*, !dbg !10361 + alias entry %31 = bitcast %class.Graph* %0 to i64*, !dbg !10365 + alias entry %45 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 1, i32 0, i32 0, i32 1, !dbg !10416 + alias entry %46 = bitcast %struct.Edge** %45 to i64*, !dbg !10416 + alias entry %48 = bitcast %"class.std::vector.5"* %9 to i64*, !dbg !10420 + alias entry %64 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1, !dbg !10455 + alias entry %65 = bitcast i64** %64 to i64*, !dbg !10455 + alias entry %67 = bitcast %"class.std::vector.0"* %15 to i64*, !dbg !10456 + alias entry %76 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %15, i64 0, i32 0, i32 0, i32 0 + alias entry %111 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %15, i64 0, i32 0, i32 0, i32 0, !dbg !10511 + alias entry %117 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %9, i64 0, i32 0, i32 0, i32 0, !dbg !10547 + alias entry %123 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, i32 0, i32 0, i32 0, !dbg !10576 +Round 1 +Round end + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + load (9.999990e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 +Warning: wrong traversal order, or recursive call +On function _ZN3LCGC2EjPdlP19ompi_communicator_t +Round 0 + alias entry %6 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 3, !dbg !10268 + alias entry %7 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 4, !dbg !10277 + alias entry %8 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 6, !dbg !10279 + base alias entry %8 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 6, !dbg !10279 + alias entry %9 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, !dbg !10281 + alias entry %10 = bitcast %"class.std::vector.0"* %9 to i8*, !dbg !10300 + alias entry %11 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0, !dbg !10302 + base alias entry %11 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0, !dbg !10302 + alias entry %12 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 1, !dbg !10306 + alias entry %15 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %11, align 8, !dbg !10308, !tbaa !10305 + alias entry %16 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 2, !dbg !10309 + alias entry %20 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, i32 0, i32 0, i32 1, !dbg !10326 + alias entry %21 = bitcast i64** %20 to i64*, !dbg !10326 + alias entry %23 = bitcast %"class.std::vector.0"* %9 to i64*, !dbg !10330 + alias entry %42 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10359 + alias entry %45 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %9, i64 0, i32 0, i32 0, i32 0, !dbg !10374 + alias entry %52 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10399 + alias entry %53 = bitcast i64* %52 to i8*, !dbg !10400 + alias entry %54 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %11, align 8, !dbg !10401, !tbaa !10305 +Round 1 +Round end + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + load (9.999989e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 +Warning: wrong traversal order, or recursive call +On function _ZNSt24uniform_int_distributionIiEclISt26linear_congruential_engineImLm16807ELm0ELm2147483647EEEEiRT_RKNS0_10param_typeE +Round 0 + alias entry %5 = getelementptr inbounds %"struct.std::uniform_int_distribution::param_type", %"struct.std::uniform_int_distribution::param_type"* %2, i64 0, i32 1, !dbg !10267 + alias entry %8 = getelementptr inbounds %"struct.std::uniform_int_distribution::param_type", %"struct.std::uniform_int_distribution::param_type"* %2, i64 0, i32 0, !dbg !10279 + alias entry %19 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0 + alias entry %37 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0 + alias entry %51 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0, !dbg !10376 +Round 1 +Round end + load (1.000000e+00) from %"struct.std::uniform_int_distribution::param_type"* %2 + load (1.000000e+00) from %"struct.std::uniform_int_distribution::param_type"* %2 + load (5.000000e-01) from %"class.std::linear_congruential_engine"* %1 + store (5.000000e-01) to %"class.std::linear_congruential_engine"* %1 +Warning: wrong traversal order, or recursive call +On function _ZNSt6vectorIlSaIlEEaSERKS1_ +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10278 + alias entry %6 = bitcast i64** %5 to i64*, !dbg !10278 + alias entry %8 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10285 + alias entry %12 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10294 + alias entry %13 = bitcast i64** %12 to i64*, !dbg !10294 + alias entry %15 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10296 + alias entry %33 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10459 + alias entry %41 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10490 + alias entry %42 = bitcast i64** %41 to i64*, !dbg !10490 + alias entry %53 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 0, !dbg !10573 + alias entry %73 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10633 + alias entry %76 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10635 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %1 + load (9.765625e-02) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %0 + store (6.250000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.695312e+00 store: 1.250000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %1 + load: 1.445312e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorIlSaIlEE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPlS1_EEmRKl +Round 0 + alias entry %8 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10281 + alias entry %9 = bitcast i64** %8 to i64*, !dbg !10281 + alias entry %11 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10288 + alias entry %12 = bitcast i64** %11 to i64*, !dbg !10288 + alias entry %632 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10728 + alias entry %848 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10820 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from i64* %3 + load (9.765625e-02) from %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from i64* %3 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.382812e+00 store: 1.406250e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 6.250000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI4EdgeSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast %struct.Edge** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %87 = bitcast %"class.std::vector.5"* %0 to i64*, !dbg !10375 + alias entry %108 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %115 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10431 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.5"* %0 + load (6.250000e-01) from %"class.std::vector.5"* %0 + load (3.125000e-01) from %"class.std::vector.5"* %0 + load (1.953125e-01) from %"class.std::vector.5"* %0 + load (1.953125e-01) from %"class.std::vector.5"* %0 + load (3.125000e-01) from %"class.std::vector.5"* %0 + store (3.125000e-01) to %"class.std::vector.5"* %0 + store (3.125000e-01) to %"class.std::vector.5"* %0 + Frequency of %"class.std::vector.5"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN3LCG18parallel_prefix_opEv +Round 0 + alias entry %10 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 4, !dbg !10283 + alias entry %169 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 1, !dbg !10361 + alias entry %175 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 2, !dbg !10269 + alias entry %179 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0 + alias entry %188 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10372 + alias entry %252 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, i32 0, i32 0, i32 0, !dbg !10372 +Round 1 +Round end + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + Frequency of %class.LCG* %0 + load: 8.523529e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI9EdgeTupleSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10273 + alias entry %6 = bitcast %struct.EdgeTuple** %5 to i64*, !dbg !10273 + alias entry %8 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10280 + alias entry %65 = bitcast %"class.std::vector.84"* %0 to i64*, !dbg !10369 + alias entry %86 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %93 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10425 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + Frequency of %"class.std::vector.84"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_E_ET_SC_SC_T0_St26random_access_iterator_tag +Round 0 +Round end +On function _ZNSt6vectorI9EdgeTupleSaIS0_EE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPS0_S2_EEEEvS7_T_S8_St20forward_iterator_tag +Round 0 + alias entry %13 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10344 + alias entry %14 = bitcast %struct.EdgeTuple** %13 to i64*, !dbg !10344 + alias entry %16 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10351 + alias entry %17 = bitcast %struct.EdgeTuple** %16 to i64*, !dbg !10351 + alias entry %120 = bitcast %"class.std::vector.84"* %0 to i64*, !dbg !10799 + alias entry %141 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %146 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10851 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + Frequency of %"class.std::vector.84"* %0 + load: 2.675781e+00 store: 1.406250e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZSt16__introsort_loopIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEElZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_T0_T1_ +Round 0 +Round end +On function _ZSt22__final_insertion_sortIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_T0_ +Round 0 +Round end +On function _ZSt13__heap_selectIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_SC_T0_ +Round 0 +Round end +On function _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEElS2_ZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_T0_SD_T1_T2_ +Round 0 +Round end +On function _ZSt22__move_median_to_firstIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_SC_SC_T0_ +Round 0 +Round end +On function _ZNSt6vectorIlSaIlEE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast i64** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %20 = bitcast i64** %8 to i64*, !dbg !10380 + alias entry %21 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10381 + alias entry %42 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %65 = bitcast %"class.std::vector.0"* %0 to i8**, !dbg !10628 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorIdSaIdEE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast double** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %20 = bitcast double** %8 to i64*, !dbg !10381 + alias entry %21 = bitcast %"class.std::vector.10"* %0 to i64*, !dbg !10382 + alias entry %42 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %65 = bitcast %"class.std::vector.10"* %0 to i8**, !dbg !10630 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.10"* %0 + load (6.250000e-01) from %"class.std::vector.10"* %0 + load (3.125000e-01) from %"class.std::vector.10"* %0 + load (3.125000e-01) from %"class.std::vector.10"* %0 + load (1.953125e-01) from %"class.std::vector.10"* %0 + load (1.953125e-01) from %"class.std::vector.10"* %0 + store (3.125000e-01) to %"class.std::vector.10"* %0 + store (3.125000e-01) to %"class.std::vector.10"* %0 + Frequency of %"class.std::vector.10"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI4CommSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10460 + alias entry %6 = bitcast %struct.Comm** %5 to i64*, !dbg !10460 + alias entry %8 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10467 + alias entry %20 = bitcast %"class.std::vector.15"* %0 to i64*, !dbg !10551 + alias entry %41 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %48 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10607 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.15"* %0 + load (6.250000e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + load (1.953125e-01) from %"class.std::vector.15"* %0 + load (1.953125e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + store (3.125000e-01) to %"class.std::vector.15"* %0 + store (3.125000e-01) to %"class.std::vector.15"* %0 + Frequency of %"class.std::vector.15"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt27__uninitialized_default_n_1ILb0EE18__uninit_default_nIPSt13unordered_setIlSt4hashIlESt8equal_toIlESaIlEEmEEvT_T0_ +Round 0 +Round end + Frequency of %"class.std::unordered_set"* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt10_HashtableIlSt4pairIKllESaIS2_ENSt8__detail10_Select1stESt8equal_toIlESt4hashIlENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE21_M_insert_unique_nodeEmmPNS4_10_Hash_nodeIS2_Lb0EEE +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 4, !dbg !10268 + alias entry %6 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 4, i32 1, !dbg !10275 + alias entry %8 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 1, !dbg !10282 + alias entry %10 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 3, !dbg !10288 + alias entry %17 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 0 + alias entry %29 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 2, i32 0, !dbg !10428 + alias entry %30 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to %"struct.std::__detail::_Hash_node"**, !dbg !10429 + alias entry %32 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %29, i64 0, i32 0, !dbg !10432 + alias entry %35 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to i64* + base alias entry %44 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %28, i64 %43, !dbg !10509 + alias entry %61 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10529, !tbaa !10511 + alias entry %62 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %61, i64 0, i32 0, !dbg !10530 + alias entry %77 = bitcast %"class.std::_Hashtable"* %0 to i8**, !dbg !10550 + alias entry %83 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i8*, !dbg !10618 + alias entry %87 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 0, !dbg !10296 + alias entry %94 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, !dbg !10627 + alias entry %95 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i64*, !dbg !10628 + base alias entry %97 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %96, i64 0, i32 0, !dbg !10630 + alias entry %99 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 2, i32 0, !dbg !10639 + alias entry %100 = bitcast %"struct.std::__detail::_Hash_node_base"* %99 to i64*, !dbg !10640 + alias entry %102 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, !dbg !10641 + alias entry %103 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, i32 0, !dbg !10641 + alias entry %104 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i64*, !dbg !10642 + alias entry %105 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %99, i64 0, i32 0, !dbg !10645 + base alias entry %105 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %99, i64 0, i32 0, !dbg !10645 + base alias entry %114 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %85, i64 %113, !dbg !10676 + base alias entry %118 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %117, i64 %86, !dbg !10678 +Round 1 +Warning: the first offset is not constant + alias entry %45 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10509, !tbaa !10511 + alias entry %57 = bitcast %"struct.std::__detail::_Hash_node_base"* %45 to i64*, !dbg !10525 + base alias offset entry (0) %96 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %88, align 8, !dbg !10629, !tbaa !10511 +Warning: the first offset is not constant +Warning: the first offset is not constant +Round 2 +Warning: the first offset is not constant +Warning: the first offset is not constant +Warning: the first offset is not constant +Round end + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (5.000000e-01) from %"class.std::_Hashtable"* %0 + load (4.999995e-01) from %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + load (3.749996e+00) from %"class.std::_Hashtable"* %0 + store (3.749996e+00) to %"class.std::_Hashtable"* %0 + load (6.249994e+00) from %"class.std::_Hashtable"* %0 + store (6.249994e+00) to %"class.std::_Hashtable"* %0 + store (4.768372e-07) to %"class.std::_Hashtable"* %0 + load (4.999995e-01) from %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + store (6.249997e-01) to %"struct.std::__detail::_Hash_node"* %3 + load (3.749998e-01) from %"class.std::_Hashtable"* %0 + store (3.749998e-01) to %"struct.std::__detail::_Hash_node"* %3 + store (3.749998e-01) to %"class.std::_Hashtable"* %0 + load (3.749998e-01) from %"struct.std::__detail::_Hash_node"* %3 + load (2.343749e-01) from %"class.std::_Hashtable"* %0 + load (2.343749e-01) from %"class.std::_Hashtable"* %0 + load (9.999995e-01) from %"class.std::_Hashtable"* %0 + store (9.999995e-01) to %"class.std::_Hashtable"* %0 + Frequency of %"class.std::_Hashtable"* %0 + load: 1.634374e+01 store: 1.287499e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"struct.std::__detail::_Hash_node"* %3 + load: 3.749998e-01 store: 9.999995e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt10_HashtableIllSaIlENSt8__detail9_IdentityESt8equal_toIlESt4hashIlENS1_18_Mod_range_hashingENS1_20_Default_ranged_hashENS1_20_Prime_rehash_policyENS1_17_Hashtable_traitsILb0ELb1ELb1EEEE21_M_insert_unique_nodeEmmPNS1_10_Hash_nodeIlLb0EEE +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 4, !dbg !10268 + alias entry %6 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 4, i32 1, !dbg !10275 + alias entry %8 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 1, !dbg !10282 + alias entry %10 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 3, !dbg !10288 + alias entry %17 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 0 + alias entry %29 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 2, i32 0, !dbg !10428 + alias entry %30 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to %"struct.std::__detail::_Hash_node.61"**, !dbg !10429 + alias entry %32 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %29, i64 0, i32 0, !dbg !10432 + alias entry %35 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to i64* + base alias entry %44 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %28, i64 %43, !dbg !10469 + alias entry %61 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10489, !tbaa !10471 + alias entry %62 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %61, i64 0, i32 0, !dbg !10490 + alias entry %77 = bitcast %"class.std::_Hashtable.34"* %0 to i8**, !dbg !10510 + alias entry %83 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i8*, !dbg !10578 + alias entry %87 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 0, !dbg !10296 + alias entry %94 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, !dbg !10587 + alias entry %95 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i64*, !dbg !10588 + base alias entry %97 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %96, i64 0, i32 0, !dbg !10590 + alias entry %99 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 2, i32 0, !dbg !10599 + alias entry %100 = bitcast %"struct.std::__detail::_Hash_node_base"* %99 to i64*, !dbg !10600 + alias entry %102 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, !dbg !10601 + alias entry %103 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, i32 0, !dbg !10601 + alias entry %104 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i64*, !dbg !10602 + alias entry %105 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %99, i64 0, i32 0, !dbg !10605 + base alias entry %105 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %99, i64 0, i32 0, !dbg !10605 + base alias entry %114 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %85, i64 %113, !dbg !10630 + base alias entry %118 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %117, i64 %86, !dbg !10632 +Round 1 +Warning: the first offset is not constant + alias entry %45 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10469, !tbaa !10471 + alias entry %57 = bitcast %"struct.std::__detail::_Hash_node_base"* %45 to i64*, !dbg !10485 + base alias offset entry (0) %96 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %88, align 8, !dbg !10589, !tbaa !10471 +Warning: the first offset is not constant +Warning: the first offset is not constant +Round 2 +Warning: the first offset is not constant +Warning: the first offset is not constant +Warning: the first offset is not constant +Round end + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (5.000000e-01) from %"class.std::_Hashtable.34"* %0 + load (4.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + load (3.749996e+00) from %"class.std::_Hashtable.34"* %0 + store (3.749996e+00) to %"class.std::_Hashtable.34"* %0 + load (6.249994e+00) from %"class.std::_Hashtable.34"* %0 + store (6.249994e+00) to %"class.std::_Hashtable.34"* %0 + store (4.768372e-07) to %"class.std::_Hashtable.34"* %0 + load (4.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + store (6.249997e-01) to %"struct.std::__detail::_Hash_node.61"* %3 + load (3.749998e-01) from %"class.std::_Hashtable.34"* %0 + store (3.749998e-01) to %"struct.std::__detail::_Hash_node.61"* %3 + store (3.749998e-01) to %"class.std::_Hashtable.34"* %0 + load (3.749998e-01) from %"struct.std::__detail::_Hash_node.61"* %3 + load (2.343749e-01) from %"class.std::_Hashtable.34"* %0 + load (2.343749e-01) from %"class.std::_Hashtable.34"* %0 + load (9.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (9.999995e-01) to %"class.std::_Hashtable.34"* %0 + Frequency of %"class.std::_Hashtable.34"* %0 + load: 1.634374e+01 store: 1.287499e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"struct.std::__detail::_Hash_node.61"* %3 + load: 3.749998e-01 store: 9.999995e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI8CommInfoSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %7 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10273 + alias entry %8 = bitcast %struct.CommInfo** %7 to i64*, !dbg !10273 + alias entry %10 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10280 + alias entry %59 = bitcast %struct.CommInfo** %10 to i64*, !dbg !10394 + alias entry %60 = bitcast %"class.std::vector.52"* %0 to i64*, !dbg !10395 + alias entry %81 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %89 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10449 + alias entry %143 = bitcast %"class.std::vector.52"* %0 to i8**, !dbg !10651 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.52"* %0 + load (6.250000e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + load (1.953125e-01) from %"class.std::vector.52"* %0 + load (1.953125e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + store (3.125000e-01) to %"class.std::vector.52"* %0 + store (3.125000e-01) to %"class.std::vector.52"* %0 + Frequency of %"class.std::vector.52"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _GLOBAL__sub_I_main.cpp +Round 0 +Round end +On function .omp_offloading.descriptor_unreg +Round 0 +Round end + Frequency of i8* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_offloading.descriptor_reg.nvptx64-nvidia-cuda +Round 0 +Round end + ---- Identify Target Regions ---- + target call: %49 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396.region_id, i32 5, i8** nonnull %24, i8** nonnull %26, i64* nonnull %28, i64* getelementptr inbounds ([5 x i64], [5 x i64]* @.offload_maptypes, i64 0, i64 0), i32 0, i32 0), !dbg !10317 + target call: %24 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %9, i8** nonnull %11, i64* nonnull %13, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0), !dbg !10269 + target call: %26 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %11, i8** nonnull %13, i64* nonnull %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0), !dbg !10269 + target call: %258 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0) + to label %259 unwind label %319, !dbg !11559 + target call: %276 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368.region_id, i32 12, i8** nonnull %200, i8** nonnull %202, i64* nonnull %204, i64* getelementptr inbounds ([12 x i64], [12 x i64]* @.offload_maptypes.47, i64 0, i64 0), i32 0, i32 0), !dbg !11584 + target call: %325 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0) + to label %326 unwind label %319, !dbg !11667 + ---- Target Distance Calculation ---- +_Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi converges after 3 iterations +target 0: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 1: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 2: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 3: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 9.152967e+00) (4: 1.000095e+00) (5: 2.000190e+00) +target 4: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 8.152880e+00) (4: 9.091440e+00) (5: 1.000095e+00) +target 5: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 7.152791e+00) (4: 8.091353e+00) (5: 9.029914e+00) + ---- OMP (main.cpp, powerpc64le-unknown-linux-gnu) ---- +new entry %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 +new entry %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 +new entry %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 +new entry %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 +new entry %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 +new entry %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 +new entry %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 +new entry %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 +new entry %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 +Round 0 + base alias entry %130 = bitcast i64** %29 to i8**, !dbg !11450 + base alias entry %142 = bitcast i64** %30 to i8**, !dbg !11479 + alias entry %147 = bitcast i8* %145 to %struct.Comm*, !dbg !11487 + alias entry %158 = bitcast i8* %156 to double*, !dbg !11511 + base alias entry %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias entry %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 + base alias entry %192 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 2 + base alias entry %193 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 2 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias entry %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias entry %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias entry %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias entry %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias entry %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias entry %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias entry %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias entry %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias entry %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias entry %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias entry %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias entry %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias entry %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias entry %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 +Warning: reach to function declaration __kmpc_fork_teams + alias entry (func arg) %struct.Comm* %1 + alias entry (func arg) double* %2 +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 1 +Round 1 + base alias entry %35 = bitcast i8** %34 to double**, !dbg !10317 + base alias entry %37 = bitcast i8** %36 to double**, !dbg !10317 + base alias entry %45 = bitcast i8** %44 to %struct.Comm**, !dbg !10317 + base alias entry %47 = bitcast i8** %46 to %struct.Comm**, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %29 = alloca i64*, align 8 + base alias entry %30 = alloca i64*, align 8 + base alias offset entry (1) %16 = alloca [3 x i8*], align 8 + base alias offset entry (1) %17 = alloca [3 x i8*], align 8 + base alias offset entry (2) %16 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %192 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 2 + base alias offset entry (2) %17 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %193 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 2 + base alias offset entry (1) %31 = alloca [12 x i8*], align 8 + base alias offset entry (1) %32 = alloca [12 x i8*], align 8 + base alias offset entry (2) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (2) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-2) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (-1) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (3) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-2) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (-1) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (-3) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-2) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-1) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-3) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-2) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-1) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-4) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-3) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-2) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-4) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-3) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-2) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (6) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-5) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-4) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-3) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (6) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-5) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-4) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-3) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (7) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-6) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-5) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-4) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-1) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (7) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-6) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-5) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-4) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-1) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (8) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-7) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-6) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-5) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-2) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-1) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (8) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-7) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-6) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-5) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-2) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-1) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-8) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-7) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-6) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-3) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-2) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-1) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-8) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-7) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-6) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-3) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-2) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-1) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (10) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-9) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-8) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-7) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-4) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-3) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-2) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (10) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-9) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-8) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-7) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-4) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-3) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-2) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-10) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-9) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-8) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-5) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-4) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-3) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-1) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-10) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-9) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-8) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-5) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-4) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-3) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-1) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams + alias entry %263 = load i64*, i64** %29, align 8, !dbg !11584, !tbaa !11451 + alias entry %264 = load i64*, i64** %30, align 8, !dbg !11584, !tbaa !11451 + alias entry %274 = ptrtoint i64* %263 to i64, !dbg !11584 + alias entry %275 = ptrtoint i64* %264 to i64, !dbg !11584 + base alias entry %215 = bitcast i8** %214 to i64* + base alias entry %217 = bitcast i8** %216 to i64* + base alias entry %220 = bitcast i8** %219 to i64* + base alias entry %222 = bitcast i8** %221 to i64* +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 2 +Warning: reach to function declaration __kmpc_fork_call +Round 2 + base alias entry %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias entry %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias entry %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias entry %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (2) %11 = alloca [5 x i8*], align 8 + base alias offset entry (2) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (-1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 + base alias offset entry (4) %11 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias offset entry (4) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %126 = bitcast i64** %29 to i8*, !dbg !11447 + base alias entry %139 = bitcast i64** %30 to i8*, !dbg !11477 + base alias offset entry (1) %184 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 0 + base alias offset entry (2) %184 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 0 + base alias offset entry (1) %186 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 0 + base alias offset entry (2) %186 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 0 + base alias offset entry (1) %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias offset entry (1) %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 + base alias offset entry (1) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (2) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (3) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (6) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (7) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (8) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (10) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (1) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (2) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (3) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (6) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (7) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (8) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (10) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (1) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (2) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (5) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (6) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (7) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (9) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (1) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (2) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (5) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (6) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (7) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (9) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (1) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (4) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (5) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (6) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (8) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (1) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (4) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (5) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (6) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (8) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (4) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (5) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (7) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (3) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (4) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (5) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (7) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (2) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (3) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (4) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (6) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias entry %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (2) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (3) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (4) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (6) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias entry %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (1) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (2) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (3) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (5) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias entry %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (1) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (2) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (3) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (5) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias entry %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (1) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (2) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (4) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (1) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (2) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (4) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (1) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (3) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (1) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (3) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (2) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (2) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (1) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (1) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 3 +Warning: reach to function declaration __kmpc_fork_call +Round 3 + base alias offset entry (4) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (4) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (3) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (3) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (2) %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias offset entry (2) %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias offset entry (1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (4) %31 = alloca [12 x i8*], align 8 + base alias offset entry (4) %32 = alloca [12 x i8*], align 8 + base alias offset entry (5) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (5) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-2) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-1) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-2) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-1) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-3) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-2) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-3) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-2) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-4) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-3) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-4) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-3) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-5) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-4) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-5) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-4) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-6) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-5) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-6) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-5) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-7) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-6) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-7) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-6) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 4 +Warning: reach to function declaration __kmpc_fork_call +Round 4 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (4) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (5) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (4) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (5) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (3) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (4) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (3) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (4) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (2) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (3) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (2) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (1) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (2) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (1) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (2) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (1) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (1) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 5 +Warning: reach to function declaration __kmpc_fork_call +Round 5 +Warning: reach to function declaration __kmpc_fork_teams +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 6 +Warning: reach to function declaration __kmpc_fork_call +Round 6 +Warning: reach to function declaration __kmpc_fork_teams +Round end + ---- Access Frequency Analysis ---- + target call (1.625206e+01, 0.000000e+00, 5.076920e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625206e+01, 0.000000e+00, 1.015380e+01) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + target call (1.625204e+01, 1.015380e+01, 0.000000e+00) using %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + target call (1.625204e+01, 5.076920e+00, 0.000000e+00) using %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + target call (1.625204e+01, 8.757690e+01, 0.000000e+00) using %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + target call (1.625204e+01, 4.569230e+01, 0.000000e+00) using %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + target call (1.625204e+01, 0.000000e+00, 5.076920e+00) using %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + target call (1.625204e+01, 3.807690e+00, 0.000000e+00) using %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + target call (1.625204e+01, 1.078710e+02, 0.000000e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625204e+01, 2.538460e+00, 0.000000e+00) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + target call (1.625204e+01, 2.538460e+00, 2.538460e+00) using %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + target call (1.625202e+01, 1.015380e+01, 1.015380e+01) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625202e+01, 1.015380e+01, 0.000000e+00) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + call (1.625199e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + call (1.625199e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 +Frequency of %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.650200e+02 store: 0.000000e+00 (target) +Frequency of %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 8.251031e+01 store: 0.000000e+00 (target) +Frequency of %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.423303e+03 store: 0.000000e+00 (target) +Frequency of %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 7.425931e+02 store: 0.000000e+00 (target) +Frequency of %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 6.188273e+01 store: 0.000000e+00 (target) +Frequency of %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 8.251031e+01 (target) +Frequency of %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.918144e+03 store: 2.475302e+02 (target) +Frequency of %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 2.062750e+02 store: 1.650201e+02 (target) +Frequency of %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 4.125515e+01 store: 4.125515e+01 (target) + ---- Optimization Preparation ---- +Rank 9 for %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 6.188273e+01 store: 0.000000e+00 (target) +Rank 8 for %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 8.251031e+01 store: 0.000000e+00 (target) +Rank 7 for %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 8.251031e+01 (target) +Rank 6 for %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 4.125515e+01 store: 4.125515e+01 (target) +Rank 5 for %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.650200e+02 store: 0.000000e+00 (target) +Rank 4 for %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 2.062750e+02 store: 1.650201e+02 (target) +Rank 3 for %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 7.425931e+02 store: 0.000000e+00 (target) +Rank 2 for %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.423303e+03 store: 0.000000e+00 (target) +Rank 1 for %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.918144e+03 store: 2.475302e+02 (target) + ---- Data Mapping Optimization ---- + target call: %49 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396.region_id, i32 5, i8** nonnull %24, i8** nonnull %26, i64* nonnull %28, i64* getelementptr inbounds ([5 x i64], [5 x i64]* @.offload_maptypes, i64 0, i64 0), i32 0, i32 0), !dbg !10317 +@.offload_maptypes = private unnamed_addr constant [5 x i64] [i64 800, i64 547, i64 33, i64 547, i64 33] + arg 2 (0.000000e+00, 0.000000e+00; 4.125515e+01, 4.125515e+01) is %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x06 + local reuse is 1.600380e+02, 1.280304e+03 after adjustment; scaled local reuse is 0x500 + reuse distance is 0x01 + arg 4 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 1.600380e+02, 2.560608e+03 after adjustment; scaled local reuse is 0xa00 + reuse distance is 0x01 + map type changed: @.offload_maptypes.0 = private unnamed_addr constant [5 x i64] [i64 800, i64 547, i64 1100853829665, i64 547, i64 1102195986465] + target call: %24 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %9, i8** nonnull %11, i64* nonnull %13, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0), !dbg !10269 +@.offload_maptypes.15 = private unnamed_addr constant [3 x i64] [i64 800, i64 35, i64 33] + target call: %26 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %11, i8** nonnull %13, i64* nonnull %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0), !dbg !10269 +@.offload_maptypes.20 = private unnamed_addr constant [3 x i64] [i64 800, i64 34, i64 34] + target call: %258 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0) + to label %259 unwind label %319, !dbg !11559 +@.offload_maptypes.20 = private unnamed_addr constant [3 x i64] [i64 800, i64 34, i64 34] + arg 1 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x01 + arg 2 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 1.015380e+01, 1.624608e+02 after adjustment; scaled local reuse is 0x0a2 + reuse distance is 0x01 + map type changed: @.offload_maptypes.20.1 = private unnamed_addr constant [3 x i64] [i64 800, i64 1099553574946, i64 1099681513506] + target call: %276 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368.region_id, i32 12, i8** nonnull %200, i8** nonnull %202, i64* nonnull %204, i64* getelementptr inbounds ([12 x i64], [12 x i64]* @.offload_maptypes.47, i64 0, i64 0), i32 0, i32 0), !dbg !11584 +@.offload_maptypes.47 = private unnamed_addr constant [12 x i64] [i64 800, i64 33, i64 33, i64 33, i64 33, i64 34, i64 33, i64 33, i64 35, i64 800, i64 35, i64 800] + arg 1 (0.000000e+00, 0.000000e+00; 1.650200e+02, 0.000000e+00) is %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + size is %90 = sub i64 %87, %89, !dbg !11386 + global reuse is 0x05 + local reuse is 1.015380e+01, 8.123040e+01 after adjustment; scaled local reuse is 0x051 + reuse distance is 0x09 + arg 2 (0.000000e+00, 0.000000e+00; 8.251031e+01, 0.000000e+00) is %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + size is %104 = sub i64 %101, %103, !dbg !11404 + global reuse is 0x08 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + arg 3 (0.000000e+00, 0.000000e+00; 1.423303e+03, 0.000000e+00) is %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + size is %118 = sub i64 %115, %117, !dbg !11430 + global reuse is 0x02 + local reuse is 8.757690e+01, 1.401230e+03 after adjustment; scaled local reuse is 0x579 + reuse distance is 0x09 + arg 4 (0.000000e+00, 0.000000e+00; 7.425931e+02, 0.000000e+00) is %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x03 + local reuse is 4.569230e+01, 3.655384e+02 after adjustment; scaled local reuse is 0x16d + reuse distance is 0x09 + arg 5 (0.000000e+00, 0.000000e+00; 0.000000e+00, 8.251031e+01) is %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x07 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + arg 6 (0.000000e+00, 0.000000e+00; 6.188273e+01, 0.000000e+00) is %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x09 + local reuse is 3.807690e+00, 3.046152e+01 after adjustment; scaled local reuse is 0x01e + reuse distance is 0x09 + arg 7 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 1.078710e+02, 1.725936e+03 after adjustment; scaled local reuse is 0x6bd + reuse distance is 0x01 + arg 8 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 2.538460e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x01 + arg 10 (0.000000e+00, 0.000000e+00; 4.125515e+01, 4.125515e+01) is %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x06 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + map type changed: @.offload_maptypes.47.2 = private unnamed_addr constant [12 x i64] [i64 800, i64 9895689605153, i64 9895646625825, i64 9897073713185, i64 9895987392545, i64 9895646621730, i64 9895636144161, i64 1101320425505, i64 1099553587235, i64 800, i64 9895646617635, i64 800] + target call: %325 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0) + to label %326 unwind label %319, !dbg !11667 +@.offload_maptypes.15 = private unnamed_addr constant [3 x i64] [i64 800, i64 35, i64 33] + arg 1 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 2.030760e+01, 3.249216e+02 after adjustment; scaled local reuse is 0x144 + reuse distance is 0x07 + arg 2 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 1.015380e+01, 1.624608e+02 after adjustment; scaled local reuse is 0x0a2 + reuse distance is 0x07 + map type changed: @.offload_maptypes.15.3 = private unnamed_addr constant [3 x i64] [i64 800, i64 7696921137187, i64 7696751280161] +1 warning generated. +In file included from main.cpp:58: +In file included from ./dspl_gpu_kernel.hpp:58: +In file included from ./graph.hpp:56: +./utils.hpp:263:56: warning: using floating point absolute value function 'fabs' when argument is of integer type [-Wabsolute-value] + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult); // 0-1 + ^ +./utils.hpp:263:56: note: use function 'std::abs' instead + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult); // 0-1 + ^~~~ + std::abs +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 +change loop scale from 32.0 to 1.0 + ---- Function Argument Access Frequency CG Analysis ---- +On function __omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396 +Round 0 + alias entry %71 = getelementptr inbounds double, double* %2, i64 %68, !dbg !45 + alias entry %74 = getelementptr inbounds %struct.Comm, %struct.Comm* %4, i64 %68, i32 1, !dbg !52 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (1.600385e+02) from double* %2 + load (1.600385e+02) from %struct.Comm* %4 + load (6.227106e-02) from double* %1 + store (6.227106e-02) to double* %1 + load (6.227106e-02) from double* %3 + store (6.227106e-02) to double* %3 + Frequency of double* %1 + load: 6.227106e-02 store: 6.227106e-02 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 1.600385e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 6.227106e-02 store: 6.227106e-02 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 1.600385e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436 +Round 0 + alias entry %41 = getelementptr inbounds %struct.Comm, %struct.Comm* %2, i64 %40, i32 0, !dbg !45 + alias entry %43 = getelementptr inbounds %struct.Comm, %struct.Comm* %1, i64 %40, i32 0, !dbg !53 + alias entry %46 = getelementptr inbounds %struct.Comm, %struct.Comm* %2, i64 %40, i32 1, !dbg !55 + alias entry %48 = getelementptr inbounds %struct.Comm, %struct.Comm* %1, i64 %40, i32 1, !dbg !57 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (5.076923e+00) from %struct.Comm* %2 + load (5.076923e+00) from %struct.Comm* %1 + store (5.076923e+00) to %struct.Comm* %1 + load (5.076923e+00) from %struct.Comm* %2 + load (5.076923e+00) from %struct.Comm* %1 + store (5.076923e+00) to %struct.Comm* %1 + Frequency of %struct.Comm* %1 + load: 1.015385e+01 store: 1.015385e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 1.015385e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455 +Round 0 + alias entry %41 = getelementptr inbounds double, double* %1, i64 %40, !dbg !45 + alias entry %42 = getelementptr inbounds %struct.Comm, %struct.Comm* %2, i64 %40, i32 1, !dbg !52 + alias entry %43 = getelementptr inbounds %struct.Comm, %struct.Comm* %2, i64 %40, i32 0, !dbg !57 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + store (5.076923e+00) to double* %1 + store (5.076923e+00) to %struct.Comm* %2 + store (5.076923e+00) to %struct.Comm* %2 + Frequency of double* %1 + load: 0.000000e+00 store: 5.076923e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 1.015385e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368 +Round 0 +Round end +change loop scale from 32.0 to 1.0 +Warning: wrong traversal order, or recursive call +On function _Z27distExecuteLouvainIterationlPKlS0_PK4EdgeS0_PlPKdP4CommS8_dPdi +Round 0 + alias entry %91 = getelementptr inbounds i64, i64* %2, i64 %90, !dbg !35 + alias entry %93 = getelementptr inbounds i64, i64* %4, i64 %0, !dbg !38 + alias entry %96 = getelementptr inbounds i64, i64* %1, i64 %0, !dbg !40 + alias entry %99 = getelementptr inbounds i64, i64* %1, i64 %98, !dbg !42 + alias entry %103 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %95, i32 0, !dbg !45 + alias entry %105 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %95, i32 1, !dbg !49 + base alias entry %178 = select i1 %119, %struct.Edge** %13, %struct.Edge** %177 + alias entry %188 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %187, i32 0, !dbg !69 + alias entry %189 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %187, i32 1, !dbg !70 + alias entry %198 = getelementptr inbounds i64, i64* %4, i64 %197, !dbg !77 + alias entry %239 = bitcast double* %189 to i64*, !dbg !109 + alias entry %282 = getelementptr inbounds double, double* %10, i64 %0, !dbg !122 + alias entry %286 = getelementptr inbounds double, double* %6, i64 %0, !dbg !125 + alias entry %307 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %306, i32 1, !dbg !136 + alias entry %309 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %306, i32 0, !dbg !137 + alias entry %355 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %354, i32 1, !dbg !136 + alias entry %357 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %354, i32 0, !dbg !137 + alias entry %403 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %402, i32 1, !dbg !167 + alias entry %404 = bitcast double* %403 to i64*, !dbg !168 + alias entry %415 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %402, i32 0, !dbg !170 + alias entry %417 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %95, i32 1, !dbg !172 + alias entry %419 = bitcast double* %417 to i64*, !dbg !174 + alias entry %430 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %95, i32 0, !dbg !176 + alias entry %434 = getelementptr inbounds i64, i64* %5, i64 %0, !dbg !179 + alias entry %462 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %461, i32 1, !dbg !136 + alias entry %464 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %461, i32 0, !dbg !137 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (1.000000e+00) from i64* %2 + load (1.000000e+00) from i64* %4 + load (1.000000e+00) from i64* %1 + load (1.000000e+00) from i64* %1 + load (5.000000e-01) from %struct.Comm* %7 + load (5.000000e-01) from %struct.Comm* %7 + load (8.000000e+00) from %struct.Edge* %3 + load (4.000000e+00) from %struct.Edge* %3 + load (8.000000e+00) from i64* %4 + load (2.500000e+00) from %struct.Edge* %3 + load (2.750000e+00) from %struct.Edge* %3 + load (5.000000e-01) from double* %10 + store (5.000000e-01) to double* %10 + load (5.000000e-01) from double* %6 + load (1.236264e-01) from %struct.Comm* %7 + load (1.236264e-01) from %struct.Comm* %7 + load (5.000000e+00) from %struct.Comm* %7 + load (5.000000e+00) from %struct.Comm* %7 + load (2.500000e-01) from %struct.Comm* %8 + load (2.500000e-01) from double* %6 + load (2.500000e-01) from %struct.Comm* %8 + store (1.000000e+00) to i64* %5 + load (5.000000e+00) from %struct.Comm* %7 + load (5.000000e+00) from %struct.Comm* %7 + Frequency of i64* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %3 + load: 1.725000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 9.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 0.000000e+00 store: 1.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %7 + load: 2.124725e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 5.000000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 5.000000e-01 store: 5.000000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z24distBuildLocalMapCounterllP7clmap_tRiPdS1_PK4EdgePKllll +Round 0 + base alias entry %83 = select i1 %16, %struct.Edge** %12, %struct.Edge** %82 + alias entry %93 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %92, i32 0, !dbg !38 + alias entry %94 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %92, i32 1, !dbg !39 + alias entry %103 = getelementptr inbounds i64, i64* %7, i64 %102, !dbg !48 + alias entry %111 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %110, i32 0, !dbg !53 + alias entry %121 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %120, !dbg !61 + alias entry %131 = getelementptr inbounds double, double* %4, i64 %125, !dbg !70 + alias entry %138 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %120, i32 1, !dbg !75 + alias entry %139 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %120, i32 0, !dbg !76 + alias entry %146 = getelementptr inbounds double, double* %4, i64 %145, !dbg !83 + alias entry %147 = bitcast double* %146 to i64*, !dbg !84 + alias entry %148 = bitcast double* %94 to i64*, !dbg !85 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (5.000000e-01) from %struct.Edge* %6 + load (2.472527e-01) from %struct.Edge* %6 + load (5.000000e-01) from i64* %7 + load (5.000000e-01) from i32* %3 + load (5.076923e+00) from %struct.clmap_t* %2 + load (3.076923e-01) from i32* %5 + load (1.538462e-01) from %struct.Edge* %6 + load (1.538462e-01) from double* %4 + store (1.538462e-01) to double* %4 + store (1.703297e-01) to %struct.clmap_t* %2 + store (1.703297e-01) to %struct.clmap_t* %2 + store (1.703297e-01) to i32* %3 + load (3.406593e-01) from i32* %5 + load (1.703297e-01) from %struct.Edge* %6 + store (1.703297e-01) to double* %4 + store (1.703297e-01) to i32* %5 + Frequency of %struct.clmap_t* %2 + load: 5.076923e+00 store: 3.406593e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 5.000000e-01 store: 1.703297e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 1.538462e-01 store: 3.241758e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %5 + load: 6.483516e-01 store: 1.703297e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %6 + load: 1.071429e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 5.000000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z15distGetMaxIndexP7clmap_tRiPdS1_dPK4Commdldllld +Round 0 + alias entry %22 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 %21 + alias entry %28 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 0, !dbg !36 + alias entry %33 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 1, !dbg !43 + alias entry %35 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 0, !dbg !46 + alias entry %37 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 1, !dbg !48 + alias entry %41 = getelementptr inbounds double, double* %2, i64 %38, !dbg !52 + alias entry %60 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 1, !dbg !62 + alias entry %81 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %80, i32 1, !dbg !43 + alias entry %83 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %80, i32 0, !dbg !46 + alias entry %89 = getelementptr inbounds double, double* %2, i64 %86, !dbg !52 + alias entry %126 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %125, i32 1, !dbg !43 + alias entry %128 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %125, i32 0, !dbg !46 + alias entry %134 = getelementptr inbounds double, double* %2, i64 %131, !dbg !52 +Round 1 +Round end +change loop scale from 32.0 to 1.0 + load (1.000000e+00) from double* %2 + load (1.000000e+00) from i32* %3 + load (1.000000e+00) from i32* %1 + load (5.000000e-01) from %struct.clmap_t* %0 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.clmap_t* %0 + load (1.250000e-01) from double* %2 + load (3.125000e-01) from %struct.Comm* %5 + load (3.125000e-01) from %struct.Comm* %5 + load (1.562500e-01) from double* %2 + load (3.125000e-01) from %struct.Comm* %5 + load (3.125000e-01) from %struct.Comm* %5 + load (1.562500e-01) from double* %2 + Frequency of %struct.clmap_t* %0 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 1.437500e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 1.750000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368 +Round 0 +Round end +change loop scale from 32.0 to 1.0 + call (5.076923e+00, 2.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %1 + call (5.076923e+00, 1.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %2 + call (5.076923e+00, 1.725000e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Edge* %3 + call (5.076923e+00, 9.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %4 + call (5.076923e+00, 0.000000e+00, 1.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %5 + call (5.076923e+00, 7.500000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using double* %6 + call (5.076923e+00, 2.124725e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %7 + call (5.076923e+00, 5.000000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %8 + call (5.076923e+00, 5.000000e-01, 5.000000e-01, 0.000000e+00, 0.000000e+00) using double* %10 + Frequency of i64* %1 + load: 1.015385e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 5.076923e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %3 + load: 8.757692e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 4.569231e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 0.000000e+00 store: 5.076923e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 3.807692e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %7 + load: 1.078707e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 2.538462e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 2.538462e+00 store: 2.538462e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + ---- Identify Target Regions ---- + ---- OMP (main.cpp, nvptx64-nvidia-cuda) ---- +Info: ignore malloc +Info: ignore malloc +Info: ignore malloc +Round 0 +Round end + ---- Access Frequency Analysis ---- + ---- Optimization Preparation ---- + ---- Data Mapping Optimization ---- +1 warning generated. + ---- Function Argument Access Frequency CG Analysis ---- +On function _Z7is_pwr2i +Round 0 +Round end +On function _Z8reseederj +Round 0 +Round end +On function _ZNSt8seed_seq8generateIN9__gnu_cxx17__normal_iteratorIPjSt6vectorIjSaIjEEEEEEvT_S8_ +Round 0 + alias entry %18 = getelementptr inbounds %"class.std::seed_seq", %"class.std::seed_seq"* %0, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !10369 + alias entry %19 = bitcast i32** %18 to i64*, !dbg !10369 + alias entry %21 = bitcast %"class.std::seed_seq"* %0 to i64*, !dbg !10376 +Round 1 +Round end + load (6.274510e-01) from %"class.std::seed_seq"* %0 + load (6.274510e-01) from %"class.std::seed_seq"* %0 + Frequency of %"class.std::seed_seq"* %0 + load: 1.254902e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z4lockv +Round 0 +Round end +On function _Z6unlockv +Round 0 +Round end +On function _Z19distSumVertexDegreeRK5GraphRSt6vectorIdSaIdEERS2_I4CommSaIS6_EE +Round 0 + alias entry %6 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10459 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function __clang_call_terminate +Round 0 +Round end + Frequency of i8* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined. +Round 0 + alias entry %25 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 0, i32 0, i32 0, i32 0 + alias entry %26 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 1, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (6.350000e+00) from %class.Graph* %3 + load (6.350000e+00) from %class.Graph* %3 + load (6.350000e+00) from %"class.std::vector.10"* %4 + load (6.350000e+00) from %"class.std::vector.15"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %class.Graph* %3 + load: 1.270000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %4 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %5 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z29distCalcConstantForSecondTermRKSt6vectorIdSaIdEEP19ompi_communicator_t +Round 0 + alias entry %9 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10283 + alias entry %10 = bitcast double** %9 to i64*, !dbg !10283 + alias entry %12 = bitcast %"class.std::vector.10"* %0 to i64*, !dbg !10288 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.10"* %0 + load (1.000000e+00) from %"class.std::vector.10"* %0 + Frequency of %"class.std::vector.10"* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.ompi_communicator_t* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..2 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %98 = bitcast double* %3 to i64*, !dbg !10325 +Round 1 +Round end + load (3.157895e-01) from %"class.std::vector.10"* %4 + load (2.105263e-01) from double* %3 + store (2.105263e-01) to double* %3 + load (2.105263e-01) from double* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.10"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z12distInitCommRSt6vectorIlSaIlEES2_l +Round 0 + alias entry %6 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10273 + alias entry %7 = bitcast i64** %6 to i64*, !dbg !10273 + alias entry %9 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10280 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.0"* %1 + load (1.000000e+00) from %"class.std::vector.0"* %1 + Frequency of %"class.std::vector.0"* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..4 +Round 0 + alias entry %29 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %31 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from %"class.std::vector.0"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %5 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z15distInitLouvainRK5GraphRSt6vectorIlSaIlEES5_RS2_IdSaIdEES8_RS2_I4CommSaIS9_EESC_Rdi +Round 0 + alias entry %16 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !10485 + alias entry %20 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10502 + alias entry %22 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10514 + alias entry %24 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %3, i64 0, i32 0, i32 0, i32 1, !dbg !10532 + alias entry %25 = bitcast double** %24 to i64*, !dbg !10532 + alias entry %27 = bitcast %"class.std::vector.10"* %3 to i64*, !dbg !10536 + alias entry %40 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10572 + alias entry %41 = bitcast i64** %40 to i64*, !dbg !10572 + alias entry %43 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10574 + alias entry %56 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %2, i64 0, i32 0, i32 0, i32 1, !dbg !10600 + alias entry %57 = bitcast i64** %56 to i64*, !dbg !10600 + alias entry %59 = bitcast %"class.std::vector.0"* %2 to i64*, !dbg !10601 + alias entry %72 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %4, i64 0, i32 0, i32 0, i32 1, !dbg !10622 + alias entry %73 = bitcast double** %72 to i64*, !dbg !10622 + alias entry %75 = bitcast %"class.std::vector.10"* %4 to i64*, !dbg !10623 + alias entry %88 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %5, i64 0, i32 0, i32 0, i32 1, !dbg !10654 + alias entry %89 = bitcast %struct.Comm** %88 to i64*, !dbg !10654 + alias entry %91 = bitcast %"class.std::vector.15"* %5 to i64*, !dbg !10658 + alias entry %104 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %6, i64 0, i32 0, i32 0, i32 1, !dbg !10685 + alias entry %105 = bitcast %struct.Comm** %104 to i64*, !dbg !10685 + alias entry %107 = bitcast %"class.std::vector.15"* %6 to i64*, !dbg !10686 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %"class.std::vector.10"* %3 + load (1.000000e+00) from %"class.std::vector.10"* %3 +Warning: wrong traversal order, or recursive call +On function _Z15distGetMaxIndexP7clmap_tRiPdS1_dPK4Commdldllld +Round 0 + alias entry %22 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 %21 + alias entry %28 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 0, !dbg !10320 + alias entry %33 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 1, !dbg !10330 + alias entry %35 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %32, i32 0, !dbg !10333 + alias entry %37 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 0, i32 1, !dbg !10335 + alias entry %41 = getelementptr inbounds double, double* %2, i64 %38, !dbg !10340 + alias entry %60 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %0, i64 1, !dbg !10352 + alias entry %80 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %79, i32 1, !dbg !10330 + alias entry %82 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %79, i32 0, !dbg !10333 + alias entry %88 = getelementptr inbounds double, double* %2, i64 %85, !dbg !10340 + alias entry %124 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %123, i32 1, !dbg !10330 + alias entry %126 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %123, i32 0, !dbg !10333 + alias entry %132 = getelementptr inbounds double, double* %2, i64 %129, !dbg !10340 +Round 1 +Round end + load (1.000000e+00) from double* %2 + load (1.000000e+00) from i32* %3 + load (1.000000e+00) from i32* %1 + load (5.000000e-01) from %struct.clmap_t* %0 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.Comm* %5 + load (2.500000e-01) from %struct.clmap_t* %0 + load (1.250000e-01) from double* %2 + load (9.984375e+00) from %struct.Comm* %5 + load (9.984375e+00) from %struct.Comm* %5 + load (4.984375e+00) from double* %2 + load (9.984375e+00) from %struct.Comm* %5 + load (9.984375e+00) from %struct.Comm* %5 + load (4.984375e+00) from double* %2 + Frequency of %struct.clmap_t* %0 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 1.109375e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 4.043750e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z24distBuildLocalMapCounterllP7clmap_tRiPdS1_PK4EdgePKllll +Round 0 + alias entry %20 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %19, i32 0, !dbg !10308 + alias entry %21 = getelementptr inbounds %struct.Edge, %struct.Edge* %6, i64 %19, i32 1, !dbg !10310 + alias entry %30 = getelementptr inbounds i64, i64* %7, i64 %29, !dbg !10326 + alias entry %37 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %35, i32 0, !dbg !10337 + alias entry %45 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %34, !dbg !10348 + alias entry %55 = getelementptr inbounds double, double* %4, i64 %49, !dbg !10358 + alias entry %61 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %34, i32 0, !dbg !10364 + alias entry %62 = getelementptr inbounds %struct.clmap_t, %struct.clmap_t* %2, i64 %34, i32 1, !dbg !10367 + alias entry %68 = bitcast double* %21 to i64*, !dbg !10375 + alias entry %71 = getelementptr inbounds double, double* %4, i64 %70, !dbg !10377 + alias entry %72 = bitcast double* %71 to i64*, !dbg !10378 +Round 1 +Round end + load (1.593750e+01) from %struct.Edge* %6 + load (7.937500e+00) from %struct.Edge* %6 + load (1.593750e+01) from i64* %7 + load (1.593750e+01) from i32* %3 + load (1.625000e+02) from %struct.clmap_t* %2 + load (9.937500e+00) from i32* %5 + load (4.937500e+00) from %struct.Edge* %6 + load (4.937500e+00) from double* %4 + store (4.937500e+00) to double* %4 + store (5.437500e+00) to %struct.clmap_t* %2 + store (5.437500e+00) to %struct.clmap_t* %2 + store (5.437500e+00) to i32* %3 + load (1.093750e+01) from i32* %5 + load (5.437500e+00) from %struct.Edge* %6 + store (5.437500e+00) to double* %4 + store (5.437500e+00) to i32* %5 + Frequency of %struct.clmap_t* %2 + load: 1.625000e+02 store: 1.087500e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %3 + load: 1.593750e+01 store: 5.437500e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 4.937500e+00 store: 1.037500e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %5 + load: 2.087500e+01 store: 5.437500e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %6 + load: 3.425000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 1.593750e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z27distExecuteLouvainIterationlPKlS0_PK4EdgeS0_PlPKdP4CommS8_dPdi +Round 0 + alias entry %18 = getelementptr inbounds i64, i64* %2, i64 %17, !dbg !10316 + alias entry %20 = getelementptr inbounds i64, i64* %4, i64 %0, !dbg !10322 + alias entry %23 = getelementptr inbounds i64, i64* %1, i64 %0, !dbg !10329 + alias entry %26 = getelementptr inbounds i64, i64* %1, i64 %25, !dbg !10332 + alias entry %30 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %22, i32 0, !dbg !10337 + alias entry %32 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %22, i32 1, !dbg !10341 + alias entry %47 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %46, i32 0, !dbg !10401 + alias entry %48 = getelementptr inbounds %struct.Edge, %struct.Edge* %3, i64 %46, i32 1, !dbg !10403 + alias entry %57 = getelementptr inbounds i64, i64* %4, i64 %56, !dbg !10414 + alias entry %93 = bitcast double* %48 to i64*, !dbg !10457 + alias entry %116 = getelementptr inbounds double, double* %10, i64 %0, !dbg !10470 + alias entry %120 = getelementptr inbounds double, double* %6, i64 %0, !dbg !10473 + alias entry %137 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %136, i32 1, !dbg !10533 + alias entry %139 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %136, i32 0, !dbg !10534 + alias entry %183 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %182, i32 1, !dbg !10533 + alias entry %185 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %182, i32 0, !dbg !10534 + alias entry %230 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %229, i32 1, !dbg !10572 + alias entry %231 = bitcast double* %230 to i64*, !dbg !10573 + alias entry %242 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %229, i32 0, !dbg !10575 + alias entry %244 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %22, i32 1, !dbg !10578 + alias entry %246 = bitcast double* %244 to i64*, !dbg !10581 + alias entry %257 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %22, i32 0, !dbg !10583 + alias entry %261 = getelementptr inbounds i64, i64* %5, i64 %0, !dbg !10587 + alias entry %264 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %263, i32 1, !dbg !10533 + alias entry %266 = getelementptr inbounds %struct.Comm, %struct.Comm* %7, i64 %263, i32 0, !dbg !10534 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (1.000000e+00) from i64* %4 + load (1.000000e+00) from i64* %1 + load (1.000000e+00) from i64* %1 + load (5.000000e-01) from %struct.Comm* %7 + load (5.000000e-01) from %struct.Comm* %7 + load (7.992188e+00) from %struct.Edge* %3 + load (3.992188e+00) from %struct.Edge* %3 + load (7.992188e+00) from i64* %4 + load (2.492188e+00) from %struct.Edge* %3 + load (2.742188e+00) from %struct.Edge* %3 + load (5.000000e-01) from double* %10 + store (5.000000e-01) to double* %10 + load (5.000000e-01) from double* %6 + load (1.250000e-01) from %struct.Comm* %7 + load (1.250000e-01) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + load (2.500000e-01) from %struct.Comm* %8 + load (2.500000e-01) from double* %6 + load (2.500000e-01) from %struct.Comm* %8 + store (1.000000e+00) to i64* %5 + load (4.992188e+00) from %struct.Comm* %7 + load (4.992188e+00) from %struct.Comm* %7 + Frequency of i64* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %3 + load: 1.721875e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 8.992188e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 0.000000e+00 store: 1.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 7.500000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %7 + load: 2.121875e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 5.000000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 5.000000e-01 store: 5.000000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z21distComputeModularityRK5GraphP4CommPKddi +Round 0 + alias entry %14 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10288 + alias entry %16 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10304 + base alias entry %35 = bitcast i8** %34 to double**, !dbg !10317 + base alias entry %37 = bitcast i8** %36 to double**, !dbg !10317 + base alias entry %45 = bitcast i8** %44 to %struct.Comm**, !dbg !10317 + base alias entry %47 = bitcast i8** %46 to %struct.Comm**, !dbg !10317 +Round 1 + base alias entry %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias entry %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias entry %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias entry %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Round 2 + base alias offset entry (2) %11 = alloca [5 x i8*], align 8 + base alias offset entry (2) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (-1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 + base alias offset entry (4) %11 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias offset entry (4) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Round 3 + base alias offset entry (4) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (4) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (3) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (3) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (2) %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias offset entry (2) %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias offset entry (1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 +Round 4 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.7 +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to double**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..8 +Round 0 + alias entry %39 = getelementptr inbounds double, double* %6, i64 %38, !dbg !10318 + alias entry %42 = getelementptr inbounds %struct.Comm, %struct.Comm* %8, i64 %38, i32 1, !dbg !10321 + alias entry %62 = bitcast double* %5 to i64*, !dbg !10329 + alias entry %74 = bitcast double* %7 to i64*, !dbg !10329 +Round 1 +Round end + load (1.010526e+01) from double* %6 + load (1.010526e+01) from %struct.Comm* %8 + load (2.105263e-01) from double* %5 + store (2.105263e-01) to double* %5 + load (2.105263e-01) from double* %7 + store (2.105263e-01) to double* %7 + load (2.105263e-01) from double* %5 + load (2.105263e-01) from double* %7 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %6 + load: 1.010526e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %7 + load: 4.210526e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %8 + load: 1.010526e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.9 +Round 0 + alias entry %3 = bitcast i8* %1 to double**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to double**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to double**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to double**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..10 +Round 0 + alias entry %65 = bitcast double* %3 to i64*, !dbg !10310 + alias entry %77 = bitcast double* %5 to i64*, !dbg !10310 +Round 1 +Round end + load (2.916667e-01) from double* %3 + store (2.916667e-01) to double* %3 + load (2.916667e-01) from double* %5 + store (2.916667e-01) to double* %5 + load (3.333333e-01) from double* %3 + load (3.333333e-01) from double* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 6.250000e-01 store: 2.916667e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 6.250000e-01 store: 2.916667e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z20distUpdateLocalCinfolP4CommPKS_ +Round 0 + base alias entry %15 = bitcast i8** %14 to %struct.Comm**, !dbg !10269 + base alias entry %17 = bitcast i8** %16 to %struct.Comm**, !dbg !10269 + base alias entry %20 = bitcast i8** %19 to %struct.Comm**, !dbg !10269 + base alias entry %22 = bitcast i8** %21 to %struct.Comm**, !dbg !10269 +Round 1 + base alias entry %14 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias entry %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 + base alias entry %19 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias entry %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 2 + base alias offset entry (1) %5 = alloca [3 x i8*], align 8 + base alias offset entry (1) %6 = alloca [3 x i8*], align 8 + base alias offset entry (2) %5 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %19 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias offset entry (2) %6 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 3 + base alias offset entry (1) %9 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %9 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %14 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias offset entry (1) %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 +Round 4 +Round end + Frequency of %struct.Comm* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..13 +Round 0 + alias entry %33 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %26, !dbg !10304 + alias entry %34 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %25, i32 1, !dbg !10304 + alias entry %35 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %26, !dbg !10304 + alias entry %36 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %25, i32 1, !dbg !10304 + alias entry %37 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %26, i32 1, !dbg !10304 + alias entry %38 = getelementptr %struct.Comm, %struct.Comm* %5, i64 %29, !dbg !10304 + alias entry %39 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %26, i32 1, !dbg !10304 + alias entry %40 = getelementptr %struct.Comm, %struct.Comm* %6, i64 %29, !dbg !10304 + alias entry %41 = bitcast double* %36 to %struct.Comm*, !dbg !10304 + alias entry %43 = bitcast double* %34 to %struct.Comm*, !dbg !10304 + alias entry %46 = bitcast %struct.Comm* %40 to double*, !dbg !10304 + alias entry %48 = bitcast %struct.Comm* %38 to double*, !dbg !10304 + alias entry %63 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %57, i32 0, !dbg !10304 + alias entry %64 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %58, i32 0, !dbg !10304 + alias entry %65 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %59, i32 0, !dbg !10304 + alias entry %66 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %60, i32 0, !dbg !10304 + alias entry %67 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %61, i32 0, !dbg !10304 + alias entry %68 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %62, i32 0, !dbg !10304 + alias entry %69 = bitcast i64* %63 to <4 x i64>*, !dbg !10304 + alias entry %70 = bitcast i64* %64 to <4 x i64>*, !dbg !10304 + alias entry %71 = bitcast i64* %65 to <4 x i64>*, !dbg !10304 + alias entry %72 = bitcast i64* %66 to <4 x i64>*, !dbg !10304 + alias entry %73 = bitcast i64* %67 to <4 x i64>*, !dbg !10304 + alias entry %74 = bitcast i64* %68 to <4 x i64>*, !dbg !10304 + alias entry %93 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %57, i32 0, !dbg !10307 + alias entry %94 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %58, i32 0, !dbg !10307 + alias entry %95 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %59, i32 0, !dbg !10307 + alias entry %96 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %60, i32 0, !dbg !10307 + alias entry %97 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %61, i32 0, !dbg !10307 + alias entry %98 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %62, i32 0, !dbg !10307 + alias entry %99 = bitcast i64* %93 to <4 x i64>*, !dbg !10307 + alias entry %100 = bitcast i64* %94 to <4 x i64>*, !dbg !10307 + alias entry %101 = bitcast i64* %95 to <4 x i64>*, !dbg !10307 + alias entry %102 = bitcast i64* %96 to <4 x i64>*, !dbg !10307 + alias entry %103 = bitcast i64* %97 to <4 x i64>*, !dbg !10307 + alias entry %104 = bitcast i64* %98 to <4 x i64>*, !dbg !10307 + alias entry %135 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %57, i32 1, !dbg !10309 + alias entry %136 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %58, i32 1, !dbg !10309 + alias entry %137 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %59, i32 1, !dbg !10309 + alias entry %138 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %60, i32 1, !dbg !10309 + alias entry %139 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %61, i32 1, !dbg !10309 + alias entry %140 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %62, i32 1, !dbg !10309 + alias entry %147 = getelementptr inbounds double, double* %135, i64 -1, !dbg !10309 + alias entry %148 = bitcast double* %147 to <4 x double>*, !dbg !10309 + alias entry %149 = getelementptr inbounds double, double* %136, i64 -1, !dbg !10309 + alias entry %150 = bitcast double* %149 to <4 x double>*, !dbg !10309 + alias entry %151 = getelementptr inbounds double, double* %137, i64 -1, !dbg !10309 + alias entry %152 = bitcast double* %151 to <4 x double>*, !dbg !10309 + alias entry %153 = getelementptr inbounds double, double* %138, i64 -1, !dbg !10309 + alias entry %154 = bitcast double* %153 to <4 x double>*, !dbg !10309 + alias entry %155 = getelementptr inbounds double, double* %139, i64 -1, !dbg !10309 + alias entry %156 = bitcast double* %155 to <4 x double>*, !dbg !10309 + alias entry %157 = getelementptr inbounds double, double* %140, i64 -1, !dbg !10309 + alias entry %158 = bitcast double* %157 to <4 x double>*, !dbg !10309 + alias entry %178 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %177, i32 0, !dbg !10304 + alias entry %180 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %177, i32 0, !dbg !10307 + alias entry %183 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %177, i32 1, !dbg !10318 + alias entry %185 = getelementptr inbounds %struct.Comm, %struct.Comm* %5, i64 %177, i32 1, !dbg !10309 +Round 1 +Round end + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %6 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + load (2.500000e+00) from %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + store (2.500000e+00) to %struct.Comm* %5 + load (9.088235e+00) from %struct.Comm* %6 + load (9.088235e+00) from %struct.Comm* %5 + store (9.088235e+00) to %struct.Comm* %5 + load (9.088235e+00) from %struct.Comm* %6 + load (9.088235e+00) from %struct.Comm* %5 + store (9.088235e+00) to %struct.Comm* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %5 + load: 3.317647e+01 store: 3.317647e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 3.317647e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..14 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z16distCleanCWandCUlPdP4Comm +Round 0 + base alias entry %17 = bitcast i8** %16 to double**, !dbg !10269 + base alias entry %19 = bitcast i8** %18 to double**, !dbg !10269 + base alias entry %22 = bitcast i8** %21 to %struct.Comm**, !dbg !10269 + base alias entry %24 = bitcast i8** %23 to %struct.Comm**, !dbg !10269 +Round 1 + base alias entry %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias entry %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 + base alias entry %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias entry %23 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 2 + base alias offset entry (1) %5 = alloca [3 x i8*], align 8 + base alias offset entry (1) %6 = alloca [3 x i8*], align 8 + base alias offset entry (2) %5 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %21 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 2, !dbg !10269 + base alias offset entry (2) %6 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %23 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 2, !dbg !10269 +Round 3 + base alias offset entry (1) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %13 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (2) %13 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 0, !dbg !10269 + base alias offset entry (1) %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %5, i64 0, i64 1, !dbg !10269 + base alias offset entry (1) %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %6, i64 0, i64 1, !dbg !10269 +Round 4 +Round end + Frequency of double* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..18 +Round 0 + alias entry %29 = getelementptr inbounds double, double* %5, i64 %28, !dbg !10304 + alias entry %30 = getelementptr inbounds %struct.Comm, %struct.Comm* %6, i64 %28, i32 0, !dbg !10309 + alias entry %33 = bitcast i64* %30 to i8*, !dbg !10299 +Round 1 +Round end + store (1.058333e+01) to double* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %5 + load: 0.000000e+00 store: 1.058333e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..19 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z21fillRemoteCommunitiesRK5GraphiiRKmS3_RKSt6vectorIlSaIlEES8_S8_S8_S8_RKS4_I4CommSaIS9_EERSt3mapIlS9_St4lessIlESaISt4pairIKlS9_EEERSt13unordered_mapIllSt4hashIlESt8equal_toIlESaISH_ISI_lEEESM_ +Round 0 + alias entry %126 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !11433 + alias entry %130 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !11449 + alias entry %132 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !11460 + alias entry %190 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 + alias entry %197 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 + alias entry %299 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 2, i32 0, !dbg !11792 + alias entry %300 = bitcast %"struct.std::__detail::_Hash_node_base"* %299 to %"struct.std::__detail::_Hash_node"**, !dbg !11793 + alias entry %308 = bitcast %"class.std::unordered_map"* %12 to i8**, !dbg !11836 + alias entry %310 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 1, !dbg !11842 + alias entry %313 = bitcast %"struct.std::__detail::_Hash_node_base"* %299 to i8*, !dbg !11846 + alias entry %316 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %8, i64 0, i32 0, i32 0, i32 0 + alias entry %317 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0 + alias entry %318 = getelementptr inbounds %"class.std::unordered_map", %"class.std::unordered_map"* %12, i64 0, i32 0, i32 0 + alias entry %319 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %320 = bitcast %"class.std::vector.0"* %319 to i64* + alias entry %321 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %322 = bitcast i64** %321 to i64* + alias entry %325 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %9, i64 0, i32 0, i32 0, i32 0 + alias entry %326 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %327 = bitcast %"class.std::vector.0"* %326 to i64* + alias entry %328 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %329 = bitcast i64** %328 to i64* + alias entry %800 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, !dbg !13393 + alias entry %801 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 1, !dbg !13405 + alias entry %802 = bitcast %"struct.std::_Rb_tree_node_base"** %801 to %"struct.std::_Rb_tree_node"**, !dbg !13405 + alias entry %808 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, !dbg !13419 + alias entry %809 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13425 + base alias entry %809 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13425 + alias entry %810 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13435 + base alias entry %810 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13435 + alias entry %811 = getelementptr inbounds %"class.std::map", %"class.std::map"* %11, i64 0, i32 0, i32 0, i32 2, !dbg !13437 + alias entry %812 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, !dbg !13442 + alias entry %813 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 1, !dbg !13447 + alias entry %814 = bitcast %"struct.std::_Rb_tree_node_base"** %813 to %"struct.std::_Rb_tree_node"**, !dbg !13447 + alias entry %820 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, !dbg !13452 + alias entry %821 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13455 + base alias entry %821 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !13455 + alias entry %822 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13462 + base alias entry %822 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 1, i32 3, !dbg !13462 + alias entry %823 = getelementptr inbounds %"class.std::map", %"class.std::map"* %13, i64 0, i32 0, i32 0, i32 2, !dbg !13464 + alias entry %828 = bitcast %"struct.std::_Rb_tree_node_base"** %801 to i64* + alias entry %830 = bitcast %"struct.std::_Rb_tree_node_base"* %808 to %"struct.std::_Rb_tree_node"* + alias entry %832 = bitcast %"struct.std::_Rb_tree_node_base"** %813 to i64* + alias entry %834 = bitcast %"struct.std::_Rb_tree_node_base"* %820 to %"struct.std::_Rb_tree_node"* + alias entry %943 = load %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"** %809, align 8, !dbg !14017, !tbaa !14018 + alias entry %998 = load %"struct.std::_Rb_tree_node_base"*, %"struct.std::_Rb_tree_node_base"** %821, align 8, !dbg !14306, !tbaa !14018 +Round 1 +Round end + load (1.000000e+00) from i64* %4 + load (9.999994e-01) from i64* %3 + load (9.999963e-01) from %class.Graph* %0 + load (9.999963e-01) from %class.Graph* %0 + load (9.999963e-01) from %class.Graph* %0 + load (9.999803e+00) from %"class.std::vector.0"* %6 + load (1.999960e+01) from %"class.std::vector.0"* %6 + load (6.249782e+00) from %"class.std::vector.0"* %5 + load (1.249956e+01) from %"class.std::vector.0"* %5 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (9.999777e-01) from %"class.std::unordered_map"* %12 + load (1.999809e+01) from %"class.std::vector.0"* %8 + load (1.999807e+01) from %"class.std::unordered_map"* %12 + load (1.999807e+01) from %"class.std::unordered_map"* %12 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..22 +Round 0 + alias entry %31 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %33 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from %"class.std::vector.0"* %4 + load (3.200000e-01) from %"class.std::vector.0"* %6 + load (1.020000e+01) from i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 1.020000e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %6 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.24 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..25 +Round 0 + alias entry %33 = getelementptr inbounds %"class.std::vector.29", %"class.std::vector.29"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.29"* %4 + load (3.157895e-01) from %"class.std::vector.0"* %3 + load (2.105263e-01) from i64* %5 + store (2.105263e-01) to i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.29"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.27 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..28 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..30 +Round 0 + alias entry %20 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %2, i64 0, i32 0, i32 0, i32 0, !dbg !10503 + alias entry %34 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %7, i64 0, i32 0, i32 0, i32 0 + alias entry %36 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from %"class.std::vector.0"* %2 + load (2.047500e+02) from %"class.std::vector.0"* %4 + load (2.047500e+02) from %"class.std::vector.15"* %7 + load (2.047500e+02) from %"class.std::vector.52"* %6 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.52"* %6 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %7 + load: 2.047500e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z22createCommunityMPITypev +Round 0 +Round end +On function _Z23destroyCommunityMPITypev +Round 0 +Round end +On function _Z23updateRemoteCommunitiesRK5GraphRSt6vectorI4CommSaIS3_EERKSt3mapIlS3_St4lessIlESaISt4pairIKlS3_EEEii +Round 0 + alias entry %19 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 0, !dbg !10869 + alias entry %46 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !11050 + alias entry %48 = getelementptr inbounds %"class.std::map", %"class.std::map"* %2, i64 0, i32 0, i32 0, i32 1, i32 2, !dbg !11068 + alias entry %49 = bitcast %"struct.std::_Rb_tree_node_base"** %48 to i64*, !dbg !11068 + alias entry %51 = getelementptr inbounds %"class.std::map", %"class.std::map"* %2, i64 0, i32 0, i32 0, i32 1, !dbg !11085 + alias entry %55 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6 + alias entry %56 = bitcast %"class.std::vector.0"* %55 to i64* + alias entry %57 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %58 = bitcast i64** %57 to i64* +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (9.999994e-01) from %class.Graph* %0 + load (9.999994e-01) from %"class.std::map"* %2 + load (1.999985e+01) from %class.Graph* %0 + load (1.999985e+01) from %class.Graph* %0 + Frequency of %class.Graph* %0 + load: 4.199970e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::map"* %2 + load: 9.999994e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..32 +Round 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.66", %"class.std::vector.66"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %30 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.137255e-01) from %"class.std::vector.66"* %4 + load (3.137255e-01) from %"class.std::vector.0"* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.137255e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.66"* %4 + load: 3.137255e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.34 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 + alias entry %7 = getelementptr inbounds i8, i8* %1, i64 8, !dbg !10261 + alias entry %8 = bitcast i8* %7 to i64**, !dbg !10261 + alias entry %10 = getelementptr inbounds i8, i8* %0, i64 8, !dbg !10261 + alias entry %11 = bitcast i8* %10 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 2.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..35 +Round 0 + alias entry %36 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 + alias entry %38 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (3.157895e-01) from %"class.std::vector.0"* %6 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + load (2.105263e-01) from i64* %5 + store (2.105263e-01) to i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %6 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..37 +Round 0 + alias entry %26 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i64* %2 + load (6.350000e+00) from %"class.std::vector.52"* %3 + load (6.350000e+00) from %"class.std::vector.15"* %4 + load (6.350000e+00) from i64* %5 + load (2.047500e+02) from i64* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.52"* %3 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.15"* %4 + load: 6.350000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.111000e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z18exchangeVertexReqsRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ii +Round 0 + alias entry %15 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10306 + alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10319 + alias entry %51 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 1, !dbg !10485 + alias entry %52 = bitcast i64** %51 to i64*, !dbg !10485 + alias entry %54 = bitcast %"class.std::vector.0"* %4 to i64*, !dbg !10489 + alias entry %71 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 1, !dbg !10517 + alias entry %72 = bitcast i64** %71 to i64*, !dbg !10517 + alias entry %74 = bitcast %"class.std::vector.0"* %3 to i64*, !dbg !10518 + alias entry %91 = bitcast %"class.std::vector.0"* %3 to i8** + alias entry %94 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 + alias entry %98 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0, !dbg !10598 + alias entry %99 = bitcast %"class.std::vector.0"* %4 to i8**, !dbg !10598 + alias entry %128 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 1, !dbg !10673 + alias entry %129 = bitcast i64** %128 to i64*, !dbg !10673 + alias entry %131 = bitcast %"class.std::vector.0"* %5 to i64*, !dbg !10674 + alias entry %147 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 1, !dbg !10696 + alias entry %148 = bitcast i64** %147 to i64*, !dbg !10696 + alias entry %150 = bitcast %"class.std::vector.0"* %6 to i64*, !dbg !10697 + alias entry %190 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 0 + alias entry %249 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 0 + alias entry %306 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %5, i64 0, i32 0, i32 0, i32 2, !dbg !11244 + alias entry %307 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %6, i64 0, i32 0, i32 0, i32 2, !dbg !11245 + alias entry %308 = bitcast i64** %306 to i64*, !dbg !11249 + alias entry %310 = bitcast i64** %307 to i64*, !dbg !11250 + alias entry %316 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 2, !dbg !11279 + alias entry %317 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 2, !dbg !11280 + alias entry %318 = bitcast i64** %316 to i64*, !dbg !11284 + alias entry %320 = bitcast i64** %317 to i64*, !dbg !11285 +Round 1 +Round end + load (1.000000e+00) from %class.Graph* %0 + load (1.000000e+00) from %class.Graph* %0 + load (9.999984e-01) from %"class.std::vector.0"* %4 + load (9.999984e-01) from %"class.std::vector.0"* %4 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..39 +Round 0 + alias entry %26 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 0, i32 0, i32 0, i32 0 + alias entry %27 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 1, i32 0, i32 0, i32 0 + alias entry %28 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 6 + alias entry %29 = bitcast %"class.std::vector.0"* %28 to i64* + alias entry %30 = getelementptr inbounds %class.Graph, %class.Graph* %3, i64 0, i32 6, i32 0, i32 0, i32 1 + alias entry %31 = bitcast i64** %30 to i64* + alias entry %32 = getelementptr inbounds %"class.std::vector.29", %"class.std::vector.29"* %5, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.988141e+02) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (3.180957e+03) from %class.Graph* %3 + load (1.590478e+03) from %"class.std::vector.29"* %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %class.Graph* %3 + load: 9.741684e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.29"* %5 + load: 1.590478e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp.reduction.reduction_func.41 +Round 0 + alias entry %3 = bitcast i8* %1 to i64**, !dbg !10261 + alias entry %5 = bitcast i8* %0 to i64**, !dbg !10261 +Round 1 +Round end + load (1.000000e+00) from i8* %1 + load (1.000000e+00) from i8* %0 + Frequency of i8* %0 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i8* %1 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..42 +Round 0 + alias entry %32 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %4, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (1.000000e+00) from i32* %2 + load (3.157895e-01) from %"class.std::vector.0"* %4 + load (2.105263e-01) from i64* %3 + store (2.105263e-01) to i64* %3 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %2 + load: 1.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 2.105263e-01 store: 2.105263e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %4 + load: 3.157895e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi +Round 0 + alias entry %68 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 2, !dbg !11180 + alias entry %85 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !11380 + alias entry %86 = bitcast i64** %85 to i64*, !dbg !11380 + alias entry %88 = bitcast %class.Graph* %2 to i64*, !dbg !11384 + alias entry %93 = bitcast %class.Graph* %2 to i8**, !dbg !11392 + alias entry %98 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 6, !dbg !11399 + alias entry %99 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 6, i32 0, i32 0, i32 1, !dbg !11402 + alias entry %100 = bitcast i64** %99 to i64*, !dbg !11402 + alias entry %102 = bitcast %"class.std::vector.0"* %98 to i64*, !dbg !11403 + alias entry %107 = bitcast %"class.std::vector.0"* %98 to i8**, !dbg !11410 + alias entry %112 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 1, !dbg !11417 + alias entry %113 = getelementptr inbounds %class.Graph, %class.Graph* %2, i64 0, i32 1, i32 0, i32 0, i32 1, !dbg !11424 + alias entry %114 = bitcast %struct.Edge** %113 to i64*, !dbg !11424 + alias entry %116 = bitcast %"class.std::vector.5"* %112 to i64*, !dbg !11428 + alias entry %121 = bitcast %"class.std::vector.5"* %112 to i8**, !dbg !11440 +Round 1 +Round end + load (9.999981e-01) from %class.Graph* %2 +Warning: wrong traversal order, or recursive call +On function .omp_outlined..45 +Round 0 +Round end + call (1.058333e+01, 2.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %5 + call (1.058333e+01, 1.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %6 + call (1.058333e+01, 1.721875e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Edge* %7 + call (1.058333e+01, 8.992188e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %8 + call (1.058333e+01, 0.000000e+00, 1.000000e+00, 0.000000e+00, 0.000000e+00) using i64* %9 + call (1.058333e+01, 7.500000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using double* %10 + call (1.058333e+01, 2.121875e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %11 + call (1.058333e+01, 5.000000e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %struct.Comm* %12 + call (1.058333e+01, 5.000000e-01, 5.000000e-01, 0.000000e+00, 0.000000e+00) using double* %14 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %5 + load: 2.116667e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %6 + load: 1.058333e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %7 + load: 1.822318e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %8 + load: 9.516732e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %9 + load: 0.000000e+00 store: 1.058333e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %10 + load: 7.937500e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %11 + load: 2.245651e+02 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %12 + load: 5.291667e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %14 + load: 5.291667e+00 store: 5.291667e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..46 +Round 0 +Round end + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %4 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Edge* %5 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %6 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %7 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %8 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %9 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.Comm* %10 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of double* %12 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_outlined..49 +Round 0 + alias entry %28 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %3, i64 0, i32 0, i32 0, i32 0 +Round 1 +Round end + load (3.200000e-01) from %"class.std::vector.0"* %3 + load (3.200000e-01) from i64** %4 + load (3.200000e-01) from i64** %5 + Frequency of i32* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i32* %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %3 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64** %4 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64** %5 + load: 3.200000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function main +Round 0 + base alias entry %14 = alloca i8**, align 8 + alias entry %33 = load i8**, i8*** %14, align 8, !dbg !10342, !tbaa !10335 +Round 1 +Round end + Frequency of i8** %1 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN11GenerateRGGC2ElP19ompi_communicator_t +Round 0 + alias entry %4 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 0, !dbg !10266 + alias entry %5 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10276 + base alias entry %5 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10276 + alias entry %6 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 5, !dbg !10279 + alias entry %8 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10281, !tbaa !10278 + alias entry %9 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 4, !dbg !10282 + alias entry %11 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 7, !dbg !10284 + alias entry %12 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 6, !dbg !10287 + alias entry %36 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 1, !dbg !10320 + alias entry %100 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10478, !tbaa !10278 + alias entry %171 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10565, !tbaa !10278 + alias entry %183 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2, !dbg !10579 + alias entry %190 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %5, align 8, !dbg !10583, !tbaa !10278 +Round 1 +Round end + store (1.000000e+00) to %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + store (2.500000e-01) to %class.GenerateRGG* %0 + store (3.437500e-01) to %class.GenerateRGG* %0 + store (2.500000e-01) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + load (5.000000e-01) from %class.GenerateRGG* %0 + load (7.656250e-01) from %class.GenerateRGG* %0 + load (7.656250e-01) from %class.GenerateRGG* %0 + store (1.000000e+00) to %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + load (1.000000e+00) from %class.GenerateRGG* %0 + Frequency of %class.GenerateRGG* %0 + load: 8.531250e+00 store: 6.843750e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %struct.ompi_communicator_t* %2 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN11GenerateRGG8generateEbbi +Round 0 + alias entry %27 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 1, !dbg !10306 + alias entry %75 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 6, !dbg !10592 + alias entry %112 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 7, !dbg !10709 + alias entry %153 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 0, !dbg !10828 + alias entry %156 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 4, !dbg !10832 + alias entry %160 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 5, !dbg !10836 + alias entry %362 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !10915 + alias entry %696 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 3, !dbg !11101 + alias entry %772 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 + alias entry %1095 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 + alias entry %1388 = getelementptr inbounds %class.GenerateRGG, %class.GenerateRGG* %0, i64 0, i32 2 +Round 1 +Round end + load (1.000000e+00) from %class.GenerateRGG* %0 + load (6.249994e-01) from %class.GenerateRGG* %0 + load (9.999990e-01) from %class.GenerateRGG* %0 + load (4.999995e-01) from %class.GenerateRGG* %0 + load (3.124994e-01) from %class.GenerateRGG* %0 + load (9.999985e-01) from %class.GenerateRGG* %0 + load (4.999993e-01) from %class.GenerateRGG* %0 + load (3.124992e-01) from %class.GenerateRGG* %0 + load (9.999971e-01) from %class.GenerateRGG* %0 + load (9.999971e-01) from %class.GenerateRGG* %0 + load (9.999962e-01) from %class.GenerateRGG* %0 + load (9.999962e-01) from %class.GenerateRGG* %0 + load (4.999966e-01) from %class.GenerateRGG* %0 + load (4.999971e-01) from %class.GenerateRGG* %0 + load (4.999971e-01) from %class.GenerateRGG* %0 + load (4.999966e-01) from %class.GenerateRGG* %0 + load (9.999923e-01) from %class.GenerateRGG* %0 + load (9.999914e-01) from %class.GenerateRGG* %0 + load (3.749968e-01) from %class.GenerateRGG* %0 + load (3.749964e-01) from %class.GenerateRGG* %0 + load (9.999890e-01) from %class.GenerateRGG* %0 + load (9.998746e-01) from %class.GenerateRGG* %0 + load (3.199362e+02) from %class.GenerateRGG* %0 + load (3.199361e+02) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (6.249210e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998736e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998726e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998717e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998707e-01) from %class.GenerateRGG* %0 + load (9.998698e-01) from %class.GenerateRGG* %0 + load (4.999349e-01) from %class.GenerateRGG* %0 + load (2.499674e-01) from %class.GenerateRGG* %0 + load (7.997451e+01) from %class.GenerateRGG* %0 + load (3.998725e+01) from %class.GenerateRGG* %0 + load (3.998725e+01) from %class.GenerateRGG* %0 + load (7.997448e+01) from %class.GenerateRGG* %0 + load (4.999063e-01) from %class.GenerateRGG* %0 + load (2.499531e-01) from %class.GenerateRGG* %0 + load (7.996993e+01) from %class.GenerateRGG* %0 + load (3.998497e+01) from %class.GenerateRGG* %0 + load (3.998497e+01) from %class.GenerateRGG* %0 + load (7.996991e+01) from %class.GenerateRGG* %0 + load (9.998126e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998116e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998107e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998091e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998082e-01) from %class.GenerateRGG* %0 + load (9.998072e-01) from %class.GenerateRGG* %0 + load (9.998015e-01) from %class.GenerateRGG* %0 + load (6.248724e-01) from %class.GenerateRGG* %0 + load (6.248718e-01) from %class.GenerateRGG* %0 + load (1.952724e-01) from %class.GenerateRGG* %0 + load (3.905445e-01) from %class.GenerateRGG* %0 + load (3.905442e-01) from %class.GenerateRGG* %0 + load (6.248393e-01) from %class.GenerateRGG* %0 + load (1.249644e+01) from %class.GenerateRGG* %0 + load (1.249643e+01) from %class.GenerateRGG* %0 + load (1.171538e+00) from %class.GenerateRGG* %0 + load (5.857690e-01) from %class.GenerateRGG* %0 + load (2.928845e-01) from %class.GenerateRGG* %0 + load (1.464422e-01) from %class.GenerateRGG* %0 + load (6.248387e-01) from %class.GenerateRGG* %0 + load (6.248381e-01) from %class.GenerateRGG* %0 + load (1.249638e+01) from %class.GenerateRGG* %0 + load (6.248253e-01) from %class.GenerateRGG* %0 + load (3.905154e-01) from %class.GenerateRGG* %0 + load (2.440719e-01) from %class.GenerateRGG* %0 + load (6.248247e-01) from %class.GenerateRGG* %0 + load (4.881438e+00) from %class.GenerateRGG* %0 + load (9.997431e-01) from %class.GenerateRGG* %0 + load (9.997421e-01) from %class.GenerateRGG* %0 + load (9.997406e-01) from %class.GenerateRGG* %0 + load (9.997406e-01) from %class.GenerateRGG* %0 + load (1.999481e+01) from %class.GenerateRGG* %0 + load (9.997388e-01) from %class.GenerateRGG* %0 + load (9.997385e-01) from %class.GenerateRGG* %0 + Frequency of %class.GenerateRGG* %0 + load: 1.246995e+03 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN14BinaryEdgeList4readEiiiSs +Round 0 + alias entry %39 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 4, !dbg !10380 + alias entry %41 = getelementptr inbounds %"class.std::basic_string", %"class.std::basic_string"* %4, i64 0, i32 0, i32 0, !dbg !10388 + alias entry %99 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 0, !dbg !10514 + alias entry %100 = bitcast %class.BinaryEdgeList* %0 to i8*, !dbg !10515 + alias entry %104 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 1, !dbg !10518 + alias entry %105 = bitcast i64* %104 to i8*, !dbg !10519 + alias entry %118 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 2, !dbg !10532 + alias entry %182 = getelementptr inbounds %class.BinaryEdgeList, %class.BinaryEdgeList* %0, i64 0, i32 3, !dbg !10605 +Round 1 +Round end + load (9.999971e-01) from %class.BinaryEdgeList* %0 + load (9.999971e-01) from %"class.std::basic_string"* %4 + load (6.249948e-01) from %class.BinaryEdgeList* %0 + load (9.999905e-01) from %class.BinaryEdgeList* %0 + store (9.999905e-01) to %class.BinaryEdgeList* %0 + load (9.999895e-01) from %class.BinaryEdgeList* %0 + load (9.999886e-01) from %class.BinaryEdgeList* %0 + load (9.999886e-01) from %class.BinaryEdgeList* %0 + load (9.999729e-01) from %class.BinaryEdgeList* %0 + store (9.999729e-01) to %class.BinaryEdgeList* %0 + load (9.999714e-01) from %class.BinaryEdgeList* %0 + load (9.999714e-01) from %class.BinaryEdgeList* %0 + load (9.999547e-01) from %class.BinaryEdgeList* %0 + load (1.999909e+01) from %class.BinaryEdgeList* %0 + Frequency of %class.BinaryEdgeList* %0 + load: 2.962391e+01 store: 1.999963e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::basic_string"* %4 + load: 9.999971e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt8_Rb_treeIlSt4pairIKl4CommESt10_Select1stIS3_ESt4lessIlESaIS3_EE8_M_eraseEPSt13_Rb_tree_nodeIS3_E +Round 0 +Round end +Warning: wrong traversal order, or recursive call +On function _ZN5GraphC2EllllP19ompi_communicator_t +Round 0 + alias entry %8 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, !dbg !10272 + alias entry %9 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 1, !dbg !10272 + alias entry %10 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 2, !dbg !10309 + alias entry %11 = bitcast %class.Graph* %0 to i8*, !dbg !10309 + alias entry %12 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 3, !dbg !10320 + alias entry %13 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 4, !dbg !10322 + alias entry %14 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 5, !dbg !10324 + alias entry %15 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, !dbg !10272 + alias entry %16 = bitcast %"class.std::vector.0"* %15 to i8*, !dbg !10332 + alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10334 + base alias entry %17 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 7, !dbg !10334 + alias entry %18 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 9, !dbg !10336 + alias entry %21 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %17, align 8, !dbg !10338, !tbaa !10335 + alias entry %22 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 8, !dbg !10339 + alias entry %28 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, i32 0, i32 0, i32 1, !dbg !10361 + alias entry %29 = bitcast i64** %28 to i64*, !dbg !10361 + alias entry %31 = bitcast %class.Graph* %0 to i64*, !dbg !10365 + alias entry %45 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 1, i32 0, i32 0, i32 1, !dbg !10416 + alias entry %46 = bitcast %struct.Edge** %45 to i64*, !dbg !10416 + alias entry %48 = bitcast %"class.std::vector.5"* %9 to i64*, !dbg !10420 + alias entry %64 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 6, i32 0, i32 0, i32 1, !dbg !10455 + alias entry %65 = bitcast i64** %64 to i64*, !dbg !10455 + alias entry %67 = bitcast %"class.std::vector.0"* %15 to i64*, !dbg !10456 + alias entry %76 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %15, i64 0, i32 0, i32 0, i32 0 + alias entry %110 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %15, i64 0, i32 0, i32 0, i32 0, !dbg !10511 + alias entry %116 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %9, i64 0, i32 0, i32 0, i32 0, !dbg !10547 + alias entry %122 = getelementptr inbounds %class.Graph, %class.Graph* %0, i64 0, i32 0, i32 0, i32 0, i32 0, !dbg !10576 +Round 1 +Round end + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + store (1.000000e+00) to %class.Graph* %0 + load (9.999990e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 + load (9.999980e-01) from %class.Graph* %0 +Warning: wrong traversal order, or recursive call +On function _ZN3LCGC2EjPdlP19ompi_communicator_t +Round 0 + alias entry %6 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 3, !dbg !10268 + alias entry %7 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 4, !dbg !10277 + alias entry %8 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 6, !dbg !10279 + base alias entry %8 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 6, !dbg !10279 + alias entry %9 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, !dbg !10281 + alias entry %10 = bitcast %"class.std::vector.0"* %9 to i8*, !dbg !10300 + alias entry %11 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0, !dbg !10302 + base alias entry %11 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0, !dbg !10302 + alias entry %12 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 1, !dbg !10306 + alias entry %15 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %11, align 8, !dbg !10308, !tbaa !10305 + alias entry %16 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 2, !dbg !10309 + alias entry %20 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, i32 0, i32 0, i32 1, !dbg !10326 + alias entry %21 = bitcast i64** %20 to i64*, !dbg !10326 + alias entry %23 = bitcast %"class.std::vector.0"* %9 to i64*, !dbg !10330 + alias entry %42 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10359 + alias entry %45 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %9, i64 0, i32 0, i32 0, i32 0, !dbg !10374 + alias entry %52 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10399 + alias entry %53 = bitcast i64* %52 to i8*, !dbg !10400 + alias entry %54 = load %struct.ompi_communicator_t*, %struct.ompi_communicator_t** %11, align 8, !dbg !10401, !tbaa !10305 +Round 1 +Round end + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + store (1.000000e+00) to %class.LCG* %0 + load (9.999989e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 + load (9.999982e-01) from %class.LCG* %0 +Warning: wrong traversal order, or recursive call +On function _ZNSt24uniform_int_distributionIiEclISt26linear_congruential_engineImLm16807ELm0ELm2147483647EEEEiRT_RKNS0_10param_typeE +Round 0 + alias entry %5 = getelementptr inbounds %"struct.std::uniform_int_distribution::param_type", %"struct.std::uniform_int_distribution::param_type"* %2, i64 0, i32 1, !dbg !10267 + alias entry %8 = getelementptr inbounds %"struct.std::uniform_int_distribution::param_type", %"struct.std::uniform_int_distribution::param_type"* %2, i64 0, i32 0, !dbg !10279 + alias entry %19 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0 + alias entry %37 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0 + alias entry %51 = getelementptr inbounds %"class.std::linear_congruential_engine", %"class.std::linear_congruential_engine"* %1, i64 0, i32 0, !dbg !10376 +Round 1 +Round end + load (1.000000e+00) from %"struct.std::uniform_int_distribution::param_type"* %2 + load (1.000000e+00) from %"struct.std::uniform_int_distribution::param_type"* %2 + load (5.000000e-01) from %"class.std::linear_congruential_engine"* %1 + store (5.000000e-01) to %"class.std::linear_congruential_engine"* %1 +Warning: wrong traversal order, or recursive call +On function _ZNSt6vectorIlSaIlEEaSERKS1_ +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 1, !dbg !10278 + alias entry %6 = bitcast i64** %5 to i64*, !dbg !10278 + alias entry %8 = bitcast %"class.std::vector.0"* %1 to i64*, !dbg !10285 + alias entry %12 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10294 + alias entry %13 = bitcast i64** %12 to i64*, !dbg !10294 + alias entry %15 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10296 + alias entry %.phi.trans.insert = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %35 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10460 + alias entry %42 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10490 + alias entry %43 = bitcast i64** %42 to i64*, !dbg !10490 + alias entry %54 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %1, i64 0, i32 0, i32 0, i32 0, !dbg !10573 + alias entry %74 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10633 + alias entry %77 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10635 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %1 + load (9.765625e-02) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %1 + load (6.250000e-01) from %"class.std::vector.0"* %0 + store (6.250000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.578125e+00 store: 1.250000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"class.std::vector.0"* %1 + load: 1.445312e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorIlSaIlEE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPlS1_EEmRKl +Round 0 + alias entry %8 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10281 + alias entry %9 = bitcast i64** %8 to i64*, !dbg !10281 + alias entry %11 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10288 + alias entry %12 = bitcast i64** %11 to i64*, !dbg !10288 + alias entry %543 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10728 + alias entry %729 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10820 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from i64* %3 + load (9.765625e-02) from %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + load (9.765625e-02) from %"class.std::vector.0"* %0 + store (1.562500e-01) to %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from i64* %3 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.382812e+00 store: 1.406250e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of i64* %3 + load: 6.250000e-01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI4EdgeSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast %struct.Edge** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %83 = bitcast %"class.std::vector.5"* %0 to i64*, !dbg !10375 + alias entry %104 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %111 = getelementptr inbounds %"class.std::vector.5", %"class.std::vector.5"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10431 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.5"* %0 + load (6.250000e-01) from %"class.std::vector.5"* %0 + load (3.125000e-01) from %"class.std::vector.5"* %0 + load (1.953125e-01) from %"class.std::vector.5"* %0 + load (1.953125e-01) from %"class.std::vector.5"* %0 + load (3.125000e-01) from %"class.std::vector.5"* %0 + store (3.125000e-01) to %"class.std::vector.5"* %0 + store (3.125000e-01) to %"class.std::vector.5"* %0 + Frequency of %"class.std::vector.5"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZN3LCG18parallel_prefix_opEv +Round 0 + alias entry %10 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 4, !dbg !10283 + alias entry %168 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 1, !dbg !10362 + alias entry %174 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 2, !dbg !10269 + alias entry %178 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 0 + alias entry %186 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 5, !dbg !10373 + alias entry %250 = getelementptr inbounds %class.LCG, %class.LCG* %0, i64 0, i32 7, i32 0, i32 0, i32 0, !dbg !10373 +Round 1 +Round end + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (2.005882e+01) from %class.LCG* %0 + load (1.000000e+00) from %class.LCG* %0 + Frequency of %class.LCG* %0 + load: 8.523529e+01 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI9EdgeTupleSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10273 + alias entry %6 = bitcast %struct.EdgeTuple** %5 to i64*, !dbg !10273 + alias entry %8 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10280 + alias entry %60 = bitcast %"class.std::vector.84"* %0 to i64*, !dbg !10369 + alias entry %81 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %88 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10425 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + Frequency of %"class.std::vector.84"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_E_ET_SC_SC_T0_St26random_access_iterator_tag +Round 0 +Round end +On function _ZNSt6vectorI9EdgeTupleSaIS0_EE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPS0_S2_EEEEvS7_T_S8_St20forward_iterator_tag +Round 0 + alias entry %13 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10344 + alias entry %14 = bitcast %struct.EdgeTuple** %13 to i64*, !dbg !10344 + alias entry %16 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10351 + alias entry %17 = bitcast %struct.EdgeTuple** %16 to i64*, !dbg !10351 + alias entry %116 = bitcast %"class.std::vector.84"* %0 to i64*, !dbg !10799 + alias entry %137 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %142 = getelementptr inbounds %"class.std::vector.84", %"class.std::vector.84"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10851 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (6.250000e-01) from %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (9.765625e-02) from %"class.std::vector.84"* %0 + store (1.562500e-01) to %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (1.953125e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + load (3.125000e-01) from %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + store (3.125000e-01) to %"class.std::vector.84"* %0 + Frequency of %"class.std::vector.84"* %0 + load: 2.675781e+00 store: 1.406250e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZSt16__introsort_loopIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEElZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_T0_T1_ +Round 0 +Round end +On function _ZSt22__final_insertion_sortIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_T0_ +Round 0 +Round end +On function _ZSt13__heap_selectIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_SC_T0_ +Round 0 +Round end +On function _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEElS2_ZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_T0_SD_T1_T2_ +Round 0 +Round end +On function _ZSt22__move_median_to_firstIN9__gnu_cxx17__normal_iteratorIP9EdgeTupleSt6vectorIS2_SaIS2_EEEEZN11GenerateRGG8generateEbbiEUlRKS2_SA_E_EvT_SC_SC_SC_T0_ +Round 0 +Round end +On function _ZNSt6vectorIlSaIlEE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast i64** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %20 = bitcast i64** %8 to i64*, !dbg !10380 + alias entry %21 = bitcast %"class.std::vector.0"* %0 to i64*, !dbg !10381 + alias entry %42 = getelementptr inbounds %"class.std::vector.0", %"class.std::vector.0"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %65 = bitcast %"class.std::vector.0"* %0 to i8**, !dbg !10628 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (6.250000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (3.125000e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + load (1.953125e-01) from %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + store (3.125000e-01) to %"class.std::vector.0"* %0 + Frequency of %"class.std::vector.0"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorIdSaIdEE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10274 + alias entry %6 = bitcast double** %5 to i64*, !dbg !10274 + alias entry %8 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10281 + alias entry %20 = bitcast double** %8 to i64*, !dbg !10381 + alias entry %21 = bitcast %"class.std::vector.10"* %0 to i64*, !dbg !10382 + alias entry %42 = getelementptr inbounds %"class.std::vector.10", %"class.std::vector.10"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %65 = bitcast %"class.std::vector.10"* %0 to i8**, !dbg !10630 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.10"* %0 + load (6.250000e-01) from %"class.std::vector.10"* %0 + load (3.125000e-01) from %"class.std::vector.10"* %0 + load (3.125000e-01) from %"class.std::vector.10"* %0 + load (1.953125e-01) from %"class.std::vector.10"* %0 + load (1.953125e-01) from %"class.std::vector.10"* %0 + store (3.125000e-01) to %"class.std::vector.10"* %0 + store (3.125000e-01) to %"class.std::vector.10"* %0 + Frequency of %"class.std::vector.10"* %0 + load: 2.265625e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI4CommSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10460 + alias entry %6 = bitcast %struct.Comm** %5 to i64*, !dbg !10460 + alias entry %8 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10467 + alias entry %20 = bitcast %"class.std::vector.15"* %0 to i64*, !dbg !10551 + alias entry %41 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %48 = getelementptr inbounds %"class.std::vector.15", %"class.std::vector.15"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10607 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.15"* %0 + load (6.250000e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + load (1.953125e-01) from %"class.std::vector.15"* %0 + load (1.953125e-01) from %"class.std::vector.15"* %0 + load (3.125000e-01) from %"class.std::vector.15"* %0 + store (3.125000e-01) to %"class.std::vector.15"* %0 + store (3.125000e-01) to %"class.std::vector.15"* %0 + Frequency of %"class.std::vector.15"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt27__uninitialized_default_n_1ILb0EE18__uninit_default_nIPSt13unordered_setIlSt4hashIlESt8equal_toIlESaIlEEmEEvT_T0_ +Round 0 +Round end + Frequency of %"class.std::unordered_set"* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt10_HashtableIlSt4pairIKllESaIS2_ENSt8__detail10_Select1stESt8equal_toIlESt4hashIlENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE21_M_insert_unique_nodeEmmPNS4_10_Hash_nodeIS2_Lb0EEE +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 4, !dbg !10268 + alias entry %6 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 4, i32 1, !dbg !10275 + alias entry %8 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 1, !dbg !10282 + alias entry %10 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 3, !dbg !10288 + alias entry %17 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 0 + alias entry %29 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 2, i32 0, !dbg !10428 + alias entry %30 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to %"struct.std::__detail::_Hash_node"**, !dbg !10429 + alias entry %32 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %29, i64 0, i32 0, !dbg !10432 + alias entry %35 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to i64* + base alias entry %44 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %28, i64 %43, !dbg !10509 + alias entry %61 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10529, !tbaa !10511 + alias entry %62 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %61, i64 0, i32 0, !dbg !10530 + alias entry %76 = bitcast %"class.std::_Hashtable"* %0 to i8**, !dbg !10550 + alias entry %82 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i8*, !dbg !10618 + alias entry %86 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 0, !dbg !10296 + alias entry %93 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, !dbg !10627 + alias entry %94 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i64*, !dbg !10628 + base alias entry %96 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %95, i64 0, i32 0, !dbg !10630 + alias entry %98 = getelementptr inbounds %"class.std::_Hashtable", %"class.std::_Hashtable"* %0, i64 0, i32 2, i32 0, !dbg !10639 + alias entry %99 = bitcast %"struct.std::__detail::_Hash_node_base"* %98 to i64*, !dbg !10640 + alias entry %101 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, !dbg !10641 + alias entry %102 = getelementptr inbounds %"struct.std::__detail::_Hash_node", %"struct.std::__detail::_Hash_node"* %3, i64 0, i32 0, i32 0, !dbg !10641 + alias entry %103 = bitcast %"struct.std::__detail::_Hash_node"* %3 to i64*, !dbg !10642 + alias entry %104 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %98, i64 0, i32 0, !dbg !10645 + base alias entry %104 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %98, i64 0, i32 0, !dbg !10645 + base alias entry %113 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %84, i64 %112, !dbg !10676 + base alias entry %117 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %116, i64 %85, !dbg !10678 +Round 1 +Warning: the first offset is not constant + alias entry %45 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10509, !tbaa !10511 + alias entry %57 = bitcast %"struct.std::__detail::_Hash_node_base"* %45 to i64*, !dbg !10525 + base alias offset entry (0) %95 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %87, align 8, !dbg !10629, !tbaa !10511 +Warning: the first offset is not constant +Warning: the first offset is not constant +Round 2 +Warning: the first offset is not constant +Warning: the first offset is not constant +Warning: the first offset is not constant +Round end + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (1.000000e+00) from %"class.std::_Hashtable"* %0 + load (5.000000e-01) from %"class.std::_Hashtable"* %0 + load (4.999995e-01) from %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + load (3.749996e+00) from %"class.std::_Hashtable"* %0 + store (3.749996e+00) to %"class.std::_Hashtable"* %0 + load (6.249994e+00) from %"class.std::_Hashtable"* %0 + store (6.249994e+00) to %"class.std::_Hashtable"* %0 + store (4.768372e-07) to %"class.std::_Hashtable"* %0 + load (4.999995e-01) from %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + store (4.999995e-01) to %"class.std::_Hashtable"* %0 + store (6.249997e-01) to %"struct.std::__detail::_Hash_node"* %3 + load (3.749998e-01) from %"class.std::_Hashtable"* %0 + store (3.749998e-01) to %"struct.std::__detail::_Hash_node"* %3 + store (3.749998e-01) to %"class.std::_Hashtable"* %0 + load (3.749998e-01) from %"struct.std::__detail::_Hash_node"* %3 + load (2.343749e-01) from %"class.std::_Hashtable"* %0 + load (2.343749e-01) from %"class.std::_Hashtable"* %0 + load (9.999995e-01) from %"class.std::_Hashtable"* %0 + store (9.999995e-01) to %"class.std::_Hashtable"* %0 + Frequency of %"class.std::_Hashtable"* %0 + load: 1.634374e+01 store: 1.287499e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"struct.std::__detail::_Hash_node"* %3 + load: 3.749998e-01 store: 9.999995e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt10_HashtableIllSaIlENSt8__detail9_IdentityESt8equal_toIlESt4hashIlENS1_18_Mod_range_hashingENS1_20_Default_ranged_hashENS1_20_Prime_rehash_policyENS1_17_Hashtable_traitsILb0ELb1ELb1EEEE21_M_insert_unique_nodeEmmPNS1_10_Hash_nodeIlLb0EEE +Round 0 + alias entry %5 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 4, !dbg !10268 + alias entry %6 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 4, i32 1, !dbg !10275 + alias entry %8 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 1, !dbg !10282 + alias entry %10 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 3, !dbg !10288 + alias entry %17 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 0 + alias entry %29 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 2, i32 0, !dbg !10428 + alias entry %30 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to %"struct.std::__detail::_Hash_node.61"**, !dbg !10429 + alias entry %32 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %29, i64 0, i32 0, !dbg !10432 + alias entry %35 = bitcast %"struct.std::__detail::_Hash_node_base"* %29 to i64* + base alias entry %44 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %28, i64 %43, !dbg !10469 + alias entry %61 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10489, !tbaa !10471 + alias entry %62 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %61, i64 0, i32 0, !dbg !10490 + alias entry %76 = bitcast %"class.std::_Hashtable.34"* %0 to i8**, !dbg !10510 + alias entry %82 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i8*, !dbg !10578 + alias entry %86 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 0, !dbg !10296 + alias entry %93 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, !dbg !10587 + alias entry %94 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i64*, !dbg !10588 + base alias entry %96 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %95, i64 0, i32 0, !dbg !10590 + alias entry %98 = getelementptr inbounds %"class.std::_Hashtable.34", %"class.std::_Hashtable.34"* %0, i64 0, i32 2, i32 0, !dbg !10599 + alias entry %99 = bitcast %"struct.std::__detail::_Hash_node_base"* %98 to i64*, !dbg !10600 + alias entry %101 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, !dbg !10601 + alias entry %102 = getelementptr inbounds %"struct.std::__detail::_Hash_node.61", %"struct.std::__detail::_Hash_node.61"* %3, i64 0, i32 0, i32 0, !dbg !10601 + alias entry %103 = bitcast %"struct.std::__detail::_Hash_node.61"* %3 to i64*, !dbg !10602 + alias entry %104 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %98, i64 0, i32 0, !dbg !10605 + base alias entry %104 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base", %"struct.std::__detail::_Hash_node_base"* %98, i64 0, i32 0, !dbg !10605 + base alias entry %113 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %84, i64 %112, !dbg !10630 + base alias entry %117 = getelementptr inbounds %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %116, i64 %85, !dbg !10632 +Round 1 +Warning: the first offset is not constant + alias entry %45 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %44, align 8, !dbg !10469, !tbaa !10471 + alias entry %57 = bitcast %"struct.std::__detail::_Hash_node_base"* %45 to i64*, !dbg !10485 + base alias offset entry (0) %95 = load %"struct.std::__detail::_Hash_node_base"*, %"struct.std::__detail::_Hash_node_base"** %87, align 8, !dbg !10589, !tbaa !10471 +Warning: the first offset is not constant +Warning: the first offset is not constant +Round 2 +Warning: the first offset is not constant +Warning: the first offset is not constant +Warning: the first offset is not constant +Round end + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (1.000000e+00) from %"class.std::_Hashtable.34"* %0 + load (5.000000e-01) from %"class.std::_Hashtable.34"* %0 + load (4.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + load (3.749996e+00) from %"class.std::_Hashtable.34"* %0 + store (3.749996e+00) to %"class.std::_Hashtable.34"* %0 + load (6.249994e+00) from %"class.std::_Hashtable.34"* %0 + store (6.249994e+00) to %"class.std::_Hashtable.34"* %0 + store (4.768372e-07) to %"class.std::_Hashtable.34"* %0 + load (4.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + store (4.999995e-01) to %"class.std::_Hashtable.34"* %0 + store (6.249997e-01) to %"struct.std::__detail::_Hash_node.61"* %3 + load (3.749998e-01) from %"class.std::_Hashtable.34"* %0 + store (3.749998e-01) to %"struct.std::__detail::_Hash_node.61"* %3 + store (3.749998e-01) to %"class.std::_Hashtable.34"* %0 + load (3.749998e-01) from %"struct.std::__detail::_Hash_node.61"* %3 + load (2.343749e-01) from %"class.std::_Hashtable.34"* %0 + load (2.343749e-01) from %"class.std::_Hashtable.34"* %0 + load (9.999995e-01) from %"class.std::_Hashtable.34"* %0 + store (9.999995e-01) to %"class.std::_Hashtable.34"* %0 + Frequency of %"class.std::_Hashtable.34"* %0 + load: 1.634374e+01 store: 1.287499e+01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) + Frequency of %"struct.std::__detail::_Hash_node.61"* %3 + load: 3.749998e-01 store: 9.999995e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _ZNSt6vectorI8CommInfoSaIS0_EE17_M_default_appendEm +Round 0 + alias entry %7 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 2, !dbg !10273 + alias entry %8 = bitcast %struct.CommInfo** %7 to i64*, !dbg !10273 + alias entry %10 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 1, !dbg !10280 + alias entry %54 = bitcast %struct.CommInfo** %10 to i64*, !dbg !10394 + alias entry %55 = bitcast %"class.std::vector.52"* %0 to i64*, !dbg !10395 + alias entry %76 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 0 + alias entry %84 = getelementptr inbounds %"class.std::vector.52", %"class.std::vector.52"* %0, i64 0, i32 0, i32 0, i32 0, !dbg !10449 + alias entry %133 = bitcast %"class.std::vector.52"* %0 to i8**, !dbg !10651 +Round 1 +Round end + load (6.250000e-01) from %"class.std::vector.52"* %0 + load (6.250000e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + load (1.953125e-01) from %"class.std::vector.52"* %0 + load (1.953125e-01) from %"class.std::vector.52"* %0 + load (3.125000e-01) from %"class.std::vector.52"* %0 + store (3.125000e-01) to %"class.std::vector.52"* %0 + store (3.125000e-01) to %"class.std::vector.52"* %0 + Frequency of %"class.std::vector.52"* %0 + load: 2.578125e+00 store: 6.250000e-01 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function _GLOBAL__sub_I_main.cpp +Round 0 +Round end +On function .omp_offloading.descriptor_unreg +Round 0 +Round end + Frequency of i8* %0 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 0.000000e+00 (target) +On function .omp_offloading.descriptor_reg.nvptx64-nvidia-cuda +Round 0 +Round end + ---- Identify Target Regions ---- + target call: %49 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396.region_id, i32 5, i8** nonnull %24, i8** nonnull %26, i64* nonnull %28, i64* getelementptr inbounds ([5 x i64], [5 x i64]* @.offload_maptypes.0, i64 0, i64 0), i32 0, i32 0), !dbg !10317 + target call: %24 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %9, i8** nonnull %11, i64* nonnull %13, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0), !dbg !10269 + target call: %26 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %11, i8** nonnull %13, i64* nonnull %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0), !dbg !10269 + target call: %258 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20.1, i64 0, i64 0), i32 0, i32 0) + to label %259 unwind label %319, !dbg !11559 + target call: %276 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368.region_id, i32 12, i8** nonnull %200, i8** nonnull %202, i64* nonnull %204, i64* getelementptr inbounds ([12 x i64], [12 x i64]* @.offload_maptypes.47.2, i64 0, i64 0), i32 0, i32 0), !dbg !11584 + target call: %325 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15.3, i64 0, i64 0), i32 0, i32 0) + to label %326 unwind label %319, !dbg !11667 + ---- Target Distance Calculation ---- +_Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi converges after 3 iterations +target 0: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 1: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 2: (0: 1.000000e+00) (1: 1.000000e+00) (2: 1.000000e+00) (3: 1.000000e+00) (4: 1.000000e+00) (5: 1.000000e+00) +target 3: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 9.152967e+00) (4: 1.000095e+00) (5: 2.000190e+00) +target 4: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 8.152880e+00) (4: 9.091440e+00) (5: 1.000095e+00) +target 5: (0: 1.010000e+02) (1: 1.010000e+02) (2: 1.010000e+02) (3: 7.152791e+00) (4: 8.091353e+00) (5: 9.029914e+00) + ---- OMP (/tmp/main-cdf4fe.bc, powerpc64le-unknown-linux-gnu) ---- +new entry %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 +new entry %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 +new entry %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 +new entry %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 +new entry %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 +new entry %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 +new entry %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 +new entry %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 +new entry %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 +Round 0 + base alias entry %130 = bitcast i64** %29 to i8**, !dbg !11450 + base alias entry %142 = bitcast i64** %30 to i8**, !dbg !11479 + alias entry %147 = bitcast i8* %145 to %struct.Comm*, !dbg !11487 + alias entry %158 = bitcast i8* %156 to double*, !dbg !11511 + base alias entry %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias entry %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 + base alias entry %192 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 2 + base alias entry %193 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 2 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias entry %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias entry %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias entry %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias entry %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias entry %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias entry %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias entry %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias entry %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias entry %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias entry %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias entry %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias entry %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias entry %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias entry %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 +Warning: reach to function declaration __kmpc_fork_teams + alias entry (func arg) %struct.Comm* %1 + alias entry (func arg) double* %2 +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 1 +Round 1 + base alias entry %35 = bitcast i8** %34 to double**, !dbg !10317 + base alias entry %37 = bitcast i8** %36 to double**, !dbg !10317 + base alias entry %45 = bitcast i8** %44 to %struct.Comm**, !dbg !10317 + base alias entry %47 = bitcast i8** %46 to %struct.Comm**, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %29 = alloca i64*, align 8 + base alias entry %30 = alloca i64*, align 8 + base alias offset entry (1) %16 = alloca [3 x i8*], align 8 + base alias offset entry (1) %17 = alloca [3 x i8*], align 8 + base alias offset entry (2) %16 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %192 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 2 + base alias offset entry (2) %17 = alloca [3 x i8*], align 8 + base alias offset entry (-1) %193 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 2 + base alias offset entry (1) %31 = alloca [12 x i8*], align 8 + base alias offset entry (1) %32 = alloca [12 x i8*], align 8 + base alias offset entry (2) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (2) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-2) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (-1) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (3) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-2) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (-1) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (-3) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-2) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-1) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (-3) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-2) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-1) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (-4) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-3) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-2) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (-4) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-3) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-2) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (6) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-5) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-4) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-3) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (6) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-5) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-4) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-3) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (7) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-6) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-5) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-4) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-1) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (7) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-6) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-5) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-4) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-1) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (8) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-7) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-6) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-5) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-2) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-1) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (8) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-7) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-6) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-5) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-2) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-1) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-8) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-7) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-6) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-3) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-2) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-1) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-8) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-7) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-6) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-3) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-2) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-1) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (10) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-9) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-8) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-7) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-4) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-3) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-2) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (10) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-9) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-8) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-7) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-4) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-3) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-2) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-10) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-9) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-8) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-5) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-4) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-3) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-1) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-10) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-9) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-8) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-5) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-4) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-3) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-1) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams + alias entry %263 = load i64*, i64** %29, align 8, !dbg !11584, !tbaa !11451 + alias entry %264 = load i64*, i64** %30, align 8, !dbg !11584, !tbaa !11451 + alias entry %274 = ptrtoint i64* %263 to i64, !dbg !11584 + alias entry %275 = ptrtoint i64* %264 to i64, !dbg !11584 + base alias entry %215 = bitcast i8** %214 to i64* + base alias entry %217 = bitcast i8** %216 to i64* + base alias entry %220 = bitcast i8** %219 to i64* + base alias entry %222 = bitcast i8** %221 to i64* +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 2 +Warning: reach to function declaration __kmpc_fork_call +Round 2 + base alias entry %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias entry %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias entry %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias entry %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (2) %11 = alloca [5 x i8*], align 8 + base alias offset entry (2) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (-1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 + base alias offset entry (4) %11 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 4, !dbg !10317 + base alias offset entry (4) %12 = alloca [5 x i8*], align 8 + base alias offset entry (-2) %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 4, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams + base alias entry %126 = bitcast i64** %29 to i8*, !dbg !11447 + base alias entry %139 = bitcast i64** %30 to i8*, !dbg !11477 + base alias offset entry (1) %184 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 0 + base alias offset entry (2) %184 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 0 + base alias offset entry (1) %186 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 0 + base alias offset entry (2) %186 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 0 + base alias offset entry (1) %189 = getelementptr inbounds [3 x i8*], [3 x i8*]* %16, i64 0, i64 1 + base alias offset entry (1) %190 = getelementptr inbounds [3 x i8*], [3 x i8*]* %17, i64 0, i64 1 + base alias offset entry (1) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (2) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (3) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (6) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (7) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (8) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (10) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (1) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (2) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (3) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (6) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (7) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (8) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (10) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (1) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (2) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (5) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (6) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (7) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (9) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (1) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (2) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (5) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (6) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (7) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (9) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (1) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (4) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (5) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (6) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (8) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (1) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (4) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (5) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (6) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (8) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (4) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (5) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (7) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (3) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (4) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (5) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (7) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (2) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (3) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (4) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (6) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias entry %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (2) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (3) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (4) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (6) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias entry %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 + base alias offset entry (1) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (2) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (3) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (5) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias entry %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (1) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (2) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (3) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (5) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias entry %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (1) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (2) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (4) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (1) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (2) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (4) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (1) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (3) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (1) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (3) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (2) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (2) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (1) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (1) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 3 +Warning: reach to function declaration __kmpc_fork_call +Round 3 + base alias offset entry (4) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %24 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 0, !dbg !10317 + base alias offset entry (4) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (2) %26 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 0, !dbg !10317 + base alias offset entry (3) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %29 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 1, !dbg !10317 + base alias offset entry (3) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (1) %31 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 1, !dbg !10317 + base alias offset entry (2) %34 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 2, !dbg !10317 + base alias offset entry (2) %36 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 2, !dbg !10317 + base alias offset entry (1) %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %11, i64 0, i64 3, !dbg !10317 + base alias offset entry (1) %41 = getelementptr inbounds [5 x i8*], [5 x i8*]* %12, i64 0, i64 3, !dbg !10317 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (4) %31 = alloca [12 x i8*], align 8 + base alias offset entry (4) %32 = alloca [12 x i8*], align 8 + base alias offset entry (5) %31 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %219 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 5 + base alias offset entry (5) %32 = alloca [12 x i8*], align 8 + base alias offset entry (-1) %221 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 5 + base alias offset entry (-2) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-1) %224 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 6 + base alias offset entry (-2) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-1) %225 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 6 + base alias offset entry (-3) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-2) %227 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 7 + base alias offset entry (-3) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-2) %228 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 7 + base alias offset entry (-4) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-3) %230 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 8 + base alias offset entry (-4) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-3) %231 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 8 + base alias offset entry (-5) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-4) %233 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 9 + base alias offset entry (-5) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-4) %235 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 9 + base alias offset entry (-6) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-5) %238 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 10 + base alias offset entry (-6) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-5) %239 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 10 + base alias offset entry (-7) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-6) %241 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 11 + base alias offset entry (-7) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 + base alias offset entry (-6) %243 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 11 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 4 +Warning: reach to function declaration __kmpc_fork_call +Round 4 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams + base alias offset entry (4) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (5) %200 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 0 + base alias offset entry (4) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (5) %202 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 0 + base alias offset entry (3) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (4) %205 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 1 + base alias offset entry (3) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (4) %206 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 1 + base alias offset entry (2) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (3) %208 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 2 + base alias offset entry (2) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (3) %209 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 2 + base alias offset entry (1) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (2) %211 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 3 + base alias offset entry (1) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (2) %212 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 3 + base alias offset entry (1) %214 = getelementptr inbounds [12 x i8*], [12 x i8*]* %31, i64 0, i64 4 + base alias offset entry (1) %216 = getelementptr inbounds [12 x i8*], [12 x i8*]* %32, i64 0, i64 4 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 5 +Warning: reach to function declaration __kmpc_fork_call +Round 5 +Warning: reach to function declaration __kmpc_fork_teams +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %189, align 8, !dbg !11559 +Warning: store a different alias pointer to a base pointer: store i8* %156, i8** %190, align 8, !dbg !11559 +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Warning: reach to function declaration __kmpc_fork_teams +Info: add function _Z21distComputeModularityRK5GraphP4CommPKddi to Round 6 +Warning: reach to function declaration __kmpc_fork_call +Round 6 +Warning: reach to function declaration __kmpc_fork_teams +Round end + ---- Access Frequency Analysis ---- + target call (1.625206e+01, 0.000000e+00, 5.076920e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625206e+01, 0.000000e+00, 1.015380e+01) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + target call (1.625204e+01, 1.015380e+01, 0.000000e+00) using %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + target call (1.625204e+01, 5.076920e+00, 0.000000e+00) using %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + target call (1.625204e+01, 8.757690e+01, 0.000000e+00) using %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + target call (1.625204e+01, 4.569230e+01, 0.000000e+00) using %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + target call (1.625204e+01, 0.000000e+00, 5.076920e+00) using %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + target call (1.625204e+01, 3.807690e+00, 0.000000e+00) using %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + target call (1.625204e+01, 1.078710e+02, 0.000000e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625204e+01, 2.538460e+00, 0.000000e+00) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + target call (1.625204e+01, 2.538460e+00, 2.538460e+00) using %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + target call (1.625202e+01, 1.015380e+01, 1.015380e+01) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + target call (1.625202e+01, 1.015380e+01, 0.000000e+00) using %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + call (1.625199e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + call (1.625199e+01, 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00) using %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 +Frequency of %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.650200e+02 store: 0.000000e+00 (target) +Frequency of %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 8.251031e+01 store: 0.000000e+00 (target) +Frequency of %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.423303e+03 store: 0.000000e+00 (target) +Frequency of %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 7.425931e+02 store: 0.000000e+00 (target) +Frequency of %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 6.188273e+01 store: 0.000000e+00 (target) +Frequency of %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 8.251031e+01 (target) +Frequency of %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.918144e+03 store: 2.475302e+02 (target) +Frequency of %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 2.062750e+02 store: 1.650201e+02 (target) +Frequency of %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 4.125515e+01 store: 4.125515e+01 (target) + ---- Optimization Preparation ---- +Rank 9 for %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 6.188273e+01 store: 0.000000e+00 (target) +Rank 8 for %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 8.251031e+01 store: 0.000000e+00 (target) +Rank 7 for %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 0.000000e+00 store: 8.251031e+01 (target) +Rank 6 for %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 4.125515e+01 store: 4.125515e+01 (target) +Rank 5 for %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.650200e+02 store: 0.000000e+00 (target) +Rank 4 for %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 2.062750e+02 store: 1.650201e+02 (target) +Rank 3 for %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 7.425931e+02 store: 0.000000e+00 (target) +Rank 2 for %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.423303e+03 store: 0.000000e+00 (target) +Rank 1 for %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + load: 0.000000e+00 store: 0.000000e+00 (host) + load: 1.918144e+03 store: 2.475302e+02 (target) + ---- Data Mapping Optimization ---- + target call: %49 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z21distComputeModularityRK5GraphP4CommPKddi_l396.region_id, i32 5, i8** nonnull %24, i8** nonnull %26, i64* nonnull %28, i64* getelementptr inbounds ([5 x i64], [5 x i64]* @.offload_maptypes.0, i64 0, i64 0), i32 0, i32 0), !dbg !10317 +@.offload_maptypes.0 = private unnamed_addr constant [5 x i64] [i64 800, i64 547, i64 1100853829665, i64 547, i64 1102195986465] + arg 2 (0.000000e+00, 0.000000e+00; 4.125515e+01, 4.125515e+01) is %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x06 + local reuse is 1.600380e+02, 1.280304e+03 after adjustment; scaled local reuse is 0x500 + reuse distance is 0x01 + arg 4 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 1.600380e+02, 2.560608e+03 after adjustment; scaled local reuse is 0xa00 + reuse distance is 0x01 + target call: %24 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %9, i8** nonnull %11, i64* nonnull %13, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15, i64 0, i64 0), i32 0, i32 0), !dbg !10269 +@.offload_maptypes.15 = private unnamed_addr constant [3 x i64] [i64 800, i64 35, i64 33] + target call: %26 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %11, i8** nonnull %13, i64* nonnull %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20, i64 0, i64 0), i32 0, i32 0), !dbg !10269 +@.offload_maptypes.20 = private unnamed_addr constant [3 x i64] [i64 800, i64 34, i64 34] + target call: %258 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z16distCleanCWandCUlPdP4Comm_l455.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.20.1, i64 0, i64 0), i32 0, i32 0) + to label %259 unwind label %319, !dbg !11559 +@.offload_maptypes.20.1 = private unnamed_addr constant [3 x i64] [i64 800, i64 1099553574946, i64 1099681513506] + arg 1 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x01 + arg 2 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 1.015380e+01, 1.624608e+02 after adjustment; scaled local reuse is 0x0a2 + reuse distance is 0x01 + target call: %276 = call i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z17distLouvainMethodiiRK5GraphRmS2_RSt6vectorIlSaIlEES6_S6_S6_ddRi_l1368.region_id, i32 12, i8** nonnull %200, i8** nonnull %202, i64* nonnull %204, i64* getelementptr inbounds ([12 x i64], [12 x i64]* @.offload_maptypes.47.2, i64 0, i64 0), i32 0, i32 0), !dbg !11584 +@.offload_maptypes.47.2 = private unnamed_addr constant [12 x i64] [i64 800, i64 9895689605153, i64 9895646625825, i64 9897073713185, i64 9895987392545, i64 9895646621730, i64 9895636144161, i64 1101320425505, i64 1099553587235, i64 800, i64 9895646617635, i64 800] + arg 1 (0.000000e+00, 0.000000e+00; 1.650200e+02, 0.000000e+00) is %91 = invoke i8* @omp_target_alloc(i64 %90, i32 signext -100) + to label %92 unwind label %291, !dbg !11387 + size is %90 = sub i64 %87, %89, !dbg !11386 + global reuse is 0x05 + local reuse is 1.015380e+01, 8.123040e+01 after adjustment; scaled local reuse is 0x051 + reuse distance is 0x09 + arg 2 (0.000000e+00, 0.000000e+00; 8.251031e+01, 0.000000e+00) is %105 = invoke i8* @omp_target_alloc(i64 %104, i32 signext -100) + to label %106 unwind label %295, !dbg !11405 + size is %104 = sub i64 %101, %103, !dbg !11404 + global reuse is 0x08 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + arg 3 (0.000000e+00, 0.000000e+00; 1.423303e+03, 0.000000e+00) is %119 = invoke i8* @omp_target_alloc(i64 %118, i32 signext -100) + to label %120 unwind label %299, !dbg !11431 + size is %118 = sub i64 %115, %117, !dbg !11430 + global reuse is 0x02 + local reuse is 8.757690e+01, 1.401230e+03 after adjustment; scaled local reuse is 0x579 + reuse distance is 0x09 + arg 4 (0.000000e+00, 0.000000e+00; 7.425931e+02, 0.000000e+00) is %128 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %129 unwind label %303, !dbg !11449 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x03 + local reuse is 4.569230e+01, 3.655384e+02 after adjustment; scaled local reuse is 0x16d + reuse distance is 0x09 + arg 5 (0.000000e+00, 0.000000e+00; 0.000000e+00, 8.251031e+01) is %140 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %141 unwind label %311, !dbg !11478 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x07 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + arg 6 (0.000000e+00, 0.000000e+00; 6.188273e+01, 0.000000e+00) is %134 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %135 unwind label %307, !dbg !11462 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x09 + local reuse is 3.807690e+00, 3.046152e+01 after adjustment; scaled local reuse is 0x01e + reuse distance is 0x09 + arg 7 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 1.078710e+02, 1.725936e+03 after adjustment; scaled local reuse is 0x6bd + reuse distance is 0x01 + arg 8 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 2.538460e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x01 + arg 10 (0.000000e+00, 0.000000e+00; 4.125515e+01, 4.125515e+01) is %156 = invoke i8* @omp_target_alloc(i64 %127, i32 signext -100) + to label %157 unwind label %317, !dbg !11510 + size is %127 = shl i64 %69, 3, !dbg !11448 + global reuse is 0x06 + local reuse is 5.076920e+00, 4.061536e+01 after adjustment; scaled local reuse is 0x028 + reuse distance is 0x09 + target call: %325 = invoke i32 @__tgt_target_teams(i64 -1, i8* nonnull @.__omp_offloading_33_128194f__Z20distUpdateLocalCinfolP4CommPKS__l436.region_id, i32 3, i8** nonnull %184, i8** nonnull %186, i64* nonnull %188, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.15.3, i64 0, i64 0), i32 0, i32 0) + to label %326 unwind label %319, !dbg !11667 +@.offload_maptypes.15.3 = private unnamed_addr constant [3 x i64] [i64 800, i64 7696921137187, i64 7696751280161] + arg 1 (0.000000e+00, 0.000000e+00; 1.918144e+03, 2.475302e+02) is %145 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %146 unwind label %313, !dbg !11486 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x01 + local reuse is 2.030760e+01, 3.249216e+02 after adjustment; scaled local reuse is 0x144 + reuse distance is 0x07 + arg 2 (0.000000e+00, 0.000000e+00; 2.062750e+02, 1.650201e+02) is %151 = invoke i8* @omp_target_alloc(i64 %144, i32 signext -100) + to label %152 unwind label %315, !dbg !11502 + size is %144 = shl i64 %69, 4, !dbg !11485 + global reuse is 0x04 + local reuse is 1.015380e+01, 1.624608e+02 after adjustment; scaled local reuse is 0x0a2 + reuse distance is 0x07 diff --git a/miniVite/main.cpp b/miniVite/main.cpp new file mode 100644 index 0000000..eb695f3 --- /dev/null +++ b/miniVite/main.cpp @@ -0,0 +1,252 @@ +// *********************************************************************** +// +// miniVite +// +// *********************************************************************** +// +// Copyright (2018) Battelle Memorial Institute +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// ************************************************************************ + + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +#include +#include + +//#include "dspl.hpp" +//#include "dspl_gpu.hpp" +#include "dspl_gpu_kernel.hpp" + +static std::string inputFileName; +static int me, nprocs; +static int ranksPerNode = 1; +static GraphElem nvRGG = 0; +static bool generateGraph = false; +static int randomEdgePercent = 0; +static bool randomNumberLCG = false; +static bool isUnitEdgeWeight = true; +static double threshold = 1.0E-6; + +// parse command line parameters +static void parseCommandLine(const int argc, char * const argv[]); + +int main(int argc, char *argv[]) +{ + double t0, t1, t2, t3, ti = 0.0; + + MPI_Init(&argc, &argv); + + MPI_Comm_size(MPI_COMM_WORLD, &nprocs); + MPI_Comm_rank(MPI_COMM_WORLD, &me); + + parseCommandLine(argc, argv); + + createCommunityMPIType(); + double td0, td1, td, tdt; + + MPI_Barrier(MPI_COMM_WORLD); + td0 = MPI_Wtime(); + + Graph* g = nullptr; + + // generate graph only supports RGG as of now + if (generateGraph) { + GenerateRGG gr(nvRGG); + g = gr.generate(randomNumberLCG, isUnitEdgeWeight, randomEdgePercent); + //g->print(false); + + if (me == 0) { + std::cout << "**********************************************************************" << std::endl; + std::cout << "Generated Random Geometric Graph with d: " << gr.get_d() << std::endl; +#ifndef PRINT_DIST_STATS + const GraphElem nv = g->get_nv(); + const GraphElem ne = g->get_ne(); + std::cout << "Number of vertices: " << nv << std::endl; + std::cout << "Number of edges: " << ne << std::endl; +#endif + //std::cout << "Sparsity: "<< (double)((double)nv / (double)(nvRGG*nvRGG))*100.0 <<"%"<< std::endl; + //std::cout << "Average degree: " << (ne / nv) << std::endl; + } + + MPI_Barrier(MPI_COMM_WORLD); + } + else { // read input graph + BinaryEdgeList rm; + g = rm.read(me, nprocs, ranksPerNode, inputFileName); + //g->print(); + } + +#ifdef PRINT_DIST_STATS + g->print_dist_stats(); +#endif + assert(g != nullptr); + + MPI_Barrier(MPI_COMM_WORLD); +#ifdef DEBUG_PRINTF + assert(g); +#endif + td1 = MPI_Wtime(); + td = td1 - td0; + + MPI_Reduce(&td, &tdt, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); + + if (me == 0) { + if (!generateGraph) + std::cout << "Time to read input file and create distributed graph (in s): " + << (tdt/nprocs) << std::endl; + else + std::cout << "Time to generate distributed graph of " + << nvRGG << " vertices (in s): " << (tdt/nprocs) << std::endl; + } + + double currMod = -1.0; + double prevMod = -1.0; + double total = 0.0; + + std::vector ssizes, rsizes, svdata, rvdata; +#if defined(USE_MPI_RMA) + MPI_Win commwin; +#endif + size_t ssz = 0, rsz = 0; + int iters = 0; + + MPI_Barrier(MPI_COMM_WORLD); + + t1 = MPI_Wtime(); + + std::cout << "Size: " << sizeof(Edge) << " : " << sizeof(GraphElem) << std::endl; +#if defined(USE_MPI_RMA) + currMod = distLouvainMethod(me, nprocs, *g, ssz, rsz, ssizes, rsizes, + svdata, rvdata, currMod, threshold, iters, commwin); +#else + currMod = distLouvainMethod(me, nprocs, *g, ssz, rsz, ssizes, rsizes, + svdata, rvdata, currMod, threshold, iters); +#endif + MPI_Barrier(MPI_COMM_WORLD); + t0 = MPI_Wtime(); + + if(me == 0) { + std::cout << "Modularity: " << currMod << ", Iterations: " + << iters << ", Time (in s): "< 0) + generateGraph = true; + break; + case 'w': + isUnitEdgeWeight = false; + break; + case 'l': + randomNumberLCG = true; + break; + case 'p': + randomEdgePercent = atoi(optarg); + break; + default: + assert(0 && "Should not reach here!!"); + break; + } + } + + if (me == 0 && (argc == 1)) { + std::cerr << "Must specify some options." << std::endl; + MPI_Abort(MPI_COMM_WORLD, -99); + } + + if (me == 0 && !generateGraph && inputFileName.empty()) { + std::cerr << "Must specify a binary file name with -f or provide parameters for generating a graph." << std::endl; + MPI_Abort(MPI_COMM_WORLD, -99); + } + + if (me == 0 && !generateGraph && randomNumberLCG) { + std::cerr << "Must specify -g for graph generation using LCG." << std::endl; + MPI_Abort(MPI_COMM_WORLD, -99); + } + + if (me == 0 && !generateGraph && randomEdgePercent) { + std::cerr << "Must specify -g for graph generation first to add random edges to it." << std::endl; + MPI_Abort(MPI_COMM_WORLD, -99); + } + + if (me == 0 && !generateGraph && !isUnitEdgeWeight) { + std::cerr << "Must specify -g for graph generation first before setting edge weights." << std::endl; + MPI_Abort(MPI_COMM_WORLD, -99); + } + + if (me == 0 && generateGraph && ((randomEdgePercent < 0) || (randomEdgePercent >= 100))) { + std::cerr << "Invalid random edge percentage for generated graph!" << std::endl; + MPI_Abort(MPI_COMM_WORLD, -99); + } +} // parseCommandLine diff --git a/miniVite/miniVite b/miniVite/miniVite new file mode 100755 index 0000000000000000000000000000000000000000..3b3b798cbe2013c9c472fc00962e61e5fc5668ec GIT binary patch literal 1338400 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%0A*Um1 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

QT>41Wu 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 pb!Gq^|S?-@JEaP7KLf&)F!lr7Wort(NlWT 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%0A*Um1 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

QT>41Wu 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 pbF0Mf2V(@Ke8CfHzTgQppLX~1_G@>o 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 z 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�IU zpnGZ+Z{pl(9vCaDYI4jbIwf_h3^eI-V4B>VQHx>}C}MJe^0cbSCQS}7?j>kxnU^In znnNViLqYg4_E68Yhe(Ym2z9l@)E*MBXg4ldb}7t&OxQK4>X3wAna#(X@k2q5O!t%{ zhloTJO!}$i+CySCwA&jZw8gGTRfi-;geKBRu8!qX;kr?wrbmXE4|# zc9SMu5KPwyf+;5x69jbVtC}!5T|iKT2wECanXQE?W^0j1OK-z{c;OG|qr9LkHy7J& zL_2${?0xaayquXNLmEingeq#k-2|gxf`BR&_lL%iz>dKM3@c(4#h1)CLv0@x?VWPq zm?Wqn*mA)>q)DSD5H#^{Sz9#E{(G2%6fJB*{{#Owv>hdG*(s|;g-eh?(VAU=hO+pt z%X)-(#pBX?B))6ubXwwbTAUVlRbN=ND9PO$E|Li0B1=t6h>8dhseaQv0gdadSoUla z!h?ixC?*8g_D$Mx75TyJG?~;&ZAv^B_(mtWtdf)DRar74XtzdN6hcW?!V7u?=91^e zJ75G<$i$-Je&~Z$@zaBMT7h?9c^N^H+SruE;M&t-k|wEE&PBPbqenn0^0N#hduG4_ zE*&r9ISVR@Ge`wujMCFy7K34aS`+d7P_T0qixb4m*!$w*jzoiOwS1L^rCU)`^s%uN zbpFig6X#w#jl~S?Avig2ao?9Hw_9H&6WG+M&z4r{7{DS$`4B}H(t(_ouC*cd8plBt z%V%f@cwoSIUQ*9_>anTTp{YYNv#moQL%9F7un{!+c7k#8tBOdLt(o90TSY;~SF1)O z8tq~LoSa(7W2c-E%v9czq75-nv+*LH2@zrr(uQQQ3^dcsvc{-}>LxEiBM_trSwN#v zu60>r5u9}+EYg`Su^7jfn(&J`^-Y%G01y}GLUAZWRc3&bnd$&fun5-7uvpdyNiPRe z5&+gCJ*c`KV^mR$q^OcUFon8oievbp#8rY0>18ZRS*y(%I>O}8Npedaa4{2#I=B$y zVnHUMwCf5eC#cs+(s*5u2|7TuDLR6tM66IGgPXi(oH{GTb+4DZbPLLc@c_uah2olm{)aPhmYNpFrr=OA{6$OUqNp>=!dW zZB6oQ6LSS(nT+)#-DHtemo4w=mU9vt6=oKilFN+>cfCCjLPxu*=@^BvA^*6_zyp^r z#9;DVXfU$u>WV1!s`$y=x?ua$A=K!&P9hmY0T|gYO^fC><+#xtjtm$^2`g;GF+f!Tu0SXNM%~bOWOe~+JWO9-%1tms?DIl!L zv|!3K(ZS0j0>Zu;133^$*k?z5fX35mtX1yG$fjOFp12dr!?JKpW=#ZovAO)&YR9O7 zAl^84=Jl|OM6K-rYloW*oI@~j0av~!>ez3tXkVTzWo`UPm{EM8?R3ov8jFD}+;+C8 zAYq}rgJ2?_lO+~NGfgDGrm@@%4h3dqLM!Sr#r)V-WqdQr1eHt_C# z=l~GiK^THaYx-%122^+^AP!*VWZnx4&R3glYu2M3{^2$LT4OVg+o^G9|d zL%;UM*TVj!CYO6=+84*n$udZsK-6iU0e+n4ZMhA`Ez!tqkhX+@W#EBH^%iAph1{}B*i?qwnSk4_ zel2E+Wq-Agp;6XU{gPzSjr+=zxy5e?Z-&Y7d5PG;NIspHSmn+I`+J)4m(-xJI5?*q z=pePnv0{!mwOB=pv_Pk6ER!blRpTbMFFFOU@)TaicUZunr3hjCZ&tQD9KU8DHtWHnh+%N|B%gSMU`=C-t0hhl~llU z$v@NsljmJ=y9ByYRhG=VG9H_C%SWzM*{8;@2+Cww>1C*;e(^**c!(;D8~>J|4pU{c zx1+LU$0QDV%mP64In^B=!8$Lxn+i*(hbRZ?=iBuemj~_(QvrFyufMC1{#z04{`z)~34l zk#Oe=x(jQLIQi8RG7I&f=rSO)MFDNA=?NJIO31XZh%FJN6v(4l!K2|iN!Pp(TbxV# z0r2U(I0;ZrR2e8Q9>G-C2oSk&DB?4ogwP<1CMXb2!8bEQWGdg{*VKw=Gc1WV4^h(8 zPoG6*P&C<>(W9)%Rj!GG2J5D}HQ{1aE23D(Cqm0n3)7;3=@7A<=q+#L31Mo0-Ke)7 zkeR%p$qC( z%D_aKpa2ZW$hcZo80XTaG!qmp->1tHW`dRmSlKqmqaBr41oIozx03;@{c@rI%1(YFqgN>CAS#Nn`y0ke1a*ulJ0h!4gT5nO= zvSUH!@waa>=}yv~5k)NL!h}m=|D+td>dJV4c#IOPdsUAcY!1!EI7( z%LK(-CMclxEgSMc(9)EP{4m?UY_1&_b!9nLW~ar~S%{||U^-4G4kGz14@$Y4gq+Ch zup>ii2X&HwHlJhH0rouQheJdx|#5J1$<8=keTE5)E zmM~kK#nR#8%FSxdGSL(f-EacPLztO3)YVd08?i8q42ajz8DZ&)LJ;e5q@6wuqBpgx z>Mx-u3w@zSxoX5Hl(t;9nLOrg-Zx+iFfuSC-=W+Y;JT4xXi`rJPAalmIO8Qh`dFIB zu()l`i}_&7U9oL3WTjDc?GcbGhvAa&G1?I5n+~fgGqhDSn(B0x?Ywbv&`>C-Yljj? z^=CjFsgE>6YNd}f16;(L25j4!4RWbX17W6Unpk7hxp@?d^Pk`qr4zh1CmaRD$THV{ zTU^E~@tV-3AHq|Ku3ZC;^j0{jMxOL5VC7HoX2?mJ)42ah1qQwhc(Uf(V^~xEV{p&63sXfQvbK7Nuj_ zY03m6=c2jg5)UecKI>wbIrYqfa1(?em}d;cPD_NK)C~~=iYpP4QjcrDCQ5WuPe79u zLe~JD5(>m)Xd?q;(F?}6A$(|Dm%ST5zf${u10#oF$o~(y$)hDT zHWF=~^w=6aK%%4O+zsN3!lL;HDjrPj9_48|s&D?#ZVBZ}*vJ`_2ZRxpCjW1C*=sO$ zm@yfEr%}|SM@^jvMw1?Ul$X@=Xkt=6g%Fb{2&V+dG$AZ?oUNQ%yz#7N8;7@zHeyB% zK9Lk?V(Xc^)k>H8PtDtgStE_yHupe{b{w)~X6{SE;yK8!90#u{3HAhc55yn@9j-W6 z<_1VNdR6>D+*CDP%&=w3a8URR%ny<2oJ_E4KV_2}>@kblww>{t%r_ONwVio08AML~AdUF2YD04s4lOPHAfT#$t#3)Gi9wQ_^CEL{rqRZFSnDqf*TmjQBUCj!D_T)6s8*EMgT+X%C_;(Cl7b>$n6(Bi7t*_~TSx{OH zw}In9UpZ$t8K_`~lqC3}HQl|O8&;+n3g|_IrRiF+jGa*7a-FS?as@CfW$OF_NIX5) zubtTomdBX@7fdBw0Gf|EjzT=$fuUtu#~Ve9uLSCP3L*zJFm<*ZC?*cJ_Z;;&F79)| z0wdclQo<`FDO~{Bu4iG z%oeY%*IqpZ$uFAsMRG7|{moNmE(J@mG6tGmH%~z-xcT0BQDkP;mTeU22;2M6Ce)0|;C!~^WhE{Rgl-Dw!e&1yocgBA{GjRG z&rWD`^soX%_c~kNqkzp4eKCL;sKPD`1M0f&3sVr#rH05!N8igkmZA%vMEXE`JfDQ7 z+FRJg5u$0^kc^5+S88qE|7XM`+KFIO%w=D~A#WH0kz4c5s>QP?P0wnw{T9U&-|#W=SxQ6uCh05JPFJ(|$=5&k@FcwjV`i8Ptobh2xF} zOIFQr#jCgST81f~T-1s!ljbqAj+@6Aa)~?h3p9NEC{>3RFBBv-+gKLqP)^L2u87l+ z4=;?8^B2vmE!xiekKbAW@L_+ju{{218zTbGmm;COamGx{P|6*{F`!1b^)!#k28?gG zQH5UQW3+`LAfJQ~bVmn7j}{*g?MtWHc5q?eoF+}&5pZDw7Jf_f81-L_3E#~f&;>|= z^I)il`jlOy*h7#9No_w49ne`{8^j_zn$jfhT6QOfW5mS$^OY5>;EC4~g=*(_1zNB< zDDVW?BfL*Jf;|){J68dAAMLB8puu)W{ZHq!+X$a(qMq_WmMQecmOkmc(`NH?F0seL$wAQr-oO zB7XQ3q7+?gP}=6RaGp!socyse+kB}TomXO&FV)t~*yGD=b48Z;GTZEn4IVa-Jw8pl zJid;Wwifv!jU3PhT*6XVCip!~?ODZW*TB?neT=5I1UUq9FH_r9J&N@clL6>=A(|l{>-(15>aA{D-G^#u?6TGEv2C`X4x*J@ZDC=T@BmG5iGA#rewByC;=0Eb7jAJhnPnzS`e|SfBl1om*iE#VjIzgNpjA9!v*BNSU=X44y+qo5NXD&|( zC0+F9b7Ma}ZD-4NwNu&7rgljeRbYf~Yw(01<6i%M2xV)v)Z zo3h0F+V#o|_P%z#qPJ)?``Y!2-mcN#uA|q2QPA9YZL+^zM{f>W>#n1hi>-Cn(fh~N zy6fl_WozAa^cJ(V?i$WY`DVd2@0;&J>w2lp@)qnSyBF-LHM}x@FgcUO54gnK?PKYk zA8X0nS(pKquG^k-S_5B3m;vP@N0?UG%2xCy`xRz@MOO1F8Cki=s$0=BYa1ncg&EwC zg2hx5W-#ko_p2o>-T2GACau%~$kb*umfdYCt6sb^!>D&Ui%+CX#%G zIqt%#4Kt9YVC=yjufhzId6+?=g1RL=PH68XJ-hV6@1$X*IgOT@b7h4PLC@Co42W(f z;5BqhMFRS&*PFGwfVhisZNVTjc7+tVYky6_;A%uS6yTCIg@Wr2-B5sk))b1_S|~u) zYYGJqT6g1uOE7DxDyD0pfP7d}C~DulM8AJcq2NBgt{LG<;hI8G8%NcxJZni8E<9JZ z7lCR88`vOX>w={U?`3;VbmZX%n-QdI{5G{L^1=NZ=*@zL)Z}qk#KK@_ZYpV7nzd2K=!X0_=<{YBM2-ed!67$$|i4j9%M&VHdNv=V|)LM9AWXp%eg0;)aub ziyOKrSFQ02SO!?XF?R6a*w^rKhs$F|OBD$rjSPdTN!GU4;LRtRybAO3jiac&~B^A81S?VRXK#rd@vi+#v+| zNTYgJRe?8E%K&~_FBLxNFI(ojesK%&nKw=!{q@r?OdLD<>r+q9zj~5?;mN$cz50c@ zWAjJnUwd>6FXdJbpm_TOqQw4y7_vVgB3&5>xE(Tp%o1CbE)01UzntPq;Ipx7=cS6FC zw_mM^dQ@5tT5wgW;Iz3asfZ21X~+=um<6W+KpC8-FU{ce`Pa_A_R8s#{<8Je&tesO zCZ(;uz3#wrU)znM#(ix!3JLeM-6-DM*LI^|ZeQDtBDH;OHwwe{wcRMj+ShiY0BT>` zjiRG{Z8r{m@^a0-F>=%6ny1e|cZ?l4ar(7a-x#wO-fuj1Oiz!^pIkU|ZtA63oQ8&8 zvR8OZnADVXy% zZ9E0rbzlRI5_i|41ZP&R2Ft-ziDHu4tKlKvxVUZbV6I+0N^M?U1Ym6`nhATqI^HqG zV6Yk&3BqUNWlOLIV%0k(W&gR)p|IbzRvpul3&pNchwTJP1trkYJb&ig$pf#zj;ii& z#DH*pYThf%4YUB*s+j52F`BE zCEANvwi#dSiL9h9QJI_&`*>!Qq4Cz#oX*XA6xdBSx2gPMXCMn`t?s6rqOY2w0jNPs zy!9dR&4AOs`ewM@GP1;h0qn{>f8sRey|lFV`=f_o$-Yjq`5OKRhBIy2G6+P4044#Z z7`^stu-!AWx0w!=$5+rFEPvt3FzlN@aA{xN9P;Kpn?eZ7E%E_0^qwVPu@%c2aIdwatlle zR{<2yOG~0_m;L=eHSpR6K^45Z0Q*Mpwq`1Lfo{;}($IRH+9_}x15JV)?o}4gvYWR# zcGNHLK6q`u^tkYigQz6f(aY zvd&P@Je$=@XdKfdHq@qbqnhGozO)1L$puMkYL<81q#eLCfa%8$C_a)7OeNXtHwiqO zVh2(*X7W(g0b2@jaS@q1 zC?p`N6^_{BhCj?}iUYsP#I6pNvqx!SS`a|Z*7NZAcVV77mRT)*WS0iTbHSz2r2aJ0XBvI8CqP?3=GRW#EZ1o(Pi#z}cz3@@uGAE|&^^ zBa^>F1&u>3M4eI~8&!sbW#L3wl_7FX^rPKDBte!B(ry(pKS6_mCP=Ulzl94gRH7_O zq=@c9p%j^x5fV!gyQLfB$21BLfU#@Ov0l=|TyS?+-zMke#Haxm4T1HWy04m@SJ$Y! ztyY5Vl1vvpQi3Hm-;5hjn5xu>Zt+H0NVlwXFc6WQ%0d7S_o!9|QVLK829u~2UTMcR z(i$!uQ3F#Rj5(LKRDdTHuSSI0TxyVA>@iZDw`mG77ViF{y=!Da1c`j)KuA?_*{NfE ze^HlJ;5Y*unU=IJkPXzt?jb|fJ^VxMjKRx@bNr$Po&lQbJ}f}PE-M$&thXL6q8WWH zFjvXc;i`eAZkcYgI_N!dj(Dx+5nr3S)jmGFXZ9v93O$R$g81yJBzJsq`(?TF6PDNtg#$cEKJS@rgJI6%gd^1 z%4!B-pjU!K3|rO>Q_NUFUbl1?XLF&aTW=u`Ikql$(J$gvrp;R3aOo}TZn;SA08IDy zc!?gW#bb3+G&!wH_M&6yw1gSMC|E@42yqRA} zfy{^rD5Z9M6b2>4Ug?IICVR`NY+`*ZckIkFK!co&aHC%3Rhl579D%qouaY9V%k{CB zUP!aYZl&F*X7JXzmC_TigD~8>-t7%~y2td!y^Aau$4O?#-gb-Tk=^B2>MD5JU;zdw z2*VQM2s~7JGy2_n*!c!^Y9w-qc zu|qFNGC^xEh_StjCzmH6)7>PpZ1WO??PANxV?H35;s11`vYT zupx4Ldn_64vVER=>>_d8=Pn9#zX&DKa*hMzf)YYTjMRJVFz8L`5ng#L($Q*hl8791 zQ@`keR&JLpaSF8`l=a?XhamJ;@&=H@28}n;u^SB$o-TS8O6T1lwR`9RX4xpltszV> z48d897)}w?Q{Y^n4?mQ;=d5O^Vi^!v*(w|Lmdz8doXF|M%m_QgDj8c6fCXi_mrzm? z;v#zcI;KCDO&+Jv3GWt+|XXt(qZXfo)Zq{k3ogjV(XeC1@UT1s8YqWL`4 zDC0_^271n7kga&ll@dl^>t&X}g>C!`qFnC18;E}&@H$B>tsL8#w={W@zoJXM_FsE@D445%Ja^f@%l7!S;p|b#0OJ=M1O=qp3 z_8FieK4NW5d?XwNE@NLa6Bc&#xRaZUAy&c#3rB9OP&H{WfF7tMDrEVlU15g2D|pZK z$nm=YT1_aE1WZgx3}(0Y3uGBi$uUV)S2-=%(5h`!M?h1f~P6Hb4o4hDhC5GHTPS(Y3RE+J5 zuQ7V=8X2Ng3y=OfH~8hwztG!GNRy6m+hLl)UbIJ7rcn ze#jcJl1CLZiVR8;!TSc=^?*N~OW_de45|?M4krS9`6<8@h?1ib@@de;FgwNDaB1F0 zFq=W5J5~q*dd>>anhV#+8BGVp%C}4s7fq^aVlir#)))|P{~IT`es?}-(zY)}UuY5$ zL{w?hOp;L>&yAw=#5{^T##}|Mp~|)6qvc{pZ!bb-E|fSB_ zJr2+v;rAFuc*kaF)L%Nquw2qkxDy{!Oqm!PmGEnSRE(v-rZJrmD|K`tRK(r}*Z5P1 z$|6;uzHYC=1AxH@^W8>apzKpLKzL<<=`ETWi)vlHe9>7j>?3Z}r88h}6*-q{ z{Ss`B{=l~^K;Dd+kb8jZ+?7Ag5#|MGMdMZ9G|}PV$m~x=jaJ|Rg||U+w;6CDi4B0( zJqy-i`t=i?gl*YhkFrTntL2nlu?v7iZxj>JA+MHmr>*)INh>QQ zZ#uPKEHXMz(S$C+_mi>LqW8uog3k0n@Ugk5Voh^vZX_W10yS~L934)>Wfh9>kb>T_ z<`P0($L6l)F^>1N98|B>&9vUC%H>QO&aH(Y2yMei4e59&8GaJ)X3kiX!F>&7QkyTL zLAHWJ2yEAKt@o;O&b1n694F+(!5K$lE(8m34N{HKZ!d2Kvw8`$0dtO=qyDmKp#z(7 zq&AG)h$Hb9M{x_M8bn;9clG+nQ+O?zO4M;AEaO!1+s+c%v(@dod%dO?GQmd!X|%eB0YH%w{UFtq!E!Y0<{ zf~@^aa@)2wd!rx-Y>p5m^(k@|R0?ew3&s+gd|-1)uRIp|dQ}j|pXqTIC|sqg)9+k? zQiFPtUqsFn8P2nh$P>uf)g?^!kO@5GbiQPo{GgO*0uKO@iwUR=eapk61 z!%H%*{0h8qh3ppvDNly&Z@zmmP(OKC^eIE z!MU+jhq4%8lUpio%SK=ghl-MRK~IEXka+NNL7;$pgA%zeHH#NR3YuI*`=Ge83bL7w zRaUmA(!;?`yZ5PICzZ^_h&J^3ny(MGTS$vdFj62nm(d;?5QH>a7($3?GrSj#J(w}U^d_92s`F_JZVK&uiC%>~pxu?P-cFwx zlX6GA2-J!!y>iBYcXzq8!|dFd*AFCkcP)GN{q=(HpxT2t1Wxs926 zD4RktLvi#%Q|z8cYYB+qO|Qa8_v!#mv(Q_wgcUpqbjEDt7s>BPe4&%F5tF5@_T z`snP}PQQL);n=z7UpqSgLNi>+f%`e|>AJn)W*h2xZNn-X?7pvIl?`@Z)Ue71yKiV% zWrN*UGpw?~?mHP)*reBgM zUg@<6Exw-7E7{`Hx7%uBW+tlt|ZI{;|tP=40`wyr;Z+tujY95y$pd5@#DIJ?xt^U>Ae_-p0 z%;k=u(sod#1#2tV4OQT2I=}xwaV}`I*ma-w`wvjKYe%rWT6T>(1oGzYKai{(2 zv_Tml$W3}PLMI@-POJDPc)9`c(ze34@PfLQmV66?M+zB*0yt%$CWmV#I;Ap$=>mFd z%gPl4upEom$wigf+#vV#go=jR(lBP-5k$q4Uo&85O{kX8b4=;sFp~Ge z4SUQEvX^K3bXJ5SBaR>QAQxy(`S_vi&#w>gZR*VHI)tJPr##|9M8xg-&OzUhswUWO z%+le+9XHJ=xJ>&jF3=1IRJg0xuv9HQS)fa%4B+R27qxV-2)W6!c4Y%muPW#Ty$@RN zHjo$v?St`Ed;d4XyM1Vzk?AhOj?w2nv|W1yUmNaLZ|rj6t{ZMz2CHwI%lTbxYYlVt zZBzSow@sD0`nDN&j(OQboQlQs2*>hBI}YDy9W}MCd3y|)AJNrm-DMn$Ev=9<G2r- z)T%G-aJxV}OrVUA&4o=bfT;07$O)-k09pW7~yilR=3jCJkw6Te}-)niYm72P-Gg_&Z%IZ3yKSKF@RiN z;V@&AHYa@Q`D?3a1S2~71l-^X1C21;sM4G$&w>FAOp*;xS|i$D;3tU*Q%=jKGr~?2 zQ9wHSaBSYen}d?(_@i_4=s6>FDr3iIxhEt8b}p5RiqJMwZnxnD1w3yO}3LQ!Y5Wi!R%pskp+6h#1pm}`zT zwkPJo!E~7u(UBiqy`VXO*z_udi30`qGKbjn5kZF}s zS+uwtGVU>K(g{i??$1I?KpbqhP#^Lqt!@;lq69adq8gL05}T#ZU=5T-C&*1bQxI)v_`Iv6%y-4>wIRRZ6>@#t=#`;3oKzCoSSVayKsy6&G(rsT!&#WR)6zNmK$!P_zqkc z3`1)G+_GN7p&pyONpAAcUhuRCKMZHNbhJ$)NNCoV+wmO|xA{XYl2hpqgeEO|h9U}e zBnB@X1x44okHdPv37u+zgOQ4A8y*^CMPvdYwDto2xy)A=`Hn3@zp*L=&4Zxx%K~{; zA!(8B7EViKzKpLp@GK9Vr7|`%!`1EBiiXcq+NBl=tNa7bEry~012{{KB=M-Sp_Fx( zgqc8Bp_Uo0A}8TO->&VTVeCn?u#C-i1)2Ofgbq((WM~!&C4l9qn3^dgMFIEju1)Dm zi^v7xBEMnJs#w&d+>J?!L@yQtVB8?41mK{K5;*eeWZld$hF{}ou&)@h(JYn(<%-_i zN#haJXlUHPNYU69%0 ze4+wX?SE2YUckhmj-&Zb>>Ns?9nBzG($tgr5Ua9zTyXGu;Ws|ws?Eb_rAOIh&CF?; ztpm#($O15s7O@E@noxweU=iV)?pG{YN^Um!p)xd@L_rk?dQ*}kAdD(rGIOl!5(DE_ z4^e2@juXu|UqrDCypj-RtH6KNn^BO*i$egXT9BKuTWI63eKIQDoaF-lmZY zHHiQZV>h`TRE3KPM#K}PZlZxqYt2yr$8_x~W_F_f)T*yKdi*@_W^_Lx1VW$^I|~5z zFrOm6ZijN_tUamfvEy*xx{*;cmUg^x zC((m;?n4``a{eSOl#0-|O$8la@+ZACn~9p!<$lnrw@@AZ6-3ktQK*o^JZKxXHg@6 zmROoajXR|?wP=>vNv?66P`h~4u8B~g1ulAmM_aK)OTxFQ%nz5le$Nk=2Oh<=)$u48 zMa^kBDOOspwE0s;=PT{$dcg~E#tCR_#ghBu^*Ctf(3RH1)8$Sf-*){_Lj?T$NgrRB zq?J+TR!37yR2nOYdEyN~qHH%~(1pYwv6PrIVWXh&lNW-hNDG;-<7K^&_#s5A6(y>P zR>K+vC*mUc=6kp_7CgNs@#PA z+4cX2Eql~x;FsUR8fpA!i!#`5sLQ|kVSm4ep7QR7`EdAO5r(qvar?99|LRu_U0TnBO>ulGeSqOt@A9XTWI==z>3pQA5nIzfgyN^Rt?H zD2A+~u6g*Qb;@A-s~O*MYrgCM1>zi^Y92luYFx$x&BH`B56#9Uj60u)>nPbZ5Bpn4^{qca&*+l z?r#_mS4-C`!RPJ%AUY%UP$#c%;}b+_60LEYUY4epuLQ>K@muMY;RfZ4)XKU_tqe3q z@HAH|#Jo+yZTV1{bH5DydV9W8`*yA6T2cY^66|&5?pe9xT3R-jb~uJ=5%%#kgdI3Cm*aGKE@0Q6cYm# zJ_Z{<1{66y`lshs!Uul?BRn{5tHsM&%fFTM_xo!)?<3W`C-%+n*3A1|c((R@@E3i+ z$89`PQD!DAm>u9}(Xr_;?&pfSekJ%H#t_$X zd~4kwweqbzzPE4j@sYQ0<@vkK4@<8D{4&e4wT*}MvR96ROLF~1%36DS<#*SZU+F8a zRz9rWeweGl|HorL{B|Gk@ypC_Yb`I=y1)5beE#}jk1ffs6bcf3z2xODkAHXR7N760 zukrY}d2hA)U?uXeANpq{{jIe;TI>F9iq^d$nG8XX9_yck|on zkAdI5Ucq-)1>fC`_Yk(v<-v=6gKs7Cb=w|V+CEu6J@%UKpKSgp=X?3^_2QSmui1Zg zyl?cleE53d@0W*PMs9KabR27otMxaRKi@|iQ=l@*@2!=5+}8M`8hT_*xIgyNO621_ zG|6i5v6BAA`aoaH$Nw{pM+5%1RQSK6@ux7;e>wEiTH}AM{ga(Iv$vM?wG;Eb+WwYL zU%&kP{qsJ^yOr?wTH9NH(Fgik{(Se6Cp&BG@sG#eUF-Q?Yk9KP{hjWEzFKSkSw21Y zvPW;*^H3u_Ke8lbs`bL(FONNcsSotKe0u8Tf8CB(^du%^P^P)*FVb4A{j%2bW+nZt zb-eBap!QbA=TC0&@vZgx&05>9zt;!(yb}Jqev8w~k3YhDQh+*rVtKvR^wN+1maosF z^JU3-i$4X`=JAvJft&usua*zrM1#F5zBW|FcZM6kT>~E@as7dBCH(dm==E0CKfl+9 z@hyM8d!3)-#aKB#a+cP9zWc$SE1|Eoj@OU%VZK)~zO}~ZTE`cT-{SaOTlp|nov$6N z^g*NXL5+ME2j*{m`LNdXwR4T>xgYCE6M*?fp9XA7BbDLC55k}Ly_NNPKjh%@^?I_7 zLXofQKDRaAu30C2xtxL3;(z(@%~f`0a<9#m8oBb+#{l0~s&!7^qQ^T@M;q4$yX~U+ zj{&}gY8^be&h;=>Z*sfsw?78>68a;_gTIf5{_Y}ByhkXZzYl8oF?v-}-j(KgPK7^6iygaXV6ZKHvBM|6;zWKi87K*IItv>hk&bVQH`B{H-;; zthL`few!cqdJbi+`ERZJTWfj7n~B$w-`9G4Yu(>k@4HxQ`uxXe&+Uf{zR`y`bW>b$ z?OT~27)iU8$JY<~T)zFkzq*Gzxo32~CSFM&us{CZ^5L6kl<}^`pP#({C^TnrCox{FC$79{+2tfBS*|UuOEcjnAde z5wB$aZgqVAJ-Gf>wr6g2e!o4w{_;EV*%%!zVBqP)zj@6wKm42d{P6F`@cSWFUimjJ z7AR<;@^8NJkstmo--v&2kJ`lFWjpwrb;nSUWy-p{t!Cr?oyEk1MR5h+tLWfb6NT~q z(<}Hk_8(n$X(Q6O#o{u)BWUOM@6l0|!FORh z#(?joJ5d(K?gYMv@jZ&~aeUv!_bR^E@V$=j$lZVy-wAvV@ zFX4L`-z)eI-nUpZb}$OzpAR1>)9W~EQF@>NBBS(RfdNM8Mlq)J;I92eW7BYPFPc2Q z4u6+(yQR1cLc5Od2#D-v`X1c1Q*Ga;w()n=_7$}IA->0Nvh9F}UgHY+>kCdog{KYV zgeW~!%q8jJ;&77QSUi)YHx);d^ycC#N)PTjuCa0@==eJPy=}O71b;t@Z#?dR(}|lL zcfcu0^Z2?5r~Ai>D1$v^e%L zdExvP${+RgnE!_I;ra2b{B=)X%F2i5A7BIgT+7HjKWaY%>d%gP^h`7+|ap?r9L$)AVz zuX*}PRz5txo|QlD@~QCO(0+Kn;Lk(**FAkXD<7VZxjYNyFL`>xe?$A>`Q@y90e!*G zyIJ}0e8lrZ`5-w7=l#qy8J(56>@U75|+>G0Ke(J$==GL;3K0f(ja+Q2w%~kNR&YAD&;y%8$4{ zxSEv@&kuWk*}kWb`)}F4r>|t?M_iv=&B}-8mmf>vzvk(8{Wr89o?p+(A3b383;zw} z!}H_*Jive5)0eXH;rYnH6rSUrp77t$et3Qf_7y+WPmkbB+lU{gnHBUyNXPaA%a1u- zhWvN4^oKq#%zu>Sr|=&>A$`>Q=lF=4%bs5FU&0$dKkD#>^6z?j!GA;f@ce34{;=z* z>sk5m{Bk63*l&I2Yep*`ol;b#Lo{${LSZq-;YQ99Y23JqIW(ooDO4p zkDp(kWFg}xKA&)Wf9THxe!}y2ahnW3oDY`2>}lecD)g$SulO(P$IrilG(Q9QlHb3~ z|L|d&D83M-+5Vrv*XD=$Z0G-s(p!=K6@2*#?G@Oy9nx&?Z=*EZ+k1zy%l4+(2tKUO zKc8U&pU~ddBX~$+*P=Ar=i6iX;SbyYMU*DIU&-J-Y%ada`=2Ov`*Rxuw=r-V1Gh17 z8w1P3z=vGG!Do4;i{hRCV1*Z{<=)>`jGte(SinbKEWS5Xz$x2x!2=Z!pvApgi-8V& z6gEzOjpfe`EK-%JJkn2JKx_eNL?sC2 z#iFZDDA9w(7hzXj4)y<<{kt~&JRW-gf5d$D{{iwl1B+CxjeF3_&-N7iIs*gEE&t0z zfQS8;$oQLeW%)stNBx10D`K|yQ;Y}o{}3o?4A}Tle^9EMN*zaXpTzj=gYo_Ko?>U2 z##4;{6W<8=_yzpLR|&81JFv(Qrr<;W&oan29mxmesu_=>NE{-XB(S8M;>JyrYLI|IV^;#J^}_1gsojP~|g{qggo0$=@M zyhH5~(F0rHct<*qjx)B5w|9>az{TtTm(sgB2N!8VKFayye6tl;3%Y7vp=>#`o_vUr0}rUKU3Fj_Jk#@NpICK(EYK`QP~W z&ObXu|AAgH|DzA6{(sW^j(4V~$pHhT$M?6540dKk?`)FuJ>HobkMe=Pfl-3L{rbOQ zdGO~wOae!$4}Ke5bQeV9+1{BM7rr@P#Q((|J4By~}&(E=>x{WZ3C4%mFMec+Guzz{*8@4-%^8V~#L?Ab$BTfF`se7+wO zenx$MP=63hNk;!DkMse-^WeF4UG!hWANO`1d(0(@;jg`0^s{@z_mtk%+4&SD!qenJ zz`Lun>nWC38vPBm?-Tq4f%qEiJib`Ar~G>jKITJy=JIu&d`>PcVfB03XKpg&-fu-x}|8Nj~NA6$!AA|6r289rB6z6ThlH zn1>&>kNzo-kB0h?ALHjXr}Wyk`jY3U|1=!6>!>Pu^H;#v#m#hg?4$P6{>R&!G~PW< zp9Af?3a;st`lUT=^W*vJJL&kw+e6C#gy-+-Y}w5DTjcz`zpXLexnr~F$?_Y!I$Jk$ zzN-9fn>8QI$9#>q2h`psrZJyEz6>+{9@7ow-=+M6NUv9Vh-u8{x6cj;TgAVFgZ<;J zNb63ALh1Ln7MTAHM2O@W@H_7Fz0u_t=-KFD0`qP3Ve{Wa8t{y?@4Abws_2LHJ3~W6 z_ZFw$k@ludRAp8E@G$eYdj9_Qm;;E1!@pHL)P7FnE3AI^Eue7FtzPm_xh)F+F8{|Sx%xe{NWRr*Moep%@U%k)>3{uI-|cdAcC@1jT16UIyZ zsUA5f;^QKr1HU}DAo_p$!cbu`M!@qQT^}h1N%+*>t*lv1%DqA{gn9P{KWE^HH%V*ku6}{X*-bDB)?ag?;J|cQ4;nVy?_)|KP&k=lIrTnagC&$MI+lmzN zPuX8SKS&39kbR^49A6PUwf&p_6YL$@!=*omc-}kTTK`!9gb3kQENU^`c%n@2--o zU&i>yto{8X7|)9se@GL5`!GKtJ%%*r$J65o33@!uuJ0p$%K5F9 zzdkE?1Ale-lU@Dg{2R#^%9B{W2|pH}=xv{yzuuSr*_;LE(*>W!KZ5=p={)$LNru+MgNJ|+9;LB=~N|K55+`c*<}81nNi z<3I5umOCT8vSE@Pa}UsMSxF_$9$+gA4pp~#^cBTF~rNq4+=ksC!_u|m=E@*`9S)H z>no5q-~BhmbmXIejxpT`UCAFwehD)Ul@H?`oi?XqnUmyp{z2#%BANr^dNe}L?Sp2Fkew6EnO#XN2hZW#k@^C5r zxTJo_J z*5e`XM%(v4bwBfWVttwP-5GqE`uyH%J*Qglq+xj&1 zd9}W&^1FAl{4Ot_uRjj8qxDAgPkZLl|4t1Gef_tL_eJ{;Aa4@*Z9jp}2iJ2+kBhRE z7q4RdoZ~rX`!j<7eLvdcXW=hRzH@!?!(dNiy>AfvG321I5b!nrJ7#)^`d{3I{Uf0~ z?5$lFsCe+xWmECOx2kuAl2e{}=O-?AK6weeuUEz=6;m*f{)$4|0LF%H#7=7(0V`U2lyYR`6B*v`nW=L5}&Xi()BOdKf~MrqxD;@ z_siHZcm$sxIC1#5cZO9ytha{s#`UGXvi%HNf5iNczO`kTEjoQQu)k%PpiAE<|Bhky zuz3IXi{j6=6~FVHVnDp}@35-*i*-zI`9d*<^+!v8dvJpxl4-GU_ zT_)VypF{po)&Bbji}8UC(&rlqFXs1m28#jVQ|&)le0z}SV}EG>N3d51hQ+#?<>#Mc z`3=JXp7$RpegOK>X9E8NzsY>R5BY<567d`8Cz*fH$Nw1WvyrRYitk@AdP8b}_UeC& z^;qHW$^UL0$2-tz6hC2E&c}P(ijtl`g#C)~fIf6}y6n3To)kTk|MUTUgB3jJ|LqG6BOtd=-@Y&?>qz$MD_e{0(4WNj;w12o{Zk_svA#_Fxc@-;!F;Ws z{`{cq_YdRsOzt-d`1~2@y@M1gXg>z%f2f20G@)q3_+gv?1b+Au`~mxbKQSKk$L6Z~ zo>m#whrAdI`4}(v8(fD75BhGXv%YZrHbQ?yK(GD=I+XVKI6n<^DD6Fs@$Bnt7$>c5 zCw*f7)3?v=6e)`y_ZLXhI~g3Zer&!Pa$GN|T_z2_S{wL6v_D>*R^2q&}OCb&Y zgZ@M++gV@zZL0eF@o%BOtyO>TW4+M(EAsxh-wXXc)ZQt9!RaraIgYfQ*aG*0zu(q; zUP|NyrDbFwBl_Wwv=fb zpEb?))IRd@Q73Aj@E-;Y#2@34gx}L8{2@QU?`gD8eigl!^S{)1c40hYQGcM9kXC;j zPsnF~9FM2b-%xu{{c#N9H}L-h_*49!)8Ft2>8~2^)-loFaSh)1f26a0Q1*-V>(PE_ zj4OQ=`~ZI6)wxsq>$dy;Ez0k!?A!TwSEs1<-=Y6y_~VU5!pr@mkl(=HI3>Wsaf=^} zgC8lr2FYI^Y#RZ;X@A@xmGe6ff8*{V8~s6)%YTUk1GFPYkx~@tL|=?)Zp5ZJ$|Y`{O?t(RgLwyvKM! z)ZbpvKjw$@66DqR4|Y}f0sV~s0NWXnulkG^fb*{lB}RX{I@`6MQ}p#GqKECGk0}29 zZd87}eXrWvNqS)W?faD8Ri?3D68(*o=^aXsG7bB=JH9-!eL3;v`&b|JJr=w7`{S$vsb*L>Mv>!?I-J<;ICfs-FqD$-SJ(c@812}{0g7>c-X)D z_a*-0@pHc7cr)Sic*2gJ@Z|WYk7rc)$nk%J_`cw^c)~qB`cLA^)VFW$x^E`)!e5LZ+=#ypB0u6U%%}GM_lzGX zo^Jce*+1m#mtfD>$K=64hk^;8(msU12x;QuJgWaD#$WQI)Vq~e{@`NqQk*a2+46zk z-#J?hQ$7^0K?*`1BfTk3fBS6eUyYxKI`}PbkN7#iez7=KwGVr*vY)oYKRR0s=z;vH zJ+L3)pYjv@sn~w9^0wf}^6;0wRQf}P59p%`U!)J{d-Hw;--X74Q;YE;UUKw8xS8a-;!mrE zXPN!O-dvmhyU+i)exQ+v`DQ%nUCuT6i~JIw|H1shf3~%5vLVj<(0{s$KSf_C4|=?t z{9^v8>GR7WAM&xJzt7|0-UI6IkCPXm2t^oa51=Yi-C zQ(gvtJMgE@^H833@uMWK#m7K@`*_|0AMul&*SRMj=)6u%dpC>+Vt&WlroW}n zD6h`l747G7`5F3GKGYFEl&6SCjdbq729m|ao!9@B>?@29uwuNl#}Ka=YTvE-$0PY4 zBkj$1@5G;r*Z&`tAGvtfUFG=`v{&l)4d3JWj*-!e*qu%Jz4LcizA?h{OT_;N-%@;V z^y0S7I{!2FUD;dvE@HboL{^aZfaeZs_;CJYq_c(KF76oruh&tZjb0qxO!?oq|NHCc zUySnn0v5;`WmCfLJo%W2kp(WA2)CKp7;gl z4-_v`KFZ$%dKfv63jCnIq4phuPif>2wYOONd{AS5V!!`Ra%gm(WD~cum-e)uFWABU zExxf)4xOJT5r2{(89(s&#+8r;Kj!B{#?Lh>dcgdY^Q-fGJnuni?;pwsKfeLV?)J9X z-8Z|RxIK4gnSY-eEYEAWeJJ}8_!;l)k}IeA1wD*+?uYH}^9_8Bw=Eu_ z^BW(WK^pcP@@2mQKAx8#w2JQ|4gD+sEyPQc^BI^Q z^znM;8@|i)8^as4UO@W6e2jPQ)%lJ4oIXa{jm9p)!+h$`^@``*p0KKbOA`pi_+RX7t}RRE_lCJ(7pApAo<9 ztXp@D^U3&$pVz#t4}mVq(;EG?>jDW4pMCgBADVv>>BEtXzDJi$-;ft?gI@Fr^nA|z z8<#KUKcGOFJ{Rdf(A&txJMT38W%^;Hvs3zTi(txA1@c(YuBNS}mstv(r8LZ4K})#~6KKY#yXF(1vx`A;ks zC*w5G^@gV*ul}2}#X8F00%2_WZ%p&b$^x-Y*|X>2&Yg>47N_Gh%%Rsk4f-KGiU1S7_t%y7kK#v|zYrf$yvoaO zA+4(XAo_=T3jVF&8A|+Fw!f7Vs`Bem9`5YRF+3X=Y43=>z5Tn!Lir(-2YyO_7W(Nt z@N+D#5BwbW^m_-95B!{n^MRjNLiz~ufuFB=8vP~lst>-8bQGTgz2@r457H27WlK#BAJ4$Eg6{ZaoFH_(Sk zeETN+>6O-BTK_8ATokL&zgIbS-%kMi=>me={%6S#iVyYHxAGPueY-^uB7M6h)33P`!J+${d_cK812V4wtwQ!Ex}(nx24h#lz-=UFgwz}h;Q=a{sQ@f1uB1Y)GnN0 zCGf{c`)(1G{7vu!{KFlwe>idx;Jv$bJ!oSpM(Fo zt8?Gobb#&){$J%zcHTmtgrdO_(v|@ zeYfQM_5a)V8{Ih&wGV%I*L{-T9{>v|kN9rpZ#EkAH|3-uf2h5qy5SoAL4H_&>{I>S zcc0>+AAD_d5vx7|(dy)_1~u?CR{fm$)eX%g+7x zmiPpH;=KND#tWoh7;k7dc9;J4PZ1C53^8(!{aIUyFZiG9m6ksTd*j<@wVlY~w?F26 z0Got*#dDS3+K>aw`0o3>A7GR1x8Z#!KRbf+2eu&*i5N`A!s3e>M2-x-FyxZBd;H?*JdBk8fTYZvEdJMp9S=KJombns7az+b3O zeO&IZuklY;s!vy1KG(nWM@MKM&>sc8(O!J@7l_c%KK_NJPkoT4PhL;c^M8@1kNrGN z|JI+U>91Z((=Y#Nn*Jxe>@n*9H{MIrU%r~AU;Ig$KJv$D`nf+!(_eZwO+WjGY5I#l zPSa2Q>oonu@1^NqxtyjS|J^h_i%tFUcxK*C)6-y;IDhK5)AT{?p@{PjoJ-S>Eu`s3 zPp9eoo=Ma9K9#0-9Zu6bA5YUe=F;>%Q)&9{i8OuJqiK3zXPW-Pk3xE#=g%EW5XwL88<0T14<1ndgYzMO z5c!|gZWguo;B(5~cRb|7KWf`~0vpCAM*2O+Mn>#gUa9Ym5>jA%+I$f z-ucrb%HREB$Y=XnzQz6}#?P(&PaF;TY=2K>4|)6dKO6Gd{%+H+s&DPzxj*EyeUtxN zqxQFthkUkwzv?SK>+O$@g?zSur}8&M?T_3a^4Y$Yqp@bj`0n?Sw)J-H57qf!TYpyk z_1cj%es&G}LFkY0L!)5tR;>R#uB7b!SD+6sKBiY~NFGC8=KFhj-x%es>;tSXKt9`g zXL;WkuIEC`bkX(K_Rdp}?+NAq{9rNu)&Y&Lv=83G^0^J=r3)Kue-rgF_B&%gDe}=4^ARr_=?pjIk1PHR z|J~OI);oSMKJ3p8`u7OOI|TF<#R-hp{pCwUxb!*T!Fs^hi3(qd|E}@d`IvyurTqDS z3HyevFUr25KOBt@^g;O5AK|Ax*4f$^V|m(3ve)hYtS}z7$MI}Xd!)Bb6+X}&_Ujuy zMZcV{ZJPh}ZXd8dNpslYVVd^gCT|aE$&ZHTWBv0U4S+@(^d-}J+fS7qL=+hfSpM4= zwt$(C_W23)BL4^brNaJ*I|4m|Uyh@y@DF-S;0HaRKdisU?Qf{s2Yn>)VErQWC;rBM zlF*;{8SSO7_>Me|Ski1+urNBrCRjN)79Kacl}w~b%JewOb3 zqWXd-iXVv{BmM?|g?L)YpD{ejxBWf6_7~B9I~?W%{QJ(EphXH8TFAinJ8w32lxg1g z(~kPrcx^nwALQZo_QA$M)L#61^7lcMxAiNXZx%c@zJsI(_*?rrji*R&nm>%Mlz-3L z`O1+_@z@9`K>UI7xX-Ua0&@En{Ij8PNolihhuWJ86vqc#E__*k&QBw3?=H0m{!_l; z2mGS)N&mcm&DZN5HGUeY^8XX%Bl7LM!=sh_@%<|Q+2m*E-cON#gZvn3Z^i+AhY$E0 zLOk3RxYlR6zg7HKTv8hT_@_9Y2kDOkeehB~X(uJ3Gob^ZtK%m2G{!TlM^oA+7JO0n+1W`;Mo?KTmz1^F569{VinBs{VSb{|xpAK;BjK z_;<1&N81gn|E#U|SNY&4%zu@}ATZxpZ`tG#GUt~W;mhPH>19@FvyYgz`wjy=!ykTe zisNCt>1RhM&!Tluv*c@g?2A zs3MXVb|2Q1>$9QuozAaNTFj5{msEd7Pvw3Trzgo{v=9DL_&d_icyk``;rcl6<7V-r z%8S0DeDSC9(SNeOEBi{2m-cDEN0`6uohN8rRrY76c!Fv1m)lEM)g$aj=m*eGWIrB} z{WvCpi+uFIq4O)&VNd(f>}&P!_Tx412k@`pOMmjwBt^)KV&~P zWba5G$$sR1MvSPm9|t$kypaCj{sgDzp-O%?I2?=LNWQFByehIEuMk1OexUt0hW4Bu zy7l>L?Z-{Rj^N)*`*A}<{n>rO(0^OpeguC=o&fplhHNw=_&FbKSulWS2$m__UF9jZz=mz^(9Yo`}3sgi{3>K z5q&e=!~P8C4|02W8TRLBYJW!kzejm)zyO`dId% z(OYC6djGOlU_Y9Dyv^5Vs`^1c^X!N|i9I{(@@A;L?NRPO(g*k-YOlBb)FfKWUub`Z z<%KVUNBA=R14f6Qls&eN@_k1370(ZXAIRU#7k^_tANjMgxBNbJu7B9OicJ1j@S8oi zzC&q%4_7_@t=V5kW$>E3$NI~QpJF!U8TVUf=e3ji8jsmaCH-|C(5rSHbo(-o2amRg zXU5t7*d_TJqwS3|`;eX;2iCwJ-S+H$*}nz#?fbG%H;keD!cpSG?9B&|E?z(y_#SC* zd6C0e{7d*B*#C6tovo4mLI2$DH-Im)!dH`3X=m*Z8uANU0Q?cI;`!gimZ&epBKB=RvouonZo z+vx8g&G^+}EEiPkJwk41f8A*Nlly6)RrK@Fey*oHMEb#a(BIZiB5m+0z3m~S1uyWe z`^2F>!hAh_0dLw3^Y?ewe~j--7q-{}73W|6)n3_mqDRNiUbH6r)HkG-Ogy`&Et z{~gQ^`=>wmjyf;<=XftM-|4b9qi4xOrH!7${$9XOax(e%xAKR#aDZmt zC@p#M2<3&|uMv-D59G_1bpASp_+R7uIsCxlqulbX-Cf5I2_@A9hn z&w+pQ`wjNMUw?F6F@hm;zZhonI~T^+6=+&%FpA>efgaJ{7k3p!OrPcb4kUuVmcL#3 zKQ52>j^@Bm;XH5^|BmiUp!`9+pY*f7^k4kE742Ku--dtLr@$}l(Sc0`I-rpPdlUAF z^pX4*TQ5+S^po&q`%mQ0pg-WdpnW2J%0Iy^oghDdEfF8RED1D*6|{Q66+Yi3J?R$8`Q5@DQ>n{u(bM{U zC46WP_#PuT;_ttee6INY>r9(GkUrT9`{OLyWcmMX0_Wc_-g6Hp?*rI=c9RK|`;q_t z)&bgkg<6FCMStV%&ucu2hX{Wb4^{kx_-jun-|P*hKclql4dm}T|L`1Wsd$+D@MlMG zUSsiL!lV0pAn&%f7at-17O&zz^!HGEi|{X@H~cp7_bhU3(P!@%-X~Q?BQ( ztL_IvdkH-1FT$7db9f^B37-*s!ehFEocVkRO@s$TY#|QK$AfHCx`t+FDBi`RzpV5Aw2ku9Iv=`sm`)L+ed$Nzl zK$xC}CHPSLFr+-hB?oczd&U0trmcthfFHa}7HREIQu>txphv^E{0aC&s4saVqw?}| zOdn=h{dbh5tozT4m`wi?Ax8Ka6Wqq#y%*~PCb^i?D>GmH!EqrQxoc{~0YW^V)$!{fngP)ee5B9E8>;KY) ziBFgGDf#+H#t(-xet71QlplWe5%R-f@`K=e_?fajqj%9~MDNX%-hXW(rT1T-p#9yf z=>6A_jOcyhnKHds^tzwvhe_`vr1$45ddJJ3_qPuZKd%b-5Bp7spU>k@-8Uk7f4HJ| z(f7j-v$*~nIY9c?pNBapv5?zK9bANoL(634DF4yCtoCjD*1W%kyL&@GnvuLWJ)iskA+@Z%cqxzQ+jD-^wOgG zDDiZ~T|wuh4%&WBQmpg8w_lsgXQ|{6_jYOY^*x63F)5t`sVYUhpT{=BD_)RpnnjqK7M{5__U_<)Uv z)tlQwvAJb`8SFoIX7d)bMRsvF*5}{fg5(~&%eX7Fz_>8it&N|H+efAoA23_^86>`r^Q~)B(uo84^!VCg6l`$ALM$5{fsAx z{hz@;iML4OKm)HIJs%N!C0;A#w-9?7uMPEYpkF`l75yfj(CRPue`7r0`36h$by~k%pJ>lT^XkfKRPM(W&^oWSjyLf7EMa^HzAj?QL%chCeu?W7fiAcd z7K-cB?*EYT;Lq&-A6s6={!Og^mg0Py?CW&v{kwRD9(SSah2b7#h6|4MG)A7X6rkbltezklo>O!?;i zkvA8=f8swWe;~@w$ta)w&FaPc{$`H3_3J;053ddJSC0=zv-h{i?Oo1) zME$V;LA;mU|6%<{u%A+2KeC?^{EVN5_b1d8FNT}c_h)Gz+`o|z$BSDc|Nn2inBJ5B zIQ|aA^8y3{?e9M}^7+9&n4n?E%6>tmhGGBofm#6b$0+l)dinWU%t;osL$-NN)n zj^Yjm)<@|0`B&d?9+!vxy@t?n{QICV9osvHg!7)GjtJ-Ryv6?BMC1{!9u=mSIci)u zzn`Nfg!6cQGbx-$IDT3CI-6I{;(2`>wb9Rm z-rrF-g!2OsU=HW8JiIlWALyt%!ucVNx+k2+c8P7_{4lKB!ujDiwI6ux&Z-(<#c)@l!kNvbCg!9<``H9J|!`cVG=ldF2neSkKNXGef zy9UbhT&fn>usi ztci1~il)q-+_`AtaZ{$ws0tV7+x>ql!CND`x7xpM2D!XnCP{9kA&9Z_n&jU!a<`oj zVn#Aso_jg;4K|Z+_3b*pn)7J+j{8Y4Ws8E~SbN z(5-s9A=o}L&FQnB`4{r*jQpFXa+EK?U$*>RnqIB^MF;BgxtERqDDUAfTmBBsR!#m* zBmXmn@sILF_{)}mUstS}{Elwb%P+1$eugYwR5kfl-L*Vpjr_-A8sjg!{9hrjRgf$A zH^Ip7)M`YY?Pteto?#t~t3O*ONqu`7L5W`J^273W{GW;ou%`0+9-`$JnR2ZC+2ub2 z`I^dq%*u!QpY^x$w)_G_7iuiOzb@a_)Apa0xA-#1*Hr!yM!r?Z{-PSnKO2Y1)l~jj zMt)F8p5Yh~p1@qZS1mlHz75EuTeLqU9|=j8o{bY|n{y6aO??S+1A+q=5GvdCPL%0K(fviOh9N;&JNh=u=c zJ4@&6cUX>P+Wrm8NZRz***|K#t(@h1waU>$V3zr|1oQoxp%3~C`p<^G_Alrq5-edT6|%z{=FlPrLvv&k+!mQ`@J#L+}#B1hJLK2j_BTh$jJT^ zr<^eI;3?y$TJA0a538CnbK=w~T}w+_SG2BZTUx5R95j34q;VC8&zm`6>daXn%$z-W z^2AvIW$e_+(bZRqxOy!u$4y{9lkEj~WO15bg2FHz_RRwU!>?*Nnz~~wB-KM>K zwQje6WrzLSw$@mNV6SOY$FfaYw`~JJS)<3`d)5s7J;A1CRn48HD$oj}RmGT@GgZah(UY>) z6JbsNNje|Q9Ob;0!~eR4Gof^FMQE@XU&ONgb~jC~_L(ieA2{e6{&(fmkj>V~Lc8$; z|8CDBW@SaTrr!J6FwWI#qwQAp{ZBf&~h*R_(Jxk-|Z8|nna;X>1(e9_H zQ$?$aRz*!)!cVlMi!dHS90NWkx12R~>ZF<4KNO8`J$6jn*5k)_?9{2ln5waDTDKZA zc3k`RZO4x3SkoU>o%R5{kPp`;H0c${eRSXb{gBUa{Sm1?aRlE8(Udk*`{sB za(J;$IjcgW^*w|@6n(i?>u^!*59&>w~ z;>52Wi$uM1aS89Sz~+RuNax&*WT?Li42#Kh>Mh8JN&8#__+Ssyf@kw@7@2R6}wDbk1ERhED*47=Gv)tR$eNRI2PbP0^v;xWN@RxVno@nm;+mU>c+51`T zc${63zZ1ak1Ro5*f<54#OYxWYXnbFC6|_a>Fal2+fNS(~2s|r*%QchAUk~IyqHh;M zOta=c4&Y;g@A;tH1Z4S8`Coy={qT98l@p{Q{Xrg8z*kLnAo)vOkVX#zGMeb0Av84! z$QeWEZGae!W<3J+Z{Ii&Me=c(ic z$b65{pEu9D3BLn>zA2IuVkcnqIPq!tbieo)?5;Zt{g%h^O-!YhA^R^vCEAD+-z2&o z$ZbT^4l5rQ)H}F#R5b!Q@5udvMyw>idY)ubF|+>N%|s~MCe zuP{}Qk5tKB7-F4}uX|TX1qN=c793AvMCtcnR;9n;6OR;gT%b<9sbyz@Lq7Hs-g?tZ zo0EdwFmylTDC=I|v<FHke3SiUnDo(jL%5ZhwvFy%|vtk zOKO*XjeMRGtGZx{5z9HQbT`>cxv3;l%A+%4rToD`?NT07l~?NFv#69?$`&n(!RkYh zqSe$WAJwcTWiz;9IV(!1<6D)^r%dUY_>7dEM@s2s_|*FDCJp+=p`qm?TVKPR-wn$N zWZ_3POI~bJGYry#7n%=6bWKI-osS*a1wT9SejIHrB&X1C%({b!B_F~dy@BDn?b1ZsY!O*EJR2O-qwumE#p)cps_v{n-^gHEJi+Ujbh?iy*#fnrL08+CZ82=K>V zAAAW%pGZ&P&?UYPj%Ug7k@pe4HdDu-unsQ*NZ=7+LC*u+mE2=94Cw`E4B<%`@Ns~a z5T2c(WCfs2gcoGMTL96$6`T=aYddkV)q4(b6&y;zIbk^c4d9+r0I#;aKp~Zm!xIXA zLl}2;*R=vMm;L&bAu4YepdM8JQdqrrB49ezg0~~usfsb_%K+U)_`9%nto)T}sql1jbA^KD)k^VtTUwWDs=d*mEug+WAvxupZsCC;5#?P4xJwDRhi7o#XW@|<+;0G0 zi@QU?l;|Co+sjXRKUsKA^ihFz`_+fu4%B@{)U=WAnC=$8*y0~cZ;l1NnEcloTzSio zy?8%BPe+5x%wjy*xC6|}sHYc=^VcLiFK&#;WXn)*~DtK$-D_6XUm=`~Szk;bTmJ+F;k3Dx(M1>lX zkjoF;KVt)NH)vSUx9|yEmdC@Qf^`7r??Z54;zQnA3x^{|V+#hW!cjJTc#3eJYWBNVFAXcM9;c?O(8U&8&8=OZcYGa&y(AUvY8 zV0u%q#mmW?-w1$!vsp&Gjev&&oKMbq`{PN327?>_l$J|Lo3AzK%tFbyT_~=R(=@`# zok7kFkTBy?4NHZz=yHwp4wS775F>gHO}Ii}mA@L92MJum7S_B{aKW=c{~+ahjgsyP zX&)Z`Z~*=awnRe`)kg!SZiN^WPI74dH_^R$aI(p9>)@55tyHoOqC=d^B#*4W5MOsP zIr(9LAlBy-*N5?!oco+XK1Hr6Oh_(%!yrc>w~EN}j|}n{a(@uHq%Df2o-fe}-SDH0 zNXo;=p!dji}&(VQ-YRFW@Z;-E;LkZgcb zKVfoQvJ78bf+Vj>HU|1Flb59az?Z0*oTbJ+3>1|-8lSDfo?Mn>omw)vxV$I695iln zuA>VU6QuOiiJyz;C_L&RH^kqzoGE;4zELv`j=$#NLD)}6(^~3H1b=*4O=zLslcdk_Ps3sdE|e^-@cn}M#bD8SsmZ9eb-db$YvZ*yeIZTV&C=2XW+cv z)X8^=V&DMX2jk=pCa;2-Iih}wUvF75N#z?;aGH|zX0X@2yC|m~2Ak99*BqZcb{v$I zfV0tWcu8JPJE6ZG&|A}`ml2gzIZ`UN4l>l<=v~U3EixOm%xGjPxXzn|gowrX>?J}-^);;6nJqCZVFJ)xjUA-eH-Rni%Z36)Tzyc4odxo7HZU4 zSJS9CN<+8b>AWcA7T637N#bPW%P{O6MNXIrnBj?$!W*ER1g>p1u##FLfmutc=N*hI*m*%t6IPP#70^T;yW(PWpL zDt!j9?}=ZXfqOB?&7kb{A(ieul!?uS-bJJx>v-qm`(38ra$W;$iuOLW@Vm}u0_(c$ zUx}$3{t_Q%a9?KOPcyi`0oD~8>B15o#lfb(>j?%R-8-obzbuCL2<*<#AO32+1a&^6I8gS!Zjzy%rHX8{%q zi;RU@$=86zk`iNyhKC`N{$&g3ZW_6;0qY}{#QLG&W@*5OJKi?Sl8)RVEFu{j1ePXb z8RB>?IxBSy)2+f>^hk7!q;`RMUQeWt%@&XgDYYE5+Py#@9inSe6Tr(!nl3%5%i{3T z#gtzJ+HTTkg)hxiZf`86@Rv9-OQVRn99b%Lj%7MI!j_QHEu&L^XeOtRQgiT^Sok-Z z&ah02|5{Vs-PCdxq6X|erL*UltoD{?vqv>yxg}f>V3%2JwP3$f-x{mW%k8V9V2P_D z{{meX;ws+rl?XZ7g^HgLPyoaYqLCY75_! z!Tlj%#+?!mM(#ma#ORJ4Q=%hNiOvyk{vn3t(a1Z(B91OL1}x9Q%0!ol*QlQkLM5II zYw?b=@Uvk_?>4{;*(6>xAsg*EWBqXtjR1Zn!W);Z&tSlu!zSJc!|8Q^xjs+4W1E}J zsmi|xK5+o>Mo~QqIc8M(96$o6La-||Zx?8c6C_HbyiiP+Xxf-V4Xss}MmFU=XKCG| zyRmh^$m#3dM%oi29Z$|iq5i&M9n`N4NUt7f3K@=2hB%F@P#2dUD*XkB3^*i?G(_d? zKM2om@Rz6xE0lu06_z$3$`W)dYVYCg1Z_2RCQdL0v*8V`&0z>V(a0&)b)I8sIM*jz z=lh_|;}D-yU9R(BLp!Ou+$zw%z+YlP^f-*9aN~K$A8u%;Mkfg^WM}swm`&j?afW$_ zB7;X}h*txy;7#hPG!oMxId>=$yp&F7g7XOpI*hwNqCUi5;=@R%1V)+&ZG^OL{HDC{ zQ&(?`s5aZdG)S(aES|uR3b!{IoF9|>e0^(fzvk$ODx)!BrC3n)#XX4&s`(@Z3#u+G z(_c_A=XMv!E~tb-jNo*+Va|)FBiB4fV8SOWqOPc>zviho2|s8;NnG=^Z;o$oRN?0% zBkC!5RIf@EKHUrfUp&zD#@BAS18HwkJkH{DW}0Ng{kru7c%g<117wj#qzUq0gC55B zy*1_F2=V6sU@02{ipUh?!8TsS-UFJSbX7qsD?q8BiEWTb5=o#By)mfzHK=;W#Nq_! zx~lL39yKH)F!~6%4mifha3c37H`9E85a&7d6%MX?G=M%@~w}n|UotPC8 znqa|`10f8QbrpJ`Y^0K4pe$hv`2&SHcbPzTpa_Eu3l5Yd#|I~ESb1}@Ty5ozH?d51 z)VnB*W93{-^_`-R6Q8rt{Ns^34Sz+SaorWah=uWXt8dKystgUktuis6f+P-H|eT^mdQY5f&&q?I2qHf+KCT}XLZGG1zd^Nh&9YdCh=XoBc(b> z<|oOxd*MEZ&wS@|s^u!S?{)FPRMSB+n(ptAH1t~t9 z5=puhX{@#RFM}?Pwe|XdzNc-gEA#ooTWPDiM?+MXC|x8?wIRQ=r9bc_DU%Ay3VR9Sfl!Vgd3Bllf)SeF}Egm~Cg0XT)U%h~Fa#IZ{m2ZM~B*aQVm zQI$ZvJ&I$Ni+PWx!^n^`9G}JaCVG^DzpyW`xu{j~{k8KqA^jo#iXVBH`oF{nc4~t7 zB|wQ9e2;```2&uxD}F#bYLXEjNx)IRPkt285lppyA6*to?DA%aQIQdk74{+z>nMUfki3! z&aMLQ-R23(OQeb0dkfWc-yv6Q>3-N#aWuGAySv z=y>dwIu7{bIV>g;r&i_d1xVnhavl+w#%b> zm0n&JUz8JzUgf9*7X#mt6SK3~;>9^J_H|q0x8%frL{#R*bx2>D6Z;M6r0I{m9?dLBBzYQ|}N(}|W)nw`)mCJN5n4?nH1Nn*QpeXC^HX_=QH>p2>D!D@ZNOFW_s!lnT zAUVaOigMf$Ouz^l9WtUBwfIIbCtg9N&VUAEgt&>eWK2B`)EL1gbq^xy8{x=BnPo&# z&aoKnQZ}#DP}zr3*e{zoaYib2D~vT|i+4JTjHx}L#*|$}-s6e-Wk@m(zHI~EmdcL-({$D@8vIvv% z22vtw?%GV){&DDftw7c+1J`;hm9$SAqP0xs9_1 zSjxFNqH1ye@<${W#mn@DGp8=`%W-Ly`1Y8|Co9n z44ms1=Qw;eW*9yN0~bcc-=)T&WKQ;r_i#2tSQnbQ%%XV?Cr7&UNw6(z2D<}%+Tnc4 z6l(IxOxEPd!ZYxF9uyWotCIdi;pvvk02eC*z0GoYi8vpe&cwS)jMah#dC61 z3HoQ;3^71#Xy+=@=93jMd1V-72^Tdu@My>;xd z2?)Z;I%IBJP^zs%rffoKh5V>-9WrmClerF=Nmf~hRJFlndZ!@ zS8t5FV5Fn5_UMY;82;Kr7{`%OuRUG|(O-K6M5#n6w>zNm zQ}4`i^dx3;q!j)j{sU_3{>m!HTEh>>#ARJ1wedv5c3WgP)3@`X zkkdEc*ZR}9i$HNn#*Yiov1a;4w5Dqp^MJ?EC$) zeg>OcigZ!V%Nwv~ws=)6wLcQ~;jj4O7-#7ctP4>s2 zO{!-jfcI@OWgUV-K*c2YACDgx3@%8+byWgyR3}9(`DXF51e!i z$+3MS>cIA__j^pjk45t2J|JSy5ZA2v{i#&8qC(u=TAvCo;galk%j z=1>Z4c-X-~ZJ#qUqbK4ViT-nDfnN(47sUmU$5Z(OP>z1i{0TTTMR@b8EM-GL5t)Md zpqS^(qKWj-h6kD`&zbXL$2^3cz9pNR&&4WLIn7VSGaY=5W#G$cekh_K`1(n{ikmJ* z5d2E419~_rc|U?Vd~Q?nR`CFQt>}g%{CVt2;QY-&No%M07!Wp+(96k-or?!Ioz6t2 zyHng3-y+f5X;?f08P4!Z`Zz_YspSF~q?W3V&VmrK4&o~FihAf5Hv5pkw{=|kV zUkvE9Wq`+o;nYQdPCgfKmBV(>60C>dT0l~D^DY1~+cBD`q^7mI_MS^v{Ul?&+{0XQuNFSl3ZGB1#ui)bB4RD1kR=ui z3b_naS8Juaopv6y-lsKOX1N)xlNxBd0uk>duye4MT;r^VB2xvi!W(qHq1_m!i8Ws7 zN<+IdOp~Bs-8h?Ln<-nR^O5D)E_uM3!;+Nu9dLT@l1H4P9vHS}?AQooNu}dGzRIvX z;q(v|89aVqvZS5kt-Vn1Yb<#tti_vkk%3F>-t*2CX;s%ChK8ACNz({tkG3;-5&ilFpG}Eb7MczO}Tjkzf!S+LPDot&=6) zt2MH>{sz5Wv7~2Y-~hj6r2{-~v!V5g3=x{Nn5J#GQ9p?;=`T7X+W&~7^RBwd&<2HR zlyi^mtVntmtEOI9pj2?~!F<21;=Z5fNNfuE5xu1MD8aqS!S9?%Ha=CO@DoKr(swTX5bI@48z-Z8HSbNB794Y zA)nrjwuW6L>%zl@qeFQg-D7AQ!!(X6<-K*Uq1_{@ z@msRRj9rypwhd1vAA%iQ?Qo{0s(kErrH*|7_`Ttl)IY?X1YBs_!ZbF4DnIT)JnW~w zhr+b`*hNV`TRW7r$AhqeKjZ%&dS;pY6vLNsfRZ0E zIOI6>ZG3_}(e&2h;^G8MuRb_Che&S`X(JPMZhewA;bth%9vusHMNgUClGh_gbw$t0 z(~gZ)C(9a{QHq?=`QAjxH5nyqhPRlOM~5Ve!{#pln~cU5(7PvthP}d%pc0`ipp|fc z!4^>FTzUB5|M*fEe4Pz*Mq&cOy~2DHC3}VWD8v74<=_8$vSNy(-iICB9eUT)U}DWW z+KDxnG@*(0v9!-lteJ7g@?$~(FN_O3BS02uWImDnStv(OtWQNg#GAj=QZ@t>ktw(m z6f?0F-K6W?r?P>QCd$ORC}+TlXpKhS=gRVI;Y?&IIE*IF0zaSkO-CX|M1G0+LoPb{ z=Q%;e$zm%mjS%cy-4fJiTAUg84t}uq{)$52djn*VW_*-LehZYNEB+Mnnj*aUQ!Qmf zKoOaOTR<@t7u}@mib%z2qN(^vsF>5}m!RURg3A@DIM*RkaVDhVzvd!Ju-EKrA}yg` zL`snm5hkoiW%rZNRI#!%Acv9Lb3n$(?LY_PZ(e53?IMufyetedPUTWbmLR}34Z0e( z$~|Kf0vPH>9O#wfJ&I>}sjH&xW;Dc)Z?RrWt;eyGb=N$M^~NpumBeGz*+Q~gP1apS zOJZccfo#`By}R&Th!dex_eDu`;!jh|djl}TYpDmK&jfJn6%ZL;OWhQWt-*bUf!fp! zQSTS9GuD=RB)U7qZhz&Rx)D3h9??&kQ%^+Sgcf6;S83trqa#F;X6ta9cNl2gOPYEu zLu87DcUBi!3R-SHL_RSzR>xg>D64$|4CarNQ=6jRwcxw25z=3TRBJx(5ztmq$9L6q zcpre)pR}K<%Q@%}Zk9>?5o$B7)Bi~>j%nEb9D356-B30V@ze0x4OartXE)qHk~zCU z(&p?2Ne5>)bh{eeWzTM4#_bg#BjbV$BvR1vS^w+?L5C1k$zKreHD@>EAZETkAaC7 z49;%2@G*OKL$AZ}L=Gn`obtFmyJ3()?gFCEZaB&yyMgGl8^#;tfG1!whIDXt!-+sL z&u(}INaooMrB7y`-7p=9IlE!|VW@RyHr^{p;YTO<XQhF+Z)--1~5OCA%=Tr}%=IjQx zyhbZ*CnUE*cPWOYoZT=5O-(0U8(?VqupbrqPMA5Z#h*S1gWtnRb~QT>zaZ&}BwHlw z?1m4YVL=l_MCKQ?$Nw!-8(dopUaUTXD94Z8D$NoGtJhOgCo>)X7=>Lg+?A zo3d^+r_%1=M#HSTo2?xqv%S%Lj!VegXh?M8XHv||d)~j%bijPlz_If{v^Sb%LxUU5 zAz(K*n(-la+aflCmA+$JgvCli#!p}z^kn+XONib7+n?W--ny|>T7T#H1 zb^lZssogYAu`9vaWwXad!m&ua^sxzS|n@P>kBZZy^8=745yG(nqb zoib*2;Kq$kZUYl}90VJOkUxeCZwU@@*n)Y=8DH>@^g{Eyu#yg)$ydCN{pz2|$E;gM zEZJ<7aqpos`GhQIGYL;{CSO2k6=+~cotIPiOg>@Up9KVG@(I>6z<4H~&!?>k&gAo% z!vvnmCxjD5;~LYp`DgNxpuAJw)Dupe$u|~2s08c@vb5X7G_lCrYH3f0X)H&jKLpJ` zlTXT*wqXXYz$~c(p$;aJ#UeR|43a$+tCB;+bRoGx@H!9DO3MhDuxt zj%SNt(??#X5B)RwLOQ&m79J56^kx9=S`5Ll8HSt>cnsl58SrMnO9;=-Q1T4mO@tR@ zz+V7n1k*p0Pg=*@<0E|&@z3NFINcnuoV~|0`TQAn`{nS4I(>aLpzqJJizbdR?J zP>&c&wP*6_Qf~sBaVDQG^%=nanS8!><$Vd97d6i0>ovmmy*X@e7xqEW8{$m9+>Z@g zBFc^GPMlf|TMQ$>oXJ-NHvde%fW_+z+?>gmU5Yox(z;Yr?VSReIg>At!_{Hofgus) z-2vE~$rt9{Vd0S(+}{8;XYySt4qG?t-k%tFPV`=Zb^A33?4QXe?Wa3tfW>(xpWsi) zwKf&Fe24MT4|$CjRu~{CxwZ$zVv5VBG2Rth{5&m z-3<-~)Nm$WmVV{!wzR(4G_g>n5Bf|mb>&PxQBS9((xZX#Y1X`fWtqN&lgwT0^k{E@{y*z zYXF-w`MMv?O@sbmt$rrobKv#Q41sC)O#VpiBC+TLPb}~qIq2?Q=pWtV8Z_a(MzRXjm3r9bc_MBQ2YKxyHMK&kPEffci4s6F9va6vJ17?Xw5Sih+e404YC|a z=0fcuAejrb1}|qX)Q$(Tifb?bkiA=gn1$N$BT?&}Fxg#%luFLVr&*}Yhh=7=wiKvY zs4W3%7HT`Kn#oS48h5Mc+Kx}NP-C6ULM_1-Yk;C~$et7|vQm1gCunA&M!P69)eRPTH9z7HYhk z)UZ(d{xudfK}2MsM$`O-S{`nqZ@?5T)aIhExlpUXw_d2d&RV=dlYH%1sIeefsPRU1 zKA8X6LT$LHpW@ptr)oA(;whIgC-6%BJ%z6EA1OxSF)Fu4N>&Tnu| zo$a&CbLwoT$~krK?xgr#6|9Kx^-I>H9c=iG8Fx*9jEoC%HIag|fAGD!pc{$emps@WY`nUQ zr19#{gIRm^O<;@PLf-uNj|QC0GUB%jcql;a)n~(E4JNOdkR5c4nO<8G(8_3DCT zcy%8MGcFZNT&a-t>caSBplqe)A!0<0S0|&&UjlozS7%FVUhUQI1;u!E(Mh`T>c4Z5@gubu;2j90(Zs+sI$s&SWzu8Z+$ygKV-y!sAES+6byi>#EMs)yDz zUY&q@2Kz8|Fi_*w+435#u$_?P!@TJjz{w}-@0k}>m*6kC`<*Y*(0-5Uhm|~@vP_-} z>KcEAo^lE5J^iUiA$d8ampByv&!p>LpNOh1_5N+yWpqBK$ukXbg_4>D9S2g+-&^tT z^wd8XZ(Dg4e}B^!ta~+61Wc*?sCt9ae{IEIOV{sE5LJ)i@86VNa~-5dbX)ui9Zyov z-&^tT^wj^MYg8>c@UQIQkdSdvO^^R1+4RlB&~Xm+)M(E?)`J+>K5z+~eYC{j4b46l zalret59ah}_h%o%;E&8CU6KhCb1>B~`)G_SgR>8E%It&JjX(S7hI>GBn8Mk|2Q&$@ zkF)WuXCFtvIClk2N?PrheK0ArkLjeqN&U0g$GxI{if?-vEs_fOvyV#JirI&~w0&MP z`)CY%%;6nEn4E-y$3m7Mg75^v2&c}*m8WgT&PP$95|p>q(rypa#3Ju4OM5y@ zV>v3l@2{cYv6L@u!zNJaK9L|7189`GxIVhE0ngbn!y@EF3AGGM$B$Oex?rF%UA zo8WO6o(wo6cr3Ph7Xs!K$PXS1oZb%D4<7qnq|%>RoWWxscXih_jNq3iO`+>4L&TxL zfHH!|y42Z#GlIvuRGgq11dn~~%6kmB2_By|)%LxK3K!y*VuHtCShhs;T4AGB!&V74 z6FkNlYeDchVDWkaH^JlVQoMxR?Q45Ku?%lUvl+C~n=J!_$5NO`>r1~;u2KJI1~It)y=mYu!Q(9b*jQ?5ePdZP zu~4OPI-cy4lHjqFO{b;Ooq_woW2tC*EFeF4EUbYM=`|qw!DFAO(ysvbgU3E@hJW4K zP7pj6qEtMjb}~5p;IS{RysLm`1dmBm-phbZ@OZ%t29N#0T0MBYC+<^z@K{t|2@!Zd zEHh=*{Z4r|u-M?SaL`km;PLsEhTw5P)4^ljk22Pw>2LOqs`hp9LYKBVW@9EN(R!_; z#br`0YoGKeFs>o<8M7e=!}zzy3wDX5X z33@Y8m3#-24-^0T97z-ZYTN)f$|R(wZv|WYZt~{Ou;6T#5#J`@g8)tZ3zlgx`RCm1 z_?Kv~@h@iFCn#>?UxH-BzkDRjxKu20r9w9TC5$@)Wh*rg5hH5iUu0DIb2aO|H|7F$1UuM1|Bya#rQPwFV@M#zXn6f#=oRsk(JU@SAk~ZU(|Ru`!Mx6P!s=R%WJg4c0#h< zN%%n>M!P)KcyTYzK8|j_1O!r=FCl3i`$3cGOYt0As%7vA>6 zxB@vPu0VVIxI#nx(7PUbopFW9dxH~kg-yuoxWY{^&b@#pC9QVE6_}K`!a`7PfzUsT zD|`pF&c0K8+skN?RKSlb{7737SFlay^P0HANwCMn6&l74ZyY$RVQAV6hxI%F?Xcb? z$?TVvv~gIH4jdMK`G;nizYmy?j5Fgl3y_f-X-lNw$0FZh313H|ctnEV&KrmIIFiO; zwJo*|>j1FD4>UJ6h#&6Js6g3D%|pb98iz$jmH!y*)eeg-sd;t4{yR{N!xEjO8;8{xeP$h& zZ#$}o&<^W@eCx0l8RRJ- z+F>m<$X*53VO?a9K0q=Z)+sQc>x~HB7GIJKrGPpd1su<c*Mqutc4TAR? zTzS0!Nx|Es2q!*|oZe)>Qu0F?@P&XE(99=uS#iUi-frO+Gs^S+04@hKyq=+@DH^a3 zk7#%|3`?622Fbgq4Bm76Y@Rqq;A*8OL${#J^hIFS1AkQ1R8s@mEx3XFICJMr6wBAVhc;OT2gy znmzp>uz^?N1cxRW_(8QxO;tNMWONSd4?rr}RRihs0KAI7vR+p5fbneVoxu2uy0U?q zQA*QiaWqEd{L?p3tos+P{lQYcv<;g;rQ2F!9mENJta zjl3Kx(LLJ_@jhrd`b2&XmDms*CdAvf+z;`Fba>+|JR&UUoeJ25ctbVt)&d?wLndX| zcQ4>2glA_cc?<9+!V5Cs-vDQXc%^l`h80;MUV+n{0Q(_czl&6QxW#X zUg;ih4WNt=uP*g|z!@Q4UFuta{r$l~sow9vO^CPZ4BPi6cDn;NOB3SVr=?*_M3)I0 zwHmh1z-B_cEy0#*f(GI{y8{+)IB*l<%`U~8ZfRYrsrHtEW4+rJG>e7UV(+@M0vk=q#7#S39ujHmG;xu)X^4ah*$6jKnHc3sw3sFz~0a65}c#g*7lDeK&}Hh}S2o z^ryi65U-ExmPxy9Lm^%vO2tEJ$AZHT@%rM*I~RCHh?g`xLIZ3WN!0;n~9xZgul)sh~gs@xunoZdT%8U0zREs}ka{3(= z%ZDrpQy+oc7!S)@MC1^3A*oa?ly}Y`pt(+_fG#f80`wE>gTANp4i(BrNb3O5&+i3# z-J0oBL6@4=3(;wi%VU*P>U_}e#9xb~L%{u6T7nh$n&=m)NAUF}lLgMD=YT<)D)kGH zCTPqSMRM?sh-ulLEdfs_sYC=){g9r_d{eDJN~mC4&jyO9>yB=mLg}b${!(0=;UE28 z1V9Hdt|Z9>F(hq*7?KWx7{fVjvq21I+@k|zWL%K(L<&wk&<|n=dIC}W66`cTh%ppN z6U4X`%sT2i4Q%n*>!3{ut5xF+|wy;gBXHj z1TlOh%(zr6aiu~wh#`#217#~U4-q43f*52}`3J*Z9mHTuYF-`0m<5UnVu()CO%UU1 zkZcgcH%!SCT3i9^Yl0XLbip-;AjWd^wvM{iLAeZKl&E6+tYX*U7MyL^_SlHO+l`AJ_LzRS z#+<2a5o_G!Wokbf{Ou`Yc9Q)A8LW)1MVB&IQiY0zf+byPupca8PFw2-ON7B6Nl6xF zf+aMmhG0nyHDj=ZoDwWyz5QUxX}E^B!xRQfreRDmSkegJI#{wC#<>G%QqpQiu!Kno zmb64-1(^R?u%w5mpW@qIMvJ5Zez0U;+KOO_?HZrg+{2E5J$|s{f`f3Yv8PzjrmS6K zt7&(zYm8a(rip6BG zn_XiMhS+VRao5;Vu$WzAH$aOM7yG=87JfeJiKN)cJB;!k2F>gm3yZvG;hoh*{shhJ z8q?}n9rrMps$$>c)9xBeq4CVFu|T!v^Y#bL>>A6~;T-{**)>*8ZZ>FU*I3YITBnQ| zPDU_482}SG?_uM}yvL5=%w1y)FqqkpZARHOHv4ei4_|1W3wIj|DclV9P)LDUcPp{r z<`N1i2wA3ZXHgEcT5QV_-`SU?a`5Nt<)F{I%0X={Rzg3lZ#Fr*-anU~n_ehpz$T;+=6=Y+BQv<)1#ChJbW3K`d%G<>C(65`6W8t62rDu_q#*65JLUk3 zGo&E+VQ3kZ9tqqJDVPoeWI_tTCE_xvJK1~KGQ1hhX3$Fa925#ENMRzaFa2?r$dE!n z46c9gdT^MKLY98~^xV?=#Q71SSX|*>gkveY5?ws6r`f*DS-Ttg0Kcgq%Q~2 z4=MOWm3{)aA5!pfGyJ~?(f`S@5T)WFwLJ%iLJGdP@}>aK2q}=Jyo&*wkixC28B*{E zYxR)AHt_l(1yTJ9L{yT?1QSyD6f8ERARP46CZy03w>kThtRvFv@V4yN z@fU12B9GD?D$~?-V@z!i!(XtGDVqh)JR0@DD#ZK_@GRUK_&Y$3=fD0P;A=E_EALkN zcYx&1`W+xyRQ;PVI|%;{@NGeN0M)+(qz)&p(Vu~GGjZv_5Gs>F^E@PhkSMWA$GD6A9Zr-4h_v5FTJ|j%yAU2#bD;hth)-g5EUb{ojG2M z9c-Yl@oA3`DC917mkot5Qlli#^56AWd z(cWm5T@~DDI)mNZXvT-wZKLrdT5q7*H~P>m2I4!cYAm?^;=6P(A$`x@5DP1&qorv6HxTwSK$=2IbyJ_nRD!u0!W6pQYCkM>*X zPr~S-KsirLf7fIkdD)gKdG7Vt+%gO3%=$|$!%sbhK?+XZ1P0DV)3dzC!N56X+HpcE zyx6@4&T&G5UN^v9i@{wt16~Mt4B=!3d=Fr*(b7jad^MYC#|Er>@|>IXHJCom``xk~ z9cC*go7ee1qhfZ*JeMZ9qQ|?|GR&*SAR5xi`;CSR5JZx(CSBqk51i|_^!jW;%ug)kMcThGjex3x+g?unN;eV8}yr=)8oApE!)#!6=FC)RQdxjaH*Gm#n`3N#oP6& zF#Ulwl>pPrIV3hh#A_|pnWkIv?h`DTl}8XIzP3v{UX;1jbqHnwR+Hz*HNTfhIA@# z4q(2HB3+pQZv)KNQKSzD!E%KvFXtggUPqDc9j0judV?lc!C{e>*Z9`45||-u((j;1 z&-NBuwxN+>!X}1lwxhwu*G#16c-z4yV|+w4HcvflE{m#aC3&4KZDMt~6G4*;WO8-d zt)TG@6zSRK4HR;X;sj`{FA1LK(LSnharDEyFfHPE; zz9a+p-&rT`mj7@Jo|^ORFSX#fE9`60dcOz{ZG4J~oepPwJ3M)^Wuz$Q3M8ClaYWzU zRg&*EYYF$4uE>jdcf$GO4MVC8+TUq@KAa1_R0sL`e1G{`)tO)NhM~rAS@MRV&UEqE z5@OykMCV_^Hw^Uw&bxqp!_c1BBF#4pHSeM_-Y_H*)!r~P`BZFO#XSOV7@CZt;xp(X zW5*4*s*UITI$Os4~H>rY2=%!hNl~bVa|EJSo!Bbr!55o z-Y~?X+)Jq~IUS9mUrbQ`>KWL6xC|U)!W^kb&V)a}!#TWch)tq}StV6|Ii`B{WkaHq z46e{p%g%D_%Z6Bz7;i`;v8B?yY{(~tUN$6}sHDc14aw`%t`OTf9rpSMiAV0qb)n8T8kH{x9FV(_vd-d%OkDrVo8$(IckEjKJrIK02& zm|RN6>}xdnvY}7F!kaB#HWbq0ZCYXA7s8U>%=5G(!pnw23cW7pYhQww4Ta(8Nj0Xpo8pm-_`Gxf zWqKx6oi=QZ>7J76wA2;a)%!0S(w*@I;Eb0I37o!vt%3QnAsLJMWkYVawb_WU@GU5RSmY@%7(G-e1!)0q z?`s|VvLO~xGgtauaQQDAl6r_9F)IDybx!cIp-iF~i;o~?YF;*^O$oS|SKh5ykD8Ya zvHc@~s}?i0$M-g1srcF*sL?#>CBwyv8-|OZ%)D$!H=UFtFPYKpz5w$mVOU|>PZ${M zHjO|2Cd05YT!d7XmYQ-#-3+5K(Z$P#Lc@ilLwWsgF|>_g8rhWBW{aWSV1|nnuTA^S z(ryaNQKu`4)1Td{XSedQAquMW&9~_pio9${bkR~(K5whzzih~dO}M}6c0=11ZewL6j@-t{TGc}dk98vZ0-fg^#hyzmZpdmfPs$wT&dSc%% zRFpG$25xqlua@C@N?w=3cMQO>i~Md-;zgl|s~5h7M3FLuWw&Lxg+e(4qrM@NV7 zraSRNIFkH;9&_$Mf$UplgrS0Oa%RX@B|pGa>~rYCTV=MbLonwz_|1l~2VW1O^ADkf zjOhG~}hGST^0AZ4TTQn1KM>8UQy`_XvK}G(>%$(NZN9TpX@8Kl7+C=B;!#&jyouBkF3z{Gz5}l_#esum@Tw4x$ zozeNPo4+mv92FO2)&bJixQ+(UYXuDLvkIp|y zTM?bNP3H5O==>$H$3*8F#s+>IIIP)d+6;&FH303fej~{|PL#B9SdtDL)^66)IxJ?~ z$W1;nGA>9RA_X%(^c|L<38E@_F;-;8VO@=+aah~ItQ}SoZ1H^Z=I4H7z}YM#UL;_D zfckM_uRGxY1WZ1AcecY44c1{X<2I+bby$LAI4mCtGcFZNT&a+CSi)EtC|jv{h!|1h zu*j(Lm%(1`u-KBCS39i7K`{5?(rSgptr2US_P13G zYTTnm*KznX4vTd%4y!k$tizImMOI2rEd|XyP9)%d%Hf`R9H?|;0z3^}Y1sK|F%%xNvY!x9F+hm-7Tn%aqf3CDQUICVKFHV>m?-85c+2h>m}A0j}z_aEMr0{ z;5)3^XdOB%+hjhkaaf1I9^YZT_D$fh%FwhK4(mz)X8!|8cK-v@cK-v@fx|jmuGIPa z06a3zjJrHQMrvd=k%G#veTOA{|00TGr^C-!#Wwv+F@Mv;Tqi`o&;(C@98Z33>zQ#$l}i$vUh+qT&RM1esy6zQ$n<|B_>2X#Mly zWScy-q!`cLp4lD7Qby#;8WH1ozupTtXB|!8H>luT*1tim9<$s>- zu;u{C-2d=AkW7bF{DtqZw%?ChpU%d61u5)*z^8Fool&ZBSnmNf4y!j%f|(h^$RZuXFuwBxGa4%_Vi;NPz%V|HG5iaPLc{nVdKnGl0EF5w-i*S< z=dwr%D;1O9cYM_zBAj!)R3#&>F)y66G<5u}18_ zv51@r7*3}xQcM2v*sos3%Pekq%>a|}*9i;VBIitipk;5U(1d3KLd336f_)9SX99$9 zKQjo=1PJV_5XLhB0i7;QcqSkqb`d-iAc(HppaNaC;7kA!%FjKlCns=|>_GsW9F#xI z;x@TBDUpA*#qDr$%tz(C30!a{K=PNiVH2pF=uZa8GXX*2l;0O{b0*-8t?0~J1&LkP z1!n?YIASQ8Mh*%^{r^xQvzG^F0?z$a&qw1XSx1I{wFS3x8U3dKUfdWjsZNnIF-K-| zoP|2T3Oo_j5}WXuClwzYjo3X99GtvjI*z6JT-$I5-m!NLT)Tz|EO}?JrwRn9cqV zFAdHFR61(NYDRw&GD=5b0(mCF8-|+*D*!3{~B=SOhCw| z{38}z=&&fi#b3dh0GGPNg3FSq7XWO|1kh77eb9f@f@ehOH+mVm{XPabI1?c4rxjE8 zZv*F<0D0|=GG_w9Arfa)E7{*?3HC+H6KJ8Qsfda3&x?s+^U82WJ8Txat1y0vVhM5M;T!<(v_Xgx3rN?8=`Gc+!~w;*`Gu zU~?wmwb!^v5_HzoGXdX%HaHU?qQ3=;O7H_$+~<#4x5TT=o(T{NT57XMFwf#}%|M9L zX9DauM(`z}+E#%DubZ|FCYgKL*fV7>+uMkkgLU>3r`$CIU&E%hT?4aOHSOmLk?@cu z-}dEpFrLLO8t!0ZGX6Z@A2AX?gaOWf6`q+Eu{#)v^fG#p%|8=hvsM1L5FG0dq}{<- z@P_t$xmA8H$juJMmahj=BqKH+cQD=y60?JG5Ttk+Qa=B63w|fMKr)hYPDC-4{{wJl z2cyf9iHZyOKq|`_z?mJ4S{$nre*$Gvu~HP+?qDnfo!P+{iq>@g0^rOJ#_}@!2Y@p> z7*qJ(0?zDU4BJf06mQJzU>u2BQR~!#Xx(~;Njn%5LxDDZfs|}UIb_+oj&`VO;zP!9 zsD@B&p+m)FTvpw}&o;-Q610q0p$Q$T5HUWKU<>FvR6;n7nT8IPz~+Q7I#dCjE=}lA z1;j3b4wWDt-wA`M%N96PL@2*i#fZJPX+8i>4$ALuahp5`CnfSPwzwTGj`^sZM}Z3* zD#>5khE1SyKC(zUR6*gC@25wsLzTUQeO}6!xMF$WP#vyfD4Iq(3B?8qOq_6i;80De z8j%HlI8=@d|3(XL=Q8@w0BjtpYn>c7qYlQQ8c@wp^one7a(o^X#-Ta{iiaD+$0&+8 zGW6YYvme|(4h*X zEB_S0jYHMoEvtLuDJ{jv8V4@^uj?R7Rx{dN$SBp2-32n^P|X5a;82Am{zHHphpK!o z{@WJUF-5fhGjPVC3i*_uUDJRI9Tw$x2iP34bg9Q%a9I-da)6CPMYCjjy}!wVXGHnE z>1F8l+YfNyP)Yk~#Z;?h;B=@2{*sKf4uA&^l~&kjfQ&;G4v{#cTFL%XmSA7BJb@Nk zHSRc6l9_Ppp+C(c=}?8paQyq*Kw%D9mXojiI++HS7b}O85@M@32m*&n#M3aToaKNA z4wY0i=ShHqLzY4s79!^`kby%LAXQGQ+KxjNz)klb4rJg^2~sNVhQQX7ZrLyLn$ z72>o*#rILt3|-DH%4-`bGW_t|?7HmeG>5Sqm+2I`hbAEx_FX>M7g%QDO~DoU*6Mfq^8wt zOy>h*rffwf@n*_)BT#nAHYk|Ny%e6EbO_ehOxa%Q!_C5!Z7KXEJ!ShYdKaf`F9nfV z6kk;@V(v`;6+lke4$F#|JJX|kHDm)IddjxCfmF(dgIEnZySAQzlmU`FW%~#q$!kp6 z4I<^HY?lC%JZ1YWAZCqe+HTZ3jg5B|Vk$8gzw8t^vUVlPYNl*g0&1pgmji01Y)@%u z#9ZJdi;2G=vfjY2nX+Y_%#`gMaM>wa$yj(L_XazFGgGz%#DAeZXiyt%Y^H44@*0|J zm5>+**|(#&%NkPxP0gv)r$OjUr5>W7U@DamY^7K;5dVWnd#l~I{W{SJ|@!SwH@ zQrn35NkQ40v+PoVU@EmHT8C4qw#fooGnM)<$`eeb&ge^nwX@YD8_|N{RBBHaH}w3O zjQ5o)aH*Y}rn4Q-U(oUf5Sq~Q4-qAyguCz3t?hdLLRiKOLeF1d<3boc|A0=HCiMIR zVi!TrUl2?8Lj}5Qf#*+z^1p+@o{#q}rcx&X;N*ZaIxP%tlZ%rQ`AaNrhl^uAIL!iF z;Q34b(l%@YmD9DQLDKUN3Wp0Y0XI{riTCLJN%<1hu@%|e*t+|~!1F&{D7I2yV$+R* z=U@M{!1H%x_+u=%UBqGZ9|zcY{)?R)e?uLN=Rfp}!1I5=$?-2x7|*|Qhrsi9WccS; zaB0M0^zQ@Mc>Zodeg)Wg{w}yz$H4P1USn`~{qIHNb)A zAE-#>d|=`9`~!GgtFBEa$MYBU_=^Eb^89tK9{{|v33}E3h&}EFI8@cdu3WHqCmgp5)R*%u%)o`1ZHu6OQJsOtibcduKi8HE|><{j42=+zG6KJ8kEdi%eB{SjH zLw|G+!%fdWM26$v{{$4q^Die~`RDXBxV%_7oRm=IyaR&3^B3_nS}LbWFURwjisnoK zDDeD+G%Q5UyFdn>e}Kew(s_>OAHYrbUk+s8`3q7i?uf0^+wuGZcI96Lc#`K&obulU z*i5CyVNxQZ<$v(}kMHAn{v!HR+S&v+HyY3XN|0F3Unpp)jpzTD#liCraoY3e`$!x; zyNgVyk7l~7=y~jCsb(H>uj5tSRtd= z0GpUpp=O8SmS;)@ufuqom|8(~m~ImnRZzX=Se|JWBE1&a#AOxc&+N6_re;^zF}v3q zo0?N$UV5+fHZ`}xW04NeASLCy9C>ZCi7SxUYZLQP@~@HDM=dM>=6@D*C5jZwHv(1y zQ{5(3AyLmJZUR|To45su<89(rRO7RXN_|Yxw^#7Gp8*X2JwSX!1^xs0?&l!QEA!){ zboyeXZ^jcJtJ7-`-^%pGI{gOXKQTQ^r~gL$X=D(;N~fDb_6`(3evMA&A^ic<%XE4w z(l;~z>m@D!!k%49<>k)!0)@=Wz4)*Mmt=2bYSwWQTza|$bBZOne6$2tjFDjeI0+U^ zkYM3s5?r}mf<>Q6u=pnlmUuXmke7Q^rUX~FkYH(N39c=c;JWb=EL$zXif1HP`JMzf zeI>!oKTB{+HJoP1%e^&Ag4<4);P!zM+%Z{#HS;C7^9czKy(z&@e@pOl^(V;w%j%mL z9BC}6-_DTW_XQIC(NBUu$4YSYRt9alJSxG}HE}K?ugx{t5?p(t1lP5Aioj)kBv^i) z1S@7qaQzAiZg^0Fl`lzf<6a3?eI~(8RX3CU=3EJG=_|plGbOlfnFM#-Ey0=>CAjl_ z3GO;9!9C5MCi{I|C3s+@1P{%V;NhDj*swu@|Ll<9(a$8<_=g0K)p~~Pj~_3=6I~?O zbg=|aUM0a(YbDscMS`dIOYlsUXUX?$Qwg5$DZz{9O0eZp3AWxO!Ap-z@bWtnyz-d@ zuX@js{k4V?Y~yM3yf&|&Bf%RJCD=Ysf*q?Qc=Hhn-g-rXxA!CH-6q}pL&8d4{CTD; zdu=4F>#;n&+hlocoZf93dTf^7Z5n%Qklt;MGknbrUkl-@lr{ig&9RF3O>ft?VQqwO zj>PJ2zB-Mtc7+-FkRB%tcklo*gwXy1RoSDFxS4=r4am9&iCqK?Bu7RucvUSCG}zN5 zIyF?M;zL7%G6SmpIfkgF8fiddNR@d6a`{!zZt_H=T>+WL4K%1}4obLc6$91oQcbOD zk3fp=>UMJsKj~GUx95>f3_x)7mTnHt)2PZjj*Q)e@X?^(X?{Js_!5AD7^?7bH0S4GG%sk)XrJ5_J4d zf-{du&^ht~*}GJe;H(`FFx9P@q`IFdL67zl^y(o&UXcX7he*)pdXQ~!n@Vv0sS=FoEy36! z5{#Q9!T41YOn6L!iQ6T(;ByHk9hKn1+FL1X@|hA$87#rnizK*cnFP}wm0=Sy(adcCjq|Uxlg3_BL81jGwL!Xgg*t-&(`?&;VMHYD5-j~fg4MrD@L0xcBzd*51n-|B!NDE~ zdUsRa*%HRRaS}H7E|su@w?e`K?|unKcrQpe&D$yABJVQ^ulN3t@JX-MHp+X$YbN1- z?^Fp7d3h4XB7-HY7Mmzx_1MJ{){I>tVXfE=62@a|C9EBLQo=;+bqVXl_DNVT_PvDl zW9oJ0mldleVS`vR2^+>vmC%pnN!U0xSi&Z;DH1k~Etc@O*lG!z$NnQ>i`Z5PkB{w^ zuvP3!2~UXqCSmJXl{c7QZmfZXC&qYSqj$HHVqGOXIW|DTQ(~hfY!|y&!c$|{NqAc9 zJ_*l=JuhMV*ggq6#D0_T%vfSO<#meXO4vEpQ^KyXb0s`0HbcU0v1=vl5nC%^&)BmP z_KNM2uy^cR3H!wUlCW>A<_^luk2RC9Aa<&Rg|R#d`^N@LSRA`R!U3^)5|+fSmvB&Q zt%PUCo|3RMwq3%(vHcPbiTx5f)=0wTvC}175i64L z`q)?rSH|W^cw_8(30K9|N_cbZDG6_hZI|%Y*hdKSdiFgmLBHxdnaXb^K|xOm3eS_E zXpRK^S4vR)kOTv^N-*$!2}%x2FevR^N;$i(1n0DsptMMW!4oAIvOt2Nw@EPUNeRw< zOM&f>vdiM!?hOn@H`O;athZ;F$o({}gM+NbX3z7FYPSrsK`K zg}0!T;Nib3D{O^tGsJldXwf0kd>3hpc>kg!OdJ#u8 zl9W|vX4UT(l67WI{eB@yXJ*vz7v_U%O@Jsb|99^sdTymmw7vtsU*gICOV@+{V>u8W zr?fcbsMfs}Mbt7pB;;}3WI{p=;qq%D>Ki;HnDp@1PGU_k!R2>%6yDkw$|`wyNz8zLtKok+@?+;=u;89!=LktcoU zKThA-D1Ap2|3#vac-}$b*p-g}5R^%Gki&#`rnr7ODjnpobPyc4o}w31Y8GM`go`P| zKSz2yA``<6=rc zr%MwqrUb+;f{Q7Fc<%@%Ms(SN#S|ix-|T#|VDg~17yu^+<@d6++NG_%Xg~O#P>F$w%4z>5f;o+RW;fY%c|Ckb3-e7VIG zX&pZo;G})&0?sJ`I9N;xRHSk)v2ZS?1n{_4-CaNi+o(i6{+j?LEvD#Pe+GDE6O_>| zrs!PjO>h=d0_n={1h`pD8TCJ_d$USXV@j}?GR%_Ij9x8dlxoPDgUl?Z%m!JojVdJZ z9|YVirj*acf5YNBrik{x1I}!t3i*_uF)`Ri6_y4sY=F&Tic4K$!DUVc%AX0a*+$hJ zX2JA&{}v0L5v_YS!MgpP1vpqtk@nMy`O3n%jY{Bm%2=y)fwP#R6?Qs6W-%okB5_8w zlKsV&U|+O6ffl;g5*)Od3AY~l9VR)8DN+(ahU4E~3JSBBQck||_gGwBtQ<~Ch%5gt zbQV)YJdKvh$pbvtMkN)^nE+6*m?ETMA#&~nGFVIrkSb?4;K9E10B*W}#mUZMiXh9? zEoTHMf^Ad*yYiO0aIaUINc}xBQiiatq z$d%zYm>Fy~b{PFG0Gqd@TaeKJo42G3UJS5#OS(cH2H3nMUGPqTleQd4S^b{@PI^lU zI4AoO=PeniNab{~aK0r2cwDP)9FW0VQq<$G1Ssh(sdIe>;H0;t&h-GmoB8tm$(0Td zX;$!-yy_3Dd-M9+z9@K0HnU_kqyG^yN;PDkfXuulyMruvONJ!=RKU$!vV1Q73XAKQ zBHG^woOw%zd@$)2T|0VOXsOLx@)W%01c$d| zh|_OLzK`@_e5>6r< zYnFufh}l_^?TDA3C26?`i`ivS&XQ1s&MJA9#Aan?Nl2DDOTv6q@n%T-9FI&5kT7W$ z!A=bXWeuhV5{vOojYp;iQuyRr-=MOf2?c~x1C?)Q0k$lGExO7SfZH^VSpXuWv4R4u z22aJSO#xE)f}4eO4TeNQ0bv1n>ys+zvoxY!!~@kmE2`t9O|t6j={>7DQXETl9|3Mv z_dep~Rd?Jq5j6-8R7Vkd#wb~JHY=k#lBKGS`KV(5+K3vAM^s0`W42sS)}ZBX1kZl* zaaJdVFSz2wwp=J6Y&l*(1K04K)i4G{BWm_cM^f(BZx}%fjKU=Zfbf3(qLDoc)1s>A zDlg-*>ez767x?()j9ty2mH1JK>$>O-%tei*p#9DM= zEs?g)NLx*I4SLXk?hipv8qhEOV7iZ$apr%PY4@#Y%fn!Eg=YS4QLi{C5uSP0a>KRD zK`|4Rxf&>Lz%Tl6A}Z=-Y-DLN4+F|~ebHxn4Ov4wuF&pC(bp`SrCkUpy^*5tUFc3g z>G~D@IzLKUwk7`QXE%Mne$h-n>v}`rdG`v1u|@CK7fNgPRQ;uh1pv`RY-Ep!ce3trD|qHZ{A8y(_aowh+N=Yw8+Kj5-bHy2GR1!n-%OR(tL>r(Hq{q2Qp{*yDiymk)MT33d)>R;s=oN zV&-F{g9bvI~J%7;$7A_Ubxf1ZrO#uHQ2`=yPy9eSnRO?b4 zC{q*;%RHB}#SFMfh|z+OTH<-Uqr&IFHTS{C~a<$3sqx zBs$?W&>3d8=)_J(?~ADG*Wo|n4SonO5-)e$c)fTfZ^izDnUq<59Ua(z$dh~n)lK^a zJYK_WUyG&L;K^?>OzO%2N=QB_dqfry%fCv#mT;&dhC6>Zy6-mnH;$VCbp-%Gap zD~Tr<9ftVhm6lbaJMkeAn?+vH7mPn82!$_97Am(LJeP+nsgfhWjeHPgy)kS%{jU~) z=zItb-v7pz;C_i~(f>vkXkh*K1zZu^jLEkasuy;a z(4c)u`)5_b z>qulh3c$L5D}9|K-NZ$@7N82ILfS@3+@d8)t4shuT7}-B_62vdV0tY}M=7P>ZmD&R zSf%ITiWLuUxN>7e-Ce~~#aF3B$4sSeLArQRtx^oS;x%5zul3LlJtTF%PR0Lo2j0I& z2~X5+sQs+sF`D5qLsGFmup0Ed0o4paZyHeBnh+F9^WR0*+?5AkFac^;mS5>HgRA4> zM5y1%;&NOZr7M3iaCESWPxW@8mR?2{%i+HUFim@L7w?{`1WP>=_re5l0jc z7kH-&h0gIKP;hFj_$I&F6M7D;c!n#(Kg)vWx{Urzfa$;$FG(uM27vj_C|;2S{sQ1d z1mBt@#NVW+#)|Jr0uKUsWfM@Z_q2sCzd>}aXW#dTUuNkIRm}Nbikpy6zJ+aLs&dI=g3orYz*Fg>^O1V*LrR?@CA{u zQ^nbP;v&Pp69jZiiytjdfPcSjaZkE9%E4{-PaD2H5#6kksV?(Ei~GjqlT7)8+oM20 z$FsOHCYOYfgG=Sqen$JK#hC_<>%IV5n+MVc(ajmbU`cF5?`wG?z~}o5L9qo-@o~|8 zAw}CA0Qn!_hrVfXyQourUCQ{g2G>0rjwaLU{eZ)Ea#dUu4Lgm&T?yPAwpdxJ%vUUK zQmV{~&qdTFy}&m!m9Lk@U6IPS7&!XE#Vey@n$Z__TKYAMTNj-uxUlDhZci}t!$w;G zS0k_#n%{TEOsJjH``@5)^SjP`aUmzJ=rs%MWFy&VFSYI_eXV%@YS(BJHx_@_06 zq|vJ3j^mZ$$n(!nKXDi0{=|$>{vBr{ ztuaEI)x%=eh8W?=z6==lE`N)rCtl^Ul*xDE*G((g29u7n)emm5XRDhuz#JaVR$qyx zGH0v3t@dnn!%R7Now@fVd$#&`13CF+d$zi*fm{!WK3m<{Kn?+te73sxE0J<%tDgfT z`8v!~UM+vN`gTCf+3L4zVI1e6$nh@_Q;84o%V|QKtzM1_n6uS~05xZ;Zv)hvtv+bQ zT;L^(iD$&ePyaK+W0e zPRLzDa~Wk1%zOYUD0)4-1M?hTpN!IXV6r=!8jj;DUixE$^`IX>9&-ogzu-ZaZ3M0H zl=Lv@^LJRydh08rUhx)aK9!(!wj54LGb*Q~XCg8ZO#kkb^aBvfn|N(unlqB%PjE_l z{&tWQ4%a?q_9~=)!BaR&PJ7X-j&p`jepL2zhw&lulc0HSThNTe`J=LXc8jWIc)!Q`W6x*=qe=)l62 zGV@rH^>#!J$5S}e3t8Cl3Wt&f6KvggqSiPtzrHq-;lG4PYm9ae4$LzZuPh+@FCl~= z_jP=4aS~P~(r)q8osd}6{w|B#;o_K&%BjEGS$#2$f4c>@a~b`k0GsvP zH=G=Ip$@wnVPJge*L^Qo&pqhm_#P=c*TCwZNse%6v zz;s%%>&XR2KM2-yT_L9fyq?r^l4MT+xIWq=dtrpF?PW;o__qU`w4N*AoOb~Zc0C0u zQaKg&893K-19)7kt`m^KdakI)zXYJ9^<16nBLLHb4t721Tt5MLGr?TX4WuhS@nNu@ zJGh?Jy;-RJ<@#Vfx4R{)8NFP{DAkZvy&+i7y$EE%dTvPKZvfn^=a$dK|H$Gxrik`4 z_6O^^A)oTQT5zGmqWoz9oAq3m`d$kzOQPNjuvyQgH8#E8Pyfh(XGD3!hEZltdw_%W zTxmb8m}wTy^<07Xld-lQ@L)YxE9?`1%zAD(MBWNT**wh z_0X^NvEk+s@(>x0e}5_{%zAD)`O1I8;__nUa8g2*)8Z5DkYx{y8Syk)DrX4b!LBE% zXwEeN1?#y|lCTgtJAn+=a|0wk8$NZ`a|5{P{)2!F)^i0Z6?eow4~k&dQ^2nLzW`5K z&m~Uz9X|`!a|gksL}bYR!+P#4&<5+dBKi{A+61oxGV8gUL1Nc)g@TsatmoFoYtF9c zhB&>Rn|fDJ+t#q|ZQJ}8KmA|=OD260QS0y&_VMIC7J9#D-!T+(F^>!*R2+#$X`h3{ z%l|ywVy;@Je;H8|@Z^8($)zz#i*n+CnC;u6Pl~E-ct~j7kZ>=$_D5td`t*@ewFM6e zxlu4#A|XcNo1>$u(fOM2hkMEs5@HAsUlmoIuhxXzRFN!^5JOmRSyZjS!>s9&Boh*% z303i{sB+b>%wi;4Cy7+ACDxA+k-UsM4m?kjkBgBhe8F8fb}=#(5H3dYo+3;;cKQ~& z=rd7IJDT6-oYHJ?F)+LF^qK5&pM7vwd7RhO=^w&XgG)=JYHJae)+g)vNjp&+=RfMw zKYCiS#lonXjR%C>kRKc%k3Wl){vjOmg$I#uqwkRSrIL3z8>vqL$Xq5f=j^AQjbz%+ zMoQewMlzl}8`%$%=TZ8)e=A)RYUw6!W+N$G6|9G}zYof6BmrJ7uRoR9NG6@xNW#r* zq(t>>qzI{-b_7zq{Ilic#b=CX)q>0^c=CskM5M~ZGE?j-aSG8tA|tDJaa28zCw~Z= zTxRrzfhl3&qCROQPyiJcfb5WClXw!4Li=*Wjo+g2ynFVnHmKfsnZT=p060 z8CB2V$sZz0FTKSuFeODIBrZQ%`<)&{jSsQb6IdzTm`T-^FNFLFL1UUI8#8~RG(3)*20Ug{}Er>cw}<|1s~HM5Rq&T{s2#hL*S!5NZ~72 z(;<;iKxhwi?Jk3mgLwLU6sZS)Sqn?v)-hqUyCdhLP#Ac407jo%`Y6K71I<>BkL_8d z4*0|zg$G+XSOzUVc`Jt%ucz;SAzA8H4!M}Hqz67$FXjg;zBsKBG+&%dnlDa9Rmo$Z zJ49N1aa!8IPMR;ykm&|S@x>`dvSh^naI6Urzc}qnu(ST+6yXKW{enfMBdAvD;z`QV zi#1n7SaT(Db_ydP*<6i-E2bzUgl#6`LmpbA#}8c|h# zgTyUbVlK(WTv3i=t_U~gN}`m~Z#Ril$t@7@2%Z6J^=2yBxRle}Q~g>+7GkZeaPS%s z>-Zp^UmNg<7=+?y!1O7e?1$34aD~+VU(dpca20@>gO8KKQ`ZJ@Rg(5QW=8NZLv}Pb z!yQhBjGGMQKvuyjFRI?cGq6_Vb1W}-xl@+l?z^#Q|3;AjTKM)i5mJ1|{Z&!t%Kt0QDy$mq8@Ni zQe0I~0EtT|ysatkEU-*J4fZ@J`1%m7s=S7Te~3TPs498dn*k+w8U0X%I5~0P2fxpp z>Zy{x=R8vYl1$Hw)KFdt=rYo-kK&En>2$D;Abaj?@Oin<0e2G8o%=v;N$w)nr^;~v z_*d`;&!7>}k0hg|K}Io~(V+XVyYChd?ZGp!&;MNwjaCJpREnxzIL3!9WlxFi;p-sT z_OS6q?dHrRDUP+J>{Y<+ma;8~m)}x$9kO|tSyhWtgqO?TWIJTDGIodrsdk9@sN%jj zcQ}J*4|!0KgvYenL?m17`@!=O`DnFM_yYGxzea{cLII)GKEMLhP5ZqT=F9WD1fGM+ zO2knnJo(+}!RCHF&b)Q4hZ`qE{}80IDvpS%^YG+%r*E9QWq@I@zH^)q{X>w-dT&Bh z4V@U|Fk_Z^4F)+75|Unfeg1?@92ZHWgj^?wkO`#%T|dKKs>&N>1T7kQrW(-FAgUX-rj z0EC`c8-i;Y!4xl!03*@`?t_hS9RVV&BOq}RoGJW;#t{(VC5s{WF+BW|V)6JTr6;JF zvfopb(fLn&UlsN_xgv&f-L&cnbcE6qvvz~mL%g&t|I==K7O?sv*u(-v(}_7Lu)QbI z?)-H&<~1RqPrazBQQE&@E6`lg3P*rPsO(b^FC@>HjE5;{BQp#BgL3JB?14aX0i<+- zCU}+vSyKSzR9)$m$O*7CWL1eR_~k@h={Z?TEq;0v;oxwJHE9q`-`RC-Cs zpY@^z&JLNfJ^+wYbfuS140D>*T2IiG4$Z1j$KV$(4Re|cJg4VMhh_Bx{$cVj3Hh_m zx4>&crmV{Wv%|g@Ku*e)-tGW@0+3U3rFZQ?<#jt` zRj(VB3AxgH9bjt!IbT+~j>}$#vNwQSHZFZ=QjTfnIC)g!WBl@3w$eda!!6N<>q*46 zHbhh=PdJpGoi!6gocSt!tem8*Wft>HIrgmkf#E5J(pLf=mGzPZz8;XPtOEdY#;f#A zhw^s|-04u(MjzyCSLu5lpd+W_a0a7vVAhEi|KSkg!;Z6p^(Z-3$8LKBU8HSmv~-Qw zscoWi9qh8{Ff!p>{##YiX5m~ulkr`ICH|h7dV*QdGN&Un;aq-**dIzbFd_9iSRwq1 z8H98B0y`YSIF}#L>C%LA`2n$u;9R~SZf%Q!ugez9TFq zc@9oW9WIXfsGJqR1!uD)e`y;wfy#NqA~}~I6b_fbH_`?oyME-j6X~-^`4TVV z?QiDt>o+zOO(VU8;!g@pydKWwH*2De1WqtJGW-$?Zs#)kivTur`Kz29*Psq&F8}_f zhN4&GDJRE!L1E_dcQ(_;0%x-v8Gh_I11@zL{nG$8bNNmU{D}b5WMD4e1+NB}Mgu39 zo!tH10Gqjd7hI{iHXOlRzO;_t5#Xe`d;#ZN1aL5yAE-#>+-KpO%Majjt-1q126OqM z9zVN9GO?o1bKLZ|Cwa3+D2_wPZD;`9emi zb}oN*FqfazG8)e1ha`R};ASqrd@lYHi|d#o+TRS^oTjKuuV~1p{DT%;=&&fi@$uTS zWuKiyJ-~v?lBll)*v#c~zS8u1|49p;5uLl1VBLP-0vyccOZ#cXG;d|#oXZz@jcOcg z!vPQG^0mTl1jx+gheIUJs8+K7izV0>El;3@mYiTDa4ugm6K*~9w^`)hNyu>g`>k?N zGHhVUJ|$L8zVa7XTwZyclu+e-3i0(mKn>b-cFqc0EBz7)eC}^q8T>kqOhqGBBPS54@eMFZxm#;Q` zf_V+z3T>Z;eQdiQCa~mNyd;}rqMaTnsmssh%c_5IHRP z)8`fN)H?-y{PaoTlMF+T9G^RZfbi4jCJYi)a2P_)ZYv*+pUOugZ*WQeXym`d3WVX~ zk`%}KXsmEw_|Z59Jmo(cZ$vhaGplM*ituvzoBYvevoarzBuM>eWIn36ce|*XhDTbC zgvb17BqF)x?g7vH^9mb!6hjBvipq z#GW2iEf!bfm#`;aqn`jM9}C|h(k^%IJf&tfM-?}NuzCAy*nTgP=bCBU5Jw`d39%XR$6y8vHSP5zff)wD((;j1<8Te0z_O+3{VvmedB zu80MTYmutad|<_P3lL$^nqN>+McXa0sYw;nqi2$+d1=Lr>>3yiB+}D14TiPH>y@|> z6(54cjK;vL1}gx)Xc|rgjCPjYG5u?411qDMZU~tq zis@f5F(uu4KuLHw{cG)}nf?{wod)%cs)z6lJ}C3Ex%`!h07htwbY%pqE2E?Q`XBr~ zi3ah8rNO@+*B)iGPPQ?dy@QXb&>ad_qL1f@!^@>Q_9Ob24OavuIpQ zRFX`f1DQ5XnVEAlNT-Tt^o^>fvmj?eZQW~ln_6zNj0v?v873|=Ce{`i1wTWE>IcKS zFUrYNPaAKYP*u`^@$>O>AD$t-A{Tbxhig4;&i{Teq7;B)RG zu0vFipA)%Pkd4w#DMD6u#Z@2l@brr71;G59g;Z6r6O>2s9Am+Oi>^s$Jw*2)Btmp= z`~m*a10h41VAS~jB^MI$t-?y{NaSMJeE?!}~21s_1#Dd$L=5ukhE zv6js!Cbbu9A@5+f#GiPKp2O8Vy^8k#v!gT`998}Bq;!;jl>YzKQKmrJ^dVAdw!4?h zrTt@d6v9oVCF*vR;~`)S9@|k!aIB6J$jF}%$go5A4)A|X8MdRO2ubNEq_7=D;?nWT z58YNnF%^R+zoM}TsXdU3li@_ZrqhB=Tm+{Jzn;iX*LI;%+8Rjq`kWZihbr~2Hus+Z z(`y)7_7u73At-(MeKV?HG^lPSWhbF5-)DvZCCA=|Bcjc{Ce*{<#92fmK(8-%i|E67 zuYl_hN-z4i(lw!$ZsHQL^&HVD&ppxbDk3sxQEl zyFcot)hL5T^Ir)sNX>2y$TU3puZzT_FS$^y6e=6P;vz_u+zFN)WP4wi6vEi6hz?0w4`@bYfQT|4T`qkD?cUO_w&!bTJ1kBI(D0Kir z{c5`elAopYTK{r#~uMn<2ibnD$ zNK^z)l$FSWYUjb#!UN0j4?=S7jcxX&P8qs@%9FUr^Ms!-^$uKDEm#eqUsG@`BbegF zZZRV2;tg=2WzclC<|MLveI#y{_(XU~myuC53J)h(SiJHREaXtd-+>})6pFyLeP>jbWxK&7%p2JdKvy@y1 z@+a}Q%cSmxQ!bFI;==PWC5lJdkf5Z2X4_B}WRu$PDe(MGKDJ>BU%6%DA(2o(*oLy2 zJ7i5~4=)g<{)^Ih{cl`_nOlBLzsb)Y>E9+Qr`a`BKAYd-SMyNLQ)j-#J(VOYy#@ zxCL{~A;sw~#ePlkY!bylm*NvmaUh`RguEsj3LMf>nV*&Qmh4&VnFfLNK$ZEWQ~YyT z`~$4i_gY}C6)2b*jet3RcCAz7c8*(!|z$qVgJFRPU=uc?F9>+=7Xgk*`|hUv?7{qYRD#0 zRS+8o#{dr;680(G_r&Z3oiKT4fu_@D$Hc{+r8_$d(#^Jo8z6Wqo?u{7raLePqCxDy zWE_4k$SaR`24*r#y;#UnU*f8y3CM53!>bfnKWRw5WDh=odh4qc&RC1y&jDBNDuv1u z;E&7M$gr(vUMWGl=TDHRex;B| z6}$-k_LCsP?ixuEQf~OGaBc-Wq_$rr6d3FpDcJ_0zu<8#mNusoIZKQvo+h zt9K#Y$ezj9L&!eufxtY5r%xZzwiqh;il7j=9)gj0@Ppdz1$mXpV7XLxFlR?0$&$Fm zJQ_mjVK&a@GV$d7itQo!UP@ml?GSpaO4KRR*+A}xmo%99@Cq8w2v7x=O^K?#crblH zr0y2-4Z@_eUy(`k4I)vNvEOb+F>`$TR5oEF*ArLT6F&e<;YE<&OpLfRp}4DT4La3f z>q!hvcrnNyBTFY?2`i~bYZA9^LQSZf(8Q$)bv)T6{}z&up9bkg|5myt)Y45{r0cjU z7y)U^DDgTiF}04mlp3w&n7GK%aaFK(I`#z4z#HgrI-AuQ-N|!$8ZB}%e-hF{nbZ3z zopePXP{hvyS0x`K@fRL$?6iBaI&&xKfVJ%Xow<&nqh?#D?13t2cyUx+f~U{Lx)jwB zmmZctq)>LE7U_{FJ5hC96?C78U3Yjg-zi@Mn|HbCNlmA#vQt-O-X-9FH~mtSPFL$) zsg^2U21FL8J9lU5LM;X$Szf;vB5b)r-b!QR?D;k>Q?f5aWa_hc9c1NP8dWX7hi6Z= z)ag^8L>^_>IAyf_L8f(8@e|Le5Gs!>6aHfVqCi1BEmi=^G4lye6W)m~=|{IlZihVCI7{&tP64=GXMHM*u5( z8b2dSAo^9N-o?+Te)u`Sa_>(s8&BvA{G3}GKQ&PFKG%;(?-Et5kR0(a_}U>d_A^Af zAc8W8ujH2Qqjc?tjGDO|M39iVH@$2T;v-IgoaKxZAaXk*n)^1l2LE-rCzJbq!#%}t zmkB3$51;^Td+9dBnw84Tt~BBX5dF=f{t4w&DMI8GMCu??))YTu+Tf?3;W>vqUu2dQ z5<7%HV@NU$Kf?{l=^$zOyH|ESv8(y>Ab&RDXWUl&h|brblr0B&j?TfQ$8+F3$Uif& zc19Jyj!r#jHoC*u^ndEuK!rVUoQ_Lx8z%#{e-T}g%nJn3zesM7nwmbCT^lz3OUNEF zN31Y~xHg_?vGI(A(=J7NXv>St#ElguohoQQH>y_SffW{sG8~T~N29G3CaInq)^Jrk zX&%&mIcnbNm^EkqKnb7JwzIanvcl6%;JU77>ADu*0$FXYfV``ZDUZ9Yff9Kld#NLP zsoRpv1p&iwz;+K5)a(BhjKZv2Ab)+jHVo?>VGm1u`Wle>h>XhG5>+pd zJ})xj6#&~JJ>njabz!6#BK;5-ZXdbR%$ydhEEKPRH0lPIQc(07}RBvAgLQXCM-Ei~}HJ z$7l*N=@>hJm5y;PB0r079k4e`jFJ zkkBuqTcr>(D&J<~-&Rq-_pudGzxRs~(eHh}WNY-()y-kyZm;-{FIhE;K8C{P@61~( zYTv?ny9O`Sl26d)7cD?rKI*(v?U#Gto(C?id`q`{lx^C%#zL}@wsSV48zm}w+eqKK zv*>vv^BN?oeVhd9ybY!bqeNpT+!j^O;c3~%6OADhjV(sCC5JX1*+zbbv~-q}BrV4d zTb|@GBk{=*XHMr=%!A{{;+*1f1>pQvNI!Bn(rtxL8oCXdrRC|KG_)E;hj20>9XxI6 z1hOUt@-`t|T^fb$=pp2;!FXp7(!(p;iTH?Hk@bg+aJR-+h?M=rpTF=kwqoz7sx$;H zBOSis~ajfxh7Hmy^Xo^81miSyEmXYTv4RAEew&KJ|s_N8)Mg>|H%rS<_u-l{R zXFQqXCZ2=B&~eEeCyM2_l!@|FDs#L*+YqXwGGZpMxrej(R&F-?Q};97K|r|@9XgGaGkcaUkB*I*=^*U*I8jWcm^2X#Do*5qSI zu68A)ulu*sHKCSn;v!wgRl%u{)@czWZqX8RdB$31O;}22)`W1oa?2>C^xI7$)#)&V zw1JTP2~1=47X&gP$0X;`&170211q;yM*c*RQ7{4gPf&((3X&wG+*vmqVS)^)8F(bl zGGSeY0y&u`=iUmALTJ~;5M0X$COTR0@xznXXGoz1$A!nP&j{SC&xr6&4VR!doN-m~6v#g%i(Q#YW~mnoS?Wt%l^nVj zUGq9!xV!Iy9ch((6-wrM6tQmFt9M{d61)5O9~W5$y+0sPv@qD+7wdc;df#2xe%iPK z{;L%35WN%eLum=_VSBV6JoQy7L6@`}1je${*Wll-N4&I$0l8onK%5teoa$AI7JXZ> z2IBa~0T9>$^EK%wCvHJ>&S+fwHe*s+%Zh~!7lYwJz$#vZvQ+?0%ZmLQUI!pEs5n41 zybWkwhV(T)b64p{na)L(iOvw|v0U0lf6bSgwm zjiVvbGDoACB_=2=e7!en0EX!nMD5VA3%Jyb&;vy^zx^o9ojznPi!s-Y5;^d$h1ez6UR9*2^9 z#a`Ouh*!u$BF29)(t*$cUfLUk<{*)_8?o5O_*qI+iPtFYVnphCWnSZ6h_F>WsHt(W zO^oznjR)JrC@;P7D4Q7PRc(AB60Kp5yzy|%611gfpdo5^N@JPRR{>iwJ&o(`b<>_f zqDJM84RLX~)TnYN)$lRIS)KD|7mD(wWMZrV%mro606YPN;(QCU54&E^6; zS!=m(D*hc;rL%7Y;4K30k8@jz{HXfx1JW=K=tJy(_1hylhsj4Ic?+U@nS4}|-yzxz zIb}UA$+n12Wb#Q#UWVvnOg_zIuDws9ZrV2hdRbe8jW~%XQK}PbgYqSnNJE^bO0%v= z{1?UIY1ynri9*zayQ{Mvr6fO&P=*J=ttokB0;epXGV`s-BuVF5KE z!5~ABc@k2?2q~>O7Rt?d7Bul}L{);@dYFHm&Iz8>X8v`$W{$QD!_EpB@`ZuhczMjV zPL~9?>9A;Z&dS_?fLFBE8L4w%!Qy-P^D%x@?ft;>7S%czm|~Jl2vlZuREoz1>r5eo zE?xMq3slv#FL85qdV`lD?WW=l#R4~YHKHQbXCu|%U7Q)5k0w$lNOF%!#upRjUk8%c zN%l#k!Z^xaL2zs~6v>)4cst_%0`y7s5dR`_yhE}WBy5)k??n8LK+hn_H<8=GZ!+{R zx8Oq&*^VjYh;zs(|7qZUCd)5LEULZ%A5CRx4;&99Hi$&Svc~U}0$-2PJXsC6w<7)( zpm~mT6{2BjG@ZW<@Cs5<9rwTnN@J%fr?dxIu~2DD#y1e=_rYhIQQFhv znc-%FW6wBBy9XpjY5N_LR~@At0Etl=|L=j9AsPBv4Gj2Dgu7%l*eGofa7Jk^%W?}o zn#!^rIHR<%tnqD9;GK@rs^D5*qqI=8rt^CPXOyOk#QGZCV&II@Qutm0&L}N~FAc44 zl*UFiZJ0|vBqj7_0eXKc#VV9+*2=O9IKY|3lETbm*{k{O#)36*kf z3QMQtu5X^iL#@~3Cf9l}34&TP6)zKzt+fzjR%>l*J>&w`dJ+lGM>M=p8J6@SKuxWO zS%zUtLxxqtz}uEht*=1T)cRpC=vwO>q$p0U{{r6DT5u#YwJt`b+*-4AD!8AycAqU+ z$9_Gc>R`c|*ECPYRHyl1L03{4A}+jj8m+YHg5*|8;3!?#N=(JG1Y}!D2r^f}2P2qanky!f+xOOe?(y2GdHFQ83*~ItM9=(@Nc> z;QDA*jnoxq$p0UCj)Q$hTuqMYP}se zx7IA3%KfC7KAT#5@VybW6%YFcfnnd^zXMVkB97IF%l`v{&-MJ9$P7N$k43;|J-yxf zT-=cw&$%1YvyTF3d@gS0jLVMB`t5fl`CL~Z>G)i)BkA~DRgjD0bM->f@ww(B>G)js z-yzpc`&*a8x~GsZ>Y`&Sca%da4V|m4RJtCZ&+;^hCLB7yeJI(kK(2`G(pt# zhMi#0V?gI1MR9sVObV{YfZ#}GdP95Q+}^;_si3u>-Rf}djpb=c9}Jgiq}p1pA>Fu zFl(1+0F>44__9E|&)ySg_c7GNXm<;sfp%YhH(9&)uxf#JnTp>pAUoEDAoG)*R=XoF zqINfua1x>_!I?ax-6s(>+O3X!#3T;8A!JxB47`2RXqWeS8SQoegVwIjL5kvNcbpVl zYgce2GupiwI9IzYU3lFooU@Jx9OsM$F6W$$MH4yB8I$n~2=mYWFmTS!nZ}x5OmOVD z^FojMA&?m7>{5rM4M^B7^r*iCiE+*@2fvpg8TyU)2hLdq;gpQ=Za~IEfHTgS%d*mf zk492h-U7}zXJJ|6S4x39pfuK_uKH2noQ0w_ou3Dsan7`S*4N+`0%x4F6uuXMGtOBG z-(SEP=ZuYN+E8v_6X)#i675k#QMY~SD2g4WoT8SoGNBjEWPBxI{=HDK@uIyM%w#pe zu~CkqypID#HFHQVbQEbbR5x9_(eUp8|WyZTWH8n_qt*ppLz~6G_Kj zevhPMFWVv)$6iiH(y^CMAnDjkX07dIlb>0*t-%sp;-}Fnu$NsB=eWcSME=^qUS5TI z7<*X^XkagEexGbF4^T;gy<{r>xqz&_6oSlezO(l7`k8FVF>HW45XFCI1i7)7+-+&> z<;e%Fy?iNTcuN?jfXdiQZh$oQay%Hcz0^5KQ5<`DC-Bxc5**2lz1#LWf=;bdEbO(jdzj)KZnv-Gqx6V z#*BrcHJ$$haK?;rkz3c-;LbQ2n6VVTD}Xa*EQN17aK?oy0G-uM8(kX=@bWLbn0D=c{Ffs=v&wsW;!9Yy>_{9}lff^;%qlOekRMfl5TK4- zdmKr}u4QI=u3ejmq+{2fN7AutwNM7fuGuSt>ZWa$!fg$1#Yp^wQdvK+3*yGEdDZki zgz)mOLOqOKs{m+V*WRjvdO9Gb(Ue+Z6U*b!oXX%j9sgWsIhB@!JzG$&OwUe*tHH)aP0>Qj%3EJ zEe6iDYb>1#S_|5}0;id%-A0#DyLU9S+TAc4+O2^LSXA~t0F8EeZ%Kvpfj&|Eh!L@b;M>3<`QNX#{W$9GVTClq3WBXPx z1iA1{i!)q}XyFG~Z&u(*OFcymei1SC)9|x#oY1bp^jKxDpI%6>x zxj19-d?cN*cn6ZsSY+0EEXF#sa9eY^*vwh7#5kbrSbXA|U@V^XP%su1pk^%g0yG$l z_nr<>j-{>1N(5t(sdz#_b}R}(<`!H;r7i95E7+RHk?;VbD$xj0GZtGRYR2OCmSI?h z`2j;sMDcH{L1o6`8Hk#(n1zDrv8Z#9qBvu*w-j8DMZuBGjKxcUbH^e}r-Ih1J&iN1 z=jz!tHeu*NGKH&vKptl`;!U}W0AqK5PiO2BQ*P`YWCr1fACvLJg!%FA!Pxy>D*h+I zvA>sxW48b#X6!atz_!sOl~;sgcL_+$hhGI~&&!Yu{jC;!D8elx8f?byQQ*wjby-g9 zVZcXIS*8GI#%@^Fcok%*V*f*dt;h5*=#0k{iq>@gH^7;(tBb_S7+edqq8Ym>d?SG~ zV>g9w4RB`cvQbR~l%|Ws`WoDAz!{~b@Vy6| zQCbRL9kjkt8XMKLVJ`KMq%_#t4MTzF-1Y6WwGR!pwsziX*xI$MN%r>u8o%dpmW@BE z{t4J2>)6_hkaTSA(?~kD_D>`oTYEY(b!_c4BpqAJthKG(BZb=<>_kgU1IpUk7w-sc zZSOAwTU!NCV`~cl4Q%a@L8zx=Yv;2PfvsgKzF0uk)(S!9xh2-tc3sSdTtUKqh^hp4 zo*7%a3Q%Kfmsy5kQ$vQ?!f+d?jIGVQBe1nw!Juue&OwUe*xH|gw_odmBbl+aC!kWU zt!3%3wuge5^_$1&k2tk%@vvKKrs6pQvb7e1%rdIl_*&s)Vc$p zrq;79!?3X-!$rc-1yrWiJrFf-m^Z+nYprvTqBym#D+SkY7{QUu)Os9nZmn55m79+1 z=~?UAvmc455Ag6ioxt!7qo*fC9IIh2f59aBZd4Lu;M&JI2A1u#W1!(CjDcZ~KzjCH z0Gctt|9u*le}Gzl%)3cr-~%L`F;KWGX$(Arq%#JZAya1zEJe~81I${Ffr)qx(%<0L zMe#Rk0cFQP*%QGScn$wWjM~7L-TkPC83Q{24aUH&+md@jXI3p315Cxc3&{2cA;{eF zs_hLuu4Zp2AYl=rD#5*zW(-sV)bxf%uNj76GeU;Tg<$}wOmFxr>NNxL^8=~%eWk#w}%8ksuUosOiVU1qJd`-2p2YcBV+iFUUFWwl!a zakehzBmMsb+8vB~80|I#G|+Cf50ka~3@Z_6m#O%R0^S z#Ck-HcHc(SXt&lrtKESiLzyt_29?q7M~IrS-X9EFyE+Fcilg1@fVbKe9LbD!-vQ3m zE=#9^)`E8L`$22>$LFZs`3J3bzj^`MoxTCo+1mg#+U392ip&4ks$cp0B<&7D(iyvV zA?axMOC%lbwm_zicE=#;XqQ=Q?Y<+0+Zz1Wuf#N%V@Vf7_@eE4pJ0HyOX8h+L8;7WJbFW0Ox9#r3?SPVeR~{aSQP`+LH61 zk%g9A{_9wVh+{S4lE$~fIY%6~lijzR+j*E7gl;F3@gs!!vwjNP&gRS5QXX1g#m?Cl zx}D#F#JHWk9g>kCVLS3Wzr+6mx3dcPy$s3FUt+MQb`g^OwNw)bd$hgBuN;aXVA^9tY02ohf`3 z(E7&hWTTok%%vX0?QFHhe&_!P%BpF1R*8hOGR5F1r>(`TQK&5@(wRH_hjJA$ABo~6jYHJrr%tykV;P)~lL%)6{13nbFLO3O3t*zm}8Ev^N zYc2R_D$94k8Eu7Sjjxpgm!dRQTkR@GthPeYn$DjMocT!5MPhvo?iJvSwo>@2qlJyO zQuxjW&S;B`YT8i#XQ60||6h+^cB*ats{D6E3!31+k>Ndh_b$M)-p2NQJ^y{m9$4C6 zSe@*ajUv|4^8fY4<)8M|zZ6jCJ^CJ!j-@@Vam2N>*COdy+5<>BmiAG;h5Wz_;p%T)YB0a;5c z1ey2Mi5N>e;Rd$mmn58ls7ml(6BdBEHEsNhIuEbVsSTuaN+si3tm7H`XS#vmPKvgTJ19J_meI2PYNJ{XJh9g>GZV#i|VR>4?Y3Vts`GW6G5@S#X`;gpQ^Sj;*h z7>h2;5(_?>%5nraGZw?L#+OThpF(NuSR9)ZjKxs2rt|*`oEeL{NUX2H^==)E#T34$ zfHPw;g|8J_-;6~zs%b;{m&Gy`r|&gmv1-}}?HonXoi3-STUnXVXfhdJLzsVDn?O;O zRxy(Y2#)P_6csxuP*jdX@`MqckS6nDs)A{kXfueMgSYLx%2%IsRDSW>GXB3sfHx{jL z6vak0ZJ0|vBr7T}ciWqf_y)b%|*DJ(UbY(CRLT{+Xndmp6B2@&M@$TS4Kuu zQ(PV2U|#gW1!#iQxxm7i8vW{ioO7JR_~lW?Roj+h@DIwD^XG@@_&H|=Uo6!ZIr%i_ zsRlWV5tKt+&1s*d$*?r>Nm11p2~E`DEH^du0p$hO*$vwMH}4` z@ew(FLKCkg@A1iQ>0o)wi*(p<3C zZC_`+FRBajPWIHn{{q7@qUmE;h%AM>f_fe}{ zP3OZ;`YS;^iuVF$g`Y_0BbhoyQxIRIAm3sziQ>2h{DB`MRa)uaLLR5{;Vbhu8VM?c z#X$m~>rX;=7NSW)A5tFZdg{Ib%4K4Tj!5sxq#0QvvmH^3Yhfn@BWU)dt{sqDhxqT! zAyiHwJ&K5ixnj*k=Yu)sToRo0`a&YnNwStAW2W<&4s$z2PHlZJk?16OpCV_z&N9q( z4A&{@h;muD{&yDG^VIzw3-P+4Fwt=d)=#9*s16+y^Lpxd`P8f_2)bM$#DqC?5_)AC zccclCzT_q(Jt+!`9tH~I`1#3aJDEY<`+ zZOuwV)a42xNge9SS4EdbqekNHtbUC7?jlpC2AJJwi7@N*W;NlqKN%wP9VQP_B+^F{ zN#+&EXHKOkXdY3!%FwY5xzYw{5{oyx!oU7JO-3ZaWH*uMr0LwBueZP1Nw`7Z{DLM# zxgs*r&rv7F)$WB@`WD!gS^?b@q8K94iAba;Q8%B)b7(@*Y)+ksBupZ`D|J(E1&T&u zQZzHD6On{Tq>rNRpISgn%qbL)fRKK^roW~o{^HjcQ~O127%?%$d?R&Vu_7nvjH3A} zbs~~5iS%)d!lxtz{Q%Jbw;+#Ww^o zwk?wAm6$0UJ&mUz{#$iD>0$V;4y~U^Co*N!aQv7|^h;ggryWg*^to_mrcxxz74d8O zZjHnoOhUwwM52pt2O^)MpgBbPUC_}aS4>t=*N-|8H&dM20V3n8OSS{l?dXJp_%#Ln zLyAPXpCU0uCkwZ%=x4!>=M&xf(KJ zQqW^Yq8giMLZlO!!tzVvej<}dza;~Ck5MP6kpYoN|DZq6uOvDTKp9L-(Glsp!0P33 zEcX+cRfwLVoe%axvBmj3f9v}6PcuS?s+#&>Uj2| z=MjlclGzl?j0V9i*X9z6+*GZvCK8<_FHqb%1_Vnt|1y!hK^;*ptEC^Kn2-s?9m{&# zaWMIjIwGCBb*t)ie#S{v*$&kc@we9+Jf7ZBt9~=EJgRTsFoO zQJPf*LVuY#h|GgTqhXRO1V0b1e@Y!u?vNoc5uN1aiJH#DyiAkph60twIikM@QAHxM zxnd&5+&gOCN`hy5dJ`hiNz$GoPX=}7HE&_CAE1sXmrnJBF-W+{Qm;Az>}aw?I+0}4 zxqs7~M?z5ac!)&$n$bY(NYG0z6H|2JlwV8MUnfgsen2#uc0!{Mpv>#W-p>zkHAid zGLyg#p-#{_I;E&jq>iG0;bfRhLSiy`q-{0p9a#Thw5hZmFsuErzXzD8mmbx$Nwp!5 z@#od}5*HKjW$f><6+Lqz1o`CQFQxdAyv%Ko5AzKzzm^&WIlKHxpY{pl+K>2;{){(} z-4FQ`J@S2IS_wAy)oBN=&W z@*N?;#z=?SY`o3>h#IvfJ7l%ZU~+2NZy}S9j;B}!oq=4A@>EN%fP&*FPZK$74L02$ z`WFSx@EeW5ZGjxDk5ij>ZLdl2S}RQ%JwZMQeZ~w}gpp4eI%g@sVgUXN(sjA& zR_I$oQG1==xZ#wih^jVO7bJ_w0O=MHMm}M*0w+aG0kDf0Qe->8BCBOzciN}PXD63Q zNL{ik$O->mxpJj+O}6_fX?JiEA2_hHN3(KI`;B*42J{oPMM#ac5LW|e5~P?bFk0z1 zeudTz(iYo80z9wMskOAvT9Z@dpqRV*&PdIeG zD@`9lmMHgAB&O(|UIv2Ol=NR_z`HZX1BJ&Ku|e;Rh8;~o=zN>hk6$zCC>0A!r0dlgRwH8Hg{K9J~X`^Gv>Lj-)ct zv&=!!6y42Rfv7VNkf4|=I!TUG*N}OmTOhfE$xqZ#G)1SOpxoP7TGS>GKZyyGSc(ho zgk3eFok030>ydmt6Qwnzjz}jm-By}xs-E@&vh|<|k$!7Sh?x|Laz*U;42Tu*XXcR* zaXOLcCW18|r%0r~NO3hq^I0I;<%-=7>fWSI#5XAZ_8fAEgJTqLejXyb(fo$ud7@v5 z)GDCAh{_T9ah1|fyIe7rj;GFyC-KH=5KPS5C@xzAr@VZqx7h~7?M3>zSunnrERjy6 z(}B*NOXfflf@<%8NTk2UFg-$oUUHe3q7$c^8M?(}iOf|*3uq?BUvP3$!DCiVTLD?jTOd|dJeQ-6NIzhj^3Xw>!1%KvaByo-C2Mo9I04gy0=@^8@Po6MaIooai(W*<3MUqVs;e`40(RL)S|^4q--%T>Wj7D>~jeHV2W|Nc1q#uSB^- zWOK!YiO&1d=6n*o`m8S_5}hO)C{CLXf_cq_jQC#ah;r#v7cV`I0P&8lUKKYz%~LcX z(upLm&YQ*NB@%*K9*0PzfAS$vCEU&N(@QQBQ*`3=HL!XkvP5P}qGxC)1aHilsno3_ z>Pz$kQ5F%|Trpvy^R}Nkfdp@`>NAK$C&?2OD?R~&cb&{N6nS4s-%KPrNnWA23wP&q zmSKLziTELPM7b>7|1Hi?{JM@Gr@w(1kK0J~22F~)44g|mY_ig0>J6^GyPHqm@K^6a zt@_<~e;zL=*BctGJ*xJBsps?Mt2=rV_=jq^$InE|R|m)l!T>NnCy zlsIy;qfWe2Rxif?Em|nmwCXxt9ix49pC#6~Na>V{Wp-q`OtG<#r$Mo2aB&!_8T8|q z>*=wK22^vYy3T)&uBmeLQPdv}RRyNkP}R>079C3Cpsz@MwqGhdV;l5~nNZYbsJX!U zd?e8~z)X*tp_nya)nKM{%UMLG8n=+U=#z$65e$WKx;n&mCE1OhsbcVOU%fFB%Y4;< zIlr`O?M6|n(TwVGDz-k`T%cM}T+Qn%R#h8qm#X@3)>EK5kbFr(A?+Y(1-L+UA-9`X z`$8ElE??bG?p7nWDkdw)9c#tGeiio&x#v3JvR;Toh__I^`Tl3a)Ny-oU-)w{ z4Ti+M3HT{tI+`2Zpu4;cl(VHl53M?1^ZhLh8VrbfNRMjJv-*3mWY0F}tyMn)tiJ@@ zAJ(DQaz<%!wD=Zm<*E6qCVfv;6=CRf-_KP2;1ktd(Bs9PNaMOA>6zx!8n>;gcg5e2 z8=kNJ2TWO+h8MKzmw?$%4gZO*9*uXW3BDXty|RPLj*x1f`M_ zyE%eSHBap42!7QzG3W@o>XbOz5lX4l#A%LDTJ=tx58==bRHcl{NL&lyQwrCpoWzX~ zq{8LZ@WkzoP*IIa+ymiDn#HPdiH9NlNTG_FoOlMpZxpJk{KQKTE>gH&O-aNtREydP zp_-bR_$rtf3bj;G;tdE8XI;YvYEfdMBP6R8iFF*Ip<18Vz!4g$Es3{7;EZV4SnWt` z1wks>RP9S_58+0-Zl+$t`!7*^sii1QXP3x3Mc;zdXioGA{3-2=Zrv0HD%9neS7nfU zj1D&qmr8~hz(#XJCY3PZ`a{>Cl%LB~tgJ&UKehvMVs>&MU{2EHf;BWa9b;vDI|_LsPAs+X)4P>G79*D#3LmTzi?3g=oyqV)mYk|6;-~P zOrcQ8>gX=Iv1*r8zBK;mTQO0v?$d6VWf#8KTE_XRkQRfjBT_r&*E=HhTiF+qT;$0< z44kzv+hvVpS=PdyMdOQCN9$?o{|)I;t?#JnZ?#*hB@JOH8I|A2PP14EuR}abqOxD6 zYG}UZtF6>$MT9Z7!fv!C?gpgqgKv^NOL30A44kh{Fvs&H=Ezsyk{nS|?JS@9>MSkx zMAXnB{~|fmLrO*Rm9IPWJFnK4rQWoHEC&l2Y7*Z9bsfp2p+U+}U?IJp>Qypgc_4{p z0(An_`>s;gq583_oM1?54gQhPhn(cAW>i1mIjXyz6Fcx_6f;BR;Ez5GiQhz0sx30) ztM<%xlhq8nI{3th)?j&fxzSVTi&<8*AC{k~2vj zm5)AHhkW{VR)Ip2pU78`Bgq1_kmPF;X_*k>l_IM06uDW}6y>moY7JF)TPnBjtnlTl zjU?}ltfK8~JIQVqDG`?JHu(z4?jBNxqD^k&xb71gznrRHQkU=56{v%BaysN&PGoQr zO?6qzw_9b5*^j9I`6}}hR9B8P&sSel-`1n|R`CqUca)r9c>CoK>Q7r|Hm=_3mw!n9 zsN_T@g4Dk|jRo<6y%_04Cedv5+5J8(S7f2bkWTnU)5_e~)2Gc*w>Pf~0Y6c2;Of#; zY329F@%`j?f-HYP-lIO^0l?S9pck~a^p%5DCSiYpBM1iwoJ5!|wsQ&FiL<4IcZsuS z3EPY9PQtqdzDYPe>iT^+i~=^lMv1xsaH9ipJlMCOMMF6|YERf$UIyKju$f$U?MWCE z?Lfl80*4b05jc_XL9v}f*j4;4A-qrgK10||Yatb2n)=j?@oH|TW~^7!nwoK5O-E{Sy_ytiCU`XuP&3)92~blI(#T0^ zDyCfHHnbw7(6QDYIKrloZP zW2>f9)!L&fP;;p|=gqf(npkVP+xeDIRo%)r9fiiuVaYQT=^1K1QvEyBB44ef;X~H1 zQaQ|tV`c%lo@9(aUR%njV;+#)@dfH+AoT_)M`hHhpeR=sHUp-E{N}-aqx#~1jZR)b{e6@=7 zL@Vf=Sz3*ssOjc+E)3kxCJnKg1r$F=$U5b*Y{n2#qBBDAkb`LoEv- zomSIn~2;29Rx% zq{$(5zPg)v9*L-%bK00r5~nQaH)*YPn(frS8`DcH&N5ZtC>hm zC$A=znk=uTIW;eOHLa-G>D9ES=4DsoRG|~q!H}AFgi()fR1XQM8DXeCgQ?KvT8H-9V<)RX$c z$=|LMXuhN2-)??r&WOg%3e9iST=M2RFB)&Ie?;TW_ z<&33=L>=L!K#dl4gp+)gNA)e%;ftpn5Xr2;{ zTP7T>qvjs#XQW-+CXdQ4?nRGEipy88P}Mao<3W$g&iH{xW!Lj#s-}AD`Gsh__54OO zp?YHaP*d#9^_ytCxh{ytn`;6!GrYN`h{l_1mS{q`aOO@;N9&S@9h1!-mEE+LJSu5g zzS>Jwm#~a)cvN=ALmri6EKrxJ`bz5QoMCcF`AX_(Yf6bm>M0uB!=k29XxySZD_g2i z`|?$SrSdlLHmYt6Wpt)uQ%mpWc4lE)OYgdHCSVupt9krLb8zxz=|g^O{Xk29m7j;G zPxSb)qdv~khx`zsl~XMJRet7C-zLIOtQ?y0v%(_7ojK%_78&l*A)jIIR1LXB4YpV+ z*BMkhES2j5s(n=59+vSfRhcY@hGB;X!H@BmI(bBsv9Q|JEZ}#|+ z^AX$^w)7!Cw*GxfAM#`Ck5TUr`9a%GSSr^ARNq)CH#bx@uo3XC7GW8Grd12;DkO8m z>JLj5%2=Sj!4<5#`|}2jbpx6eajvDVCD%?g?hR*$+eGeG$tS;w-5;7*{az$jU$~HC z`HfYe_L6HI;=JWuLiO&RCcmKEpI>n2!_L;b=ZGOEq;sZQhU&+zQdgwfx)c<0lCP># zeZ6%#H{=DgmionVdEdFHcMDasL#C)gGF3CfYvx3vIl02{dN^ELa+6ESm#;dJs}?H8 zYFEBWp}x0OqfiS9R4?kEkjoCP+9@ZU-1kzBG>)}Fe-EO%ndQpc=wa0RJ$l=IH1*v* zdS=q%Y8=ITU_jk-r(6ik18h_j*BsiJ)LI|wn@;V5xvG$=Jyk&BhaB+%S#Ik=5z7SX zO`-uvb z0qgNVY6Eog&dBabPN9dON|^_P+Re&yV`p0GV-)Tv&z+iZLl4C&ehQwkJPA{)rk8=* z@SCSqGWqOmk1Cn+5jNTDTCAqeK~d$8ImWEF7{{;UlTBJ~eXJDo72fqy7v-sTFtolA zM7>=A8*uz^>(uj=%)wN2exxTbNLFIkmuxyD^~Gsj)FGq3+onNuY548`0jEIMw6 zVs;4|u-&}f?2IMHo#ur);|1xALUkB#4XsV1y(Jh;r;$`Me)?26$6z`S`};Zces%37 zW*iRj`ZShQrHjBqVN@gK%_ruL{ZjN=k^E7-EduAMZW!HVDTG$xWYEH~JZ_{YGF z723ZQW{)<<55&tM9s_gQWmqTeaaF6JN*j<1IlHt^oC3~wCFfOo9VBO=ymydsFLa#4IX445K!E4QwM>GI z01pFX`H&=_7|dEj!HkQ8aRQ1e0O=p0>{JNx>kV#y;4))84)7zv2!KBU@I*xl23$)! z5?n~`U8Ic5@HPZ`qXWts0}#9}!YZyn8K1za9<73~Y7UU`Aqw{Tiu>2t4kONTV-}1q z0XY9MP9jIDU2r_KzJ37?{wI|B3x5JS21Rg-$EFf&;;&T!&L|kYMWdrgG72M&W(GJl zVY8Yv!{n4xjy|>r7%9+mmxd?{aU{0V-Kq3q>5U*`{0viJo2S*Wz;_%p<7k~0m>y&GERU&c|C zG|m$jUm(DF8r&73k6)nzoZ1=lt|9_lB8)chyov_dkp`OrTx*PhFn9!j|1y37m}(cx z9`^-|-@tPf2(n6E4$Fk`9!R%dUJ~^(o&o9BZKmxt2HxUV7?pL*Iu?HifLp&JZ{KY) zCV`VW_6Kn4s7Y-0{fF3i^>ar(B86yLPb&R&0)!^2El=F*Z+u zbYtTs8Ji$TH#UcCubhX7O#^Ten;*ROJLze0{3fFUcJ4`R%E8)=4UP^c7hq+6=?iDs z-VdZ%525f;mSR;n6-SxlF8>Qq3XfFyf~veiTAp}Wq=xUemglKhK~&l`Un*@C#&up} z6wC8EImOzE6}@(+@_aBR}^u z9*DVID-QX4TJki=JfPL?D{|_%X5jh>4nB%0yxOiCd!cq(`Cz>WUFVN|fmG-)51&Kx zuveT#8-r0S1EU4+Sgf>nZ6{oHP|-kt=mI%Nv_T1IbM|eh#MzaoM0$B1O9!0=lf53w zSJ~2x@`JxZ%ie?B=_$yWmV6HKeU!6B4!(=x@(x&$($9U^8)XR+ZGNZiAI4`r_%S?9bUY`SKD&GAQReK=zHgh0!Ew3$B0|(*pI{Y8~ zgWM}rDXT2uaYP=E6u`Dv-3zGJKw+Kf?gr|$0cK^U4@DrX@50YhF^#O?WI?6UzFh0m zvX;PdGQ#3(sdAn{%Qr*L7=t9qwoQO-nd!!Ka5JICzr|`ZJfC1CO3S@xyGEt`QlnzU z<6^a9r7* zP5(god?iZRc+BIbzHFbiA49!tHC0tL{d|Pa`mA_$m8_b66_T2(rYAyDTh;VbNb01T zehW!_-lS4h)1M*j&c+kpi7H1m{T&ixS+<56uA2T8l18cPSf{eRRfVN7ZDS!azBtG zX;9=TRjV`+ss&UpVcB-xAj4ScNvOAxdh#mj6{tTVwc;x3OQ_G2TE$3sDx+1>Mq(Q@ z{x7>BluN5r4Vp&OKIhf8fTkO@8@<||&;-!W;2}c{U~>p6<^O|d6w&R!0Zk+#n=2+v zbn46-G1bgvWQlTVtWU*E@v|!Wb`lg#iuk4fH3ITBl-45g5s+mxPaU#n;VAZN+B?7C zjHFaqd_9h!CBP{H6X0inoOb{&0%Yuki*k)a>$<;(u^t@Dz@bmAM*IBzRFT>ZQ2IL- z{HBfCbVtPfJvhMI9Bb~!qfFOl_YweuL_?UeB#FY^?zrTPmGBIm`@!xO}D4D1~Q41onxnf7rJU#=-{UnHTX;-XX#ww?B zptLVm0LckSd_}qVVZE!VSdBZ4PAqiI*okeOwLH6vp zfDQzet6~@sOb6&quoqw;!CwGF0W!uSNor{op1{KA2N)D1{(4QD1Au?UYH4pYe$&rR ztX>C7X^n=(FY?LdRh@5GDpp%~6#2+ClcUJJFe|%6&JT;#sIOsgKFk2wy5bQyRSrjf zYj%qFZuH(!&*IZ@#i}&>s=jL>edR5`Sna^Fu2RD-Y#)a}!N=CWVPU!!6M!_G2TuH| zCpFilRs)4Mj|bUeRgCw(sBPh9b{Wrr(t7qlr5E9Ue|Pmio__QSovLW9pF^e#%s7ne zmGUf*Z7Sze&C}Fg)(R@;7dKM-u)xp~+v^3+KiNgD^-PAv1GJi|+IVJHXi9k|TCdPd z)E?Yo4~CYq5|*0p*V6I7f8o$J7!mj2UX*_!57|RULlnmgIf#dDfGExviTD*nS>_k< zkUq4^4Y=aS*}Pc9`yk4h*kT^zhfaa`I@u*6?u7WEh+I*J{t8iAwv?l20N)lYv0KhH zV!%dR*O4XTNfGa;hO=Nc`zeMjeHF&q3P$B=V-gq+VdG&q*a48mL*Ge|@k@M099TK_ z1r<6ttCck&_{%*0NuRM2EC;CZIzSwNrlr3P7cnsKKWWTD9XRX*Um{88aX%GA*`-Dn z2sz%j1F(+wa(4TV9b@|UFE?&MjpXb$<0m+%>M7j+l<_;Va>{5KHBoSmO*UuFmB#m| z59ft3A1;~$1i217MqE+YxNEB03v%#om@M=7XXEOF<;*eC0Qv&hMXm4_waOR;R*Ks0 zEy^)+idq;})X|8db~#0z2o=RH`q*34YD2rp?y8UNt_rfN93!Wwny?CWS-IBXUDgq- zblG44tIIO-(YP4fP6D{bm;;tG-?)UL76Jr=9wVoy&9LIqp#`5o+99H-55aO-F#ZI1 zg=U%*)yZ4bTBB-$T~u}Ss9Tg{

!$tU^WQMHH0|R*HHQz%Givt7h7E9W)G!^+x$b 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 E55Zm)EdT%j literal 0 HcmV?d00001 diff --git a/miniVite/run b/miniVite/run new file mode 100644 index 0000000..7d738a1 --- /dev/null +++ b/miniVite/run @@ -0,0 +1,15 @@ +LIBOMPTARGET_DEBUG=1 LLD_GPU_MODE=SDEV bsub -nnodes 1 -P GEN010SOLLVE -J km -W 120 -q batch -o log jsrun -n 1 -g 6 nvprof ./miniVite -n 50000000 +LLD_GPU_MODE=UM mpirun -n 1 nvprof ./miniVite -n 50000000 + +grep Time: summit/alloc_032819_large.log | awk '{print $2}' | v2m 11 3 2 +grep "Host To Device" summit/alloc_032819_sm.log | awk '{print $6}' | awk -F "m" '{print $1}' | v2m 4 2 3 +grep "Device To Host" summit/alloc_032819_sm.log | awk '{print $6}' | awk -F "m" '{print $1}' | v2m 5 +grep "Gpu page fault groups" summit/alloc_032819_sm.log | awk '{print $6}' | awk -F "m|s" '{print $1}' +grep "cuMemPrefetchAsync" summit/alloc_032819_sm.log | awk '{print $2}' | awk -F "m|s" '{print $1}' +grep "cuMemPrefetchAsync" summit/alloc_032819_sm.log | awk '{print $4}' | awk -F "m|s" '{print $1}' +grep "cuMemcpyHtoD" summit/alloc_032819_sm.log | awk '{print $4}' | awk -F "m|s" '{print $1}' | v2m 4 4 3 + +grep "Host To Device" summit/alloc_032819_large.log | awk '{print $6}' | awk -F "m" '{print $1}' | v2m 11 2 3 +grep "Device To Host" summit/alloc_032819_large.log | awk '{print $6}' | awk -F "m" '{print $1}' | v2m 11 2 3 +grep "Gpu page fault groups" summit/alloc_032819_large.log | awk '{print $6}' | awk -F "m|s" '{print $1}'| v2m 11 3 3 +grep "Host To Device" summit/alloc_032819_large.log | awk '{print $5}' | awk -F "G" '{print $1}' | v2m 11 2 3 diff --git a/miniVite/run.sh b/miniVite/run.sh new file mode 100644 index 0000000..e4b907a --- /dev/null +++ b/miniVite/run.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +log0="summit/alloc_051919_lru_sm.log" +log1="summit/alloc_051919_lru_la.log" + +cd /ccs/home/lld/apps/miniVite + +for(( j=0; j<3; j++ )) +do + bsub -o $log0 submit_sm.lsf + sleep 1 + job_num=`bjob | grep lld | grep mnV | wc -l` + while [ $job_num -ne 0 ] + do + sleep 20 + job_num=`bjob | grep lld | grep mnV | wc -l` + done + for(( i=50000000; i<=150000000; i+=10000000 )) + do + sed "s/input/$i/" < submit_one.lsf > temp.lsf + bsub -o $log1 temp.lsf + sleep 1 + job_num=`bjob | grep lld | grep mnV | wc -l` + while [ $job_num -ne 0 ] + do + sleep 20 + job_num=`bjob | grep lld | grep mnV | wc -l` + done + done +done + +cd - diff --git a/miniVite/run2.sh b/miniVite/run2.sh new file mode 100644 index 0000000..4bb64d5 --- /dev/null +++ b/miniVite/run2.sh @@ -0,0 +1,21 @@ +#!/bin/bash + +log1="summit/all_032619_1_2.log" +log2="summit/all_032619_2_2.log" + +cd /ccs/home/lld/apps/miniVite + +for(( j=0; j<3; j++ )) +do + bsub -o $log1 submit_mid2.lsf + bsub -o $log2 submit_hu.lsf + sleep 1 + job_num=`bjob | grep lld | wc -l` + while [ $job_num -ne 0 ] + do + sleep 30 + job_num=`bjob | grep lld | wc -l` + done +done + +cd - diff --git a/miniVite/stats b/miniVite/stats new file mode 100644 index 0000000..57aaf9c --- /dev/null +++ b/miniVite/stats @@ -0,0 +1,2 @@ +grep Time: summit/alloc_040419_sm.log | awk '{print $2}' | v2m 4 7 3 +grep Time: summit/alloc_040519_la.log | awk '{print $2}' | v2m 11 6 3 diff --git a/miniVite/submit.sh b/miniVite/submit.sh new file mode 100644 index 0000000..a039b51 --- /dev/null +++ b/miniVite/submit.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +log="summit/all_032619.log" +opt="-nnodes 1 -P GEN010SOLLVE -J km -W 120 -q batch -o $log" + +cd /ccs/home/lld/apps/miniVite + +for(( j=0; j<3; j++ )) +do + for(( i=5000000; i<=150000000; i+=5000000 )) + do + LLD_GPU_MODE=UM bsub $opt jsrun -n1 -g6 nvprof ./miniVite -n 10000000 + sleep 1 + job_num=`bjob | grep lld | wc -l` + while [ $job_num -ne 0 ] + do + sleep 30 + job_num=`bjob | grep lld | wc -l` + done + done +done + +cd - diff --git a/miniVite/utils.hpp b/miniVite/utils.hpp new file mode 100644 index 0000000..50337e4 --- /dev/null +++ b/miniVite/utils.hpp @@ -0,0 +1,328 @@ +// *********************************************************************** +// +// miniVite +// +// *********************************************************************** +// +// Copyright (2018) Battelle Memorial Institute +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// ************************************************************************ + +#pragma once +#ifndef UTILS_HPP +#define UTILS_HPP + +#define PI (3.14159) +#define MAX_PRINT_NEDGE (100000) + +// Read https://en.wikipedia.org/wiki/Linear_congruential_generator#Period_length +// about choice of LCG parameters +// From numerical recipes +// TODO FIXME investigate larger periods +#define MLCG (2147483647) // 2^31 - 1 +#define ALCG (16807) // 7^5 +#define BLCG (0) + +#define SR_UP_TAG 100 +#define SR_DOWN_TAG 101 +#define SR_SIZES_UP_TAG 102 +#define SR_SIZES_DOWN_TAG 103 +#define SR_X_UP_TAG 104 +#define SR_X_DOWN_TAG 105 +#define SR_Y_UP_TAG 106 +#define SR_Y_DOWN_TAG 107 +#define SR_LCG_TAG 108 + +#include +#include +#include + +#ifdef USE_32_BIT_GRAPH +using GraphElem = int32_t; +using GraphWeight = float; +const MPI_Datatype MPI_GRAPH_TYPE = MPI_INT32_T; +const MPI_Datatype MPI_WEIGHT_TYPE = MPI_FLOAT; +#else +using GraphElem = int64_t; +using GraphWeight = double; +const MPI_Datatype MPI_GRAPH_TYPE = MPI_INT64_T; +const MPI_Datatype MPI_WEIGHT_TYPE = MPI_DOUBLE; +#endif + +extern unsigned seed; + +// Is nprocs a power-of-2? +int is_pwr2(int nprocs) +{ return ((nprocs != 0) && !(nprocs & (nprocs - 1))); } + +// return unint32_t seed +GraphElem reseeder(unsigned initseed) +{ + std::seed_seq seq({initseed}); + std::vector seeds(1); + seq.generate(seeds.begin(), seeds.end()); + + return (GraphElem)seeds[0]; +} + +// Local random number generator +template +T genRandom(T lo, T hi) +{ + thread_local static G gen(seed); + using Dist = typename std::conditional + < + std::is_integral::value + , std::uniform_int_distribution + , std::uniform_real_distribution + >::type; + + thread_local static Dist utd {}; + return utd(gen, typename Dist::param_type{lo, hi}); +} + +// Parallel Linear Congruential Generator +// x[i] = (a*x[i-1] + b)%M +class LCG +{ + public: + LCG(unsigned seed, GraphWeight* drand, + GraphElem n, MPI_Comm comm = MPI_COMM_WORLD): + seed_(seed), drand_(drand), n_(n) + { + comm_ = comm; + MPI_Comm_size(comm_, &nprocs_); + MPI_Comm_rank(comm_, &rank_); + + // allocate long random numbers + rnums_.resize(n_); + + // init x0 + if (rank_ == 0) + x0_ = reseeder(seed_); + + // step #1: bcast x0 from root + MPI_Bcast(&x0_, 1, MPI_GRAPH_TYPE, 0, comm_); + + // step #2: parallel prefix to generate first random value per process + parallel_prefix_op(); + } + + ~LCG() { rnums_.clear(); } + + // matrix-matrix multiplication for 2x2 matrices + void matmat_2x2(GraphElem c[], GraphElem a[], GraphElem b[]) + { + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + GraphElem sum = 0; + for (int k = 0; k < 2; k++) { + sum += a[i*2+k]*b[k*2+j]; + } + c[i*2+j] = sum; + } + } + } + + // x *= y + void matop_2x2(GraphElem x[], GraphElem y[]) + { + GraphElem tmp[4]; + matmat_2x2(tmp, x, y); + memcpy(x, tmp, sizeof(GraphElem[4])); + } + + // find kth power of a 2x2 matrix + void mat_power(GraphElem mat[], GraphElem k) + { + GraphElem tmp[4]; + memcpy(tmp, mat, sizeof(GraphElem[4])); + + // mat-mat multiply k times + for (GraphElem p = 0; p < k-1; p++) + matop_2x2(mat, tmp); + } + + // parallel prefix for matrix-matrix operation + // `x0 is the very first random number in the series + // `ab is a 2-length array which stores a and b + // `n_ is (n/p) + // `rnums is n_ length array which stores the random nums for a process + void parallel_prefix_op() + { + GraphElem global_op[4]; + global_op[0] = ALCG; + global_op[1] = 0; + global_op[2] = BLCG; + global_op[3] = 1; + + mat_power(global_op, n_); // M^(n/p) + GraphElem prefix_op[4] = {1,0,0,1}; // I in row-major + + GraphElem global_op_recv[4]; + + int steps = (int)(log2((double)nprocs_)); + + for (int s = 0; s < steps; s++) { + + int mate = rank_^(1 << s); // toggle the sth LSB to find my neighbor + + // send/recv global to/from mate + MPI_Sendrecv(global_op, 4, MPI_GRAPH_TYPE, mate, SR_LCG_TAG, + global_op_recv, 4, MPI_GRAPH_TYPE, mate, SR_LCG_TAG, + comm_, MPI_STATUS_IGNORE); + + matop_2x2(global_op, global_op_recv); + + if (mate < rank_) + matop_2x2(prefix_op, global_op_recv); + + MPI_Barrier(comm_); + } + + // populate the first random number entry for each process + // (x0*a + b)%P + if (rank_ == 0) + rnums_[0] = x0_; + else + rnums_[0] = (x0_*prefix_op[0] + prefix_op[2])%MLCG; + } + + // generate random number based on the first + // random number on a process + // TODO check the 'quick'n dirty generators to + // see if we can avoid the mod + void generate() + { +#if defined(PRINT_LCG_LONG_RANDOM_NUMBERS) + for (int k = 0; k < nprocs_; k++) { + if (k == rank_) { + std::cout << "------------" << std::endl; + std::cout << "Process#" << rank_ << " :" << std::endl; + std::cout << "------------" << std::endl; + std::cout << rnums_[0] << std::endl; + for (GraphElem i = 1; i < n_; i++) { + rnums_[i] = (rnums_[i-1]*ALCG + BLCG)%MLCG; + std::cout << rnums_[i] << std::endl; + } + } + MPI_Barrier(comm_); + } +#else + for (GraphElem i = 1; i < n_; i++) { + rnums_[i] = (rnums_[i-1]*ALCG + BLCG)%MLCG; + } +#endif + GraphWeight mult = 1.0 / (GraphWeight)(1.0 + (GraphWeight)(MLCG-1)); + +#if defined(PRINT_LCG_DOUBLE_RANDOM_NUMBERS) + for (int k = 0; k < nprocs_; k++) { + if (k == rank_) { + std::cout << "------------" << std::endl; + std::cout << "Process#" << rank_ << " :" << std::endl; + std::cout << "------------" << std::endl; + + for (GraphElem i = 0; i < n_; i++) { + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult ); // 0-1 + std::cout << drand_[i] << std::endl; + } + } + MPI_Barrier(comm_); + } +#else + for (GraphElem i = 0; i < n_; i++) + drand_[i] = (GraphWeight)((GraphWeight)fabs(rnums_[i]) * mult); // 0-1 +#endif + } + + // copy from drand_[idx_start] to new_drand, + // rescale the random numbers between lo and hi + void rescale(GraphWeight* new_drand, GraphElem idx_start, GraphWeight const& lo) + { + GraphWeight range = (1.0 / (GraphWeight)nprocs_); + +#if defined(PRINT_LCG_DOUBLE_LOHI_RANDOM_NUMBERS) + for (int k = 0; k < nprocs_; k++) { + if (k == rank_) { + std::cout << "------------" << std::endl; + std::cout << "Process#" << rank_ << " :" << std::endl; + std::cout << "------------" << std::endl; + + for (GraphElem i = idx_start, j = 0; i < n_; i++, j++) { + new_drand[j] = lo + (GraphWeight)(range * drand_[i]); + std::cout << new_drand[j] << std::endl; + } + } + MPI_Barrier(comm_); + } +#else + for (GraphElem i = idx_start, j = 0; i < n_; i++, j++) + new_drand[j] = lo + (GraphWeight)(range * drand_[i]); // lo-hi +#endif + } + + private: + MPI_Comm comm_; + int nprocs_, rank_; + unsigned seed_; + GraphElem n_, x0_; + GraphWeight* drand_; + std::vector rnums_; +}; + +// locks +#ifdef USE_OPENMP_LOCK +#else +#ifdef USE_SPINLOCK +#include +std::atomic_flag lkd_ = ATOMIC_FLAG_INIT; +#else +#include +std::mutex mtx_; +#endif +void lock() { +#ifdef USE_SPINLOCK + while (lkd_.test_and_set(std::memory_order_acquire)) { ; } +#else + mtx_.lock(); +#endif +} +void unlock() { +#ifdef USE_SPINLOCK + lkd_.clear(std::memory_order_release); +#else + mtx_.unlock(); +#endif +} +#endif + +#endif // UTILS