bool graph_miner_mpi_omp_hybrid::is_min(int thread_id)
{
if(DFS_CODE_V[thread_id].size() == 1) {
return (true);
}
DFS_CODE_V[thread_id].toGraph(GRAPH_IS_MIN_V[thread_id]);
DFS_CODE_IS_MIN_V[thread_id].clear();
Projected_map3 root;
types::EdgeList edges;
for(unsigned int from = 0; from < GRAPH_IS_MIN_V[thread_id].size(); ++from) {
if(get_forward_root(GRAPH_IS_MIN_V[thread_id], GRAPH_IS_MIN_V[thread_id][from], edges)) {
for(types::EdgeList::iterator it = edges.begin(); it != edges.end(); ++it) {
root[GRAPH_IS_MIN_V[thread_id][from].label][(*it)->elabel][GRAPH_IS_MIN_V[thread_id][(*it)->to].label].push(0, *it, 0);
} // for it
} // if get_forward_root
} // for from
Projected_iterator3 fromlabel = root.begin();
Projected_iterator2 elabel = fromlabel->second.begin();
Projected_iterator1 tolabel = elabel->second.begin();
DFS_CODE_IS_MIN_V[thread_id].push(0, 1, fromlabel->first, elabel->first, tolabel->first);
return (project_is_min(thread_id,tolabel->second));
}
bool graph_miner_mpi_omp_hybrid::is_min(Thread_private_data &gprv)
{
if(gprv.DFS_CODE.size() == 1) {
return (true);
}
gprv.DFS_CODE.toGraph(gprv.GRAPH_IS_MIN);
gprv.DFS_CODE_IS_MIN.clear();
Projected_map3 root;
types::EdgeList edges;
for(unsigned int from = 0; from < gprv.GRAPH_IS_MIN.size(); ++from) {
if(get_forward_root(gprv.GRAPH_IS_MIN, gprv.GRAPH_IS_MIN[from], edges)) {
for(types::EdgeList::iterator it = edges.begin(); it != edges.end(); ++it) {
root[gprv.GRAPH_IS_MIN[from].label][(*it)->elabel][gprv.GRAPH_IS_MIN[(*it)->to].label].push(0, *it, 0);
} // for it
} // if get_forward_root
} // for from
Projected_iterator3 fromlabel = root.begin();
Projected_iterator2 elabel = fromlabel->second.begin();
Projected_iterator1 tolabel = elabel->second.begin();
gprv.DFS_CODE_IS_MIN.push(0, 1, fromlabel->first, elabel->first, tolabel->first);
return (project_is_min(gprv,tolabel->second));
}
void graph_miner_mpi_dyn::run_intern(void)
{
types::EdgeList edges;
Projected_map3 root;
int single_edge_dfscodes = 0;
for(unsigned int from = 0; from < graph.size(); ++from) {
if(get_forward_root(graph, graph[from], edges)) { // get the edge list of the node g[from] in graph g
for(types::EdgeList::iterator it = edges.begin(); it != edges.end(); ++it) {
//embeddings with a single edge
if(root.count(graph[from].label) == 0 || root[graph[from].label].count((*it)->elabel) == 0 || root[graph[from].label][(*it)->elabel].count(graph[(*it)->to].label) == 0) {
single_edge_dfscodes++;
DEBUG(*logger, "single edge DFS code : (0,1," << graph[from].label << "," << (*it)->elabel << "," << graph[(*it)->to].label << ")" );
}
root[graph[from].label][(*it)->elabel][graph[(*it)->to].label].push(0, *it, 0); //projected (PDFS vector) entry: graph id (always 0 for single graph), edge pointer and null PDFS
} //for
} // if
} // for from
//} // for id
int dfscodes_per_rank = (int) ceil((single_edge_dfscodes * 1.0) / numtasks);
int start_index = rank * dfscodes_per_rank;
int end_index = start_index + dfscodes_per_rank - 1;
if (end_index > single_edge_dfscodes - 1)
end_index = single_edge_dfscodes - 1;
DEBUG(*(graph_miner::logger), "start index = " << start_index << " , end index = " << end_index << endl);
std::deque<types::DFS> tmp;
dfs_task_queue.push_back(tmp);
int index = 0;
for(Projected_iterator3 fromlabel = root.begin(); fromlabel != root.end(); ++fromlabel) {
for(Projected_iterator2 elabel = fromlabel->second.begin(); elabel != fromlabel->second.end(); ++elabel) {
for(Projected_iterator1 tolabel = elabel->second.begin();
tolabel != elabel->second.end(); ++tolabel) {
if( index >= start_index && index <= end_index ) {
// Build the initial two-node graph. It will be grownrecursively within project.
DFS dfs(0, 1, fromlabel->first, elabel->first, tolabel->first);
dfs_task_queue[0].push_back(dfs);
//std::cout << dfs.to_string() << endl;
}
index++;
} // for tolabel
} // for elabel
} // for fromlabel
//std::cout<<"size = " << dfs_task_queue[0].size() << std::endl;
//while(dfs_task_queue[0].size() > 0){
while(computation_end == false) {
if(dfs_task_queue[0].size() == 0) {
is_working = false;
embeddings_regeneration_level = 0;
task_split_level = 0;
load_balance();
}else{
//this is done in process_received_data, so not required here
//is_working = true;
DFS dfs = dfs_task_queue[0].front();
dfs_task_queue[0].pop_front();
DEBUG(*(graph_miner::logger), "popped dfs = " << dfs.to_string() );
load_balance();
DFS_CODE.push(0, 1, dfs.fromlabel, dfs.elabel, dfs.tolabel);
current_dfs_level = 1;
//INFO(*(graph_miner::logger), "embeddings regeneration level = " << embeddings_regeneration_level);
if(embeddings_regeneration_level < 1)
project(root[dfs.fromlabel][dfs.elabel][dfs.tolabel], 1); //Projected (PDFS vector): each entry contains graph id 0, edge pointer, null PDFS
else
regenerate_embeddings(root[dfs.fromlabel][dfs.elabel][dfs.tolabel], 1);
current_dfs_level = 0;
DFS_CODE.pop();
if(dfs_task_queue[0].size() == 0) {
DEBUG(*(graph_miner::logger),"processor " << rank << " is idle, has token = " << has_token);
if(has_token == true)
DEBUG(*(graph_miner::logger),"processor " << rank << " token color = " << get_token_color(token_color));
}
}
}
} // void graph_miner_mpi_dyn::run_intern(void)
void gSpan::run_intern()
{
if(maxpat_min <= 1) {
// std::cout << "TRANS.size() = " << TRANS.size() << std::endl;
//Counting the frequency of all single vertex labels
for(UINT id = 0; id<TRANS.size(); ++id)
{
for(UINT nid = 0; nid<TRANS[id].size(); ++nid)
{
if(singleVertex[id][TRANS[id][nid].label]==0)
singleVertexLabel[TRANS[id][nid].label] += 1;
singleVertex[id][TRANS[id][nid].label] += 1;
}
}
for(std::map<UINT,UINT>::iterator it = singleVertexLabel.begin(); it!=singleVertexLabel.end(); ++it)
{
if((*it).second < minsup) //checking frequency of vertices with minimum support.
continue; // Ignoring the infrequent vertices
UINT frequent_label = (*it).first;
//std::cout << "Frequent Label: " << frequent_label << std::endl;
Graph g(directed);
g.resize(1);
g[0].label = frequent_label;
// Didn't understand the purpose of this part
std::vector<UINT> counts(TRANS.size());
for(std::map<UINT, std::map<UINT, UINT> >::iterator it2 = singleVertex.begin(); it2 != singleVertex.end(); ++it2) {
// std::cout << "(*it2).first = " << (*it2).first << "(*it2).second[frequent_label] = " << (*it2).second[frequent_label] << std::endl;
counts[(*it2).first] = (*it2).second[frequent_label];
}
}
}
EdgeList edges;
Projected_map3 root;
for(UINT id=0; id< TRANS.size(); ++id)
{
Graph& g = TRANS[id];
for(UINT from = 0; from < g.size(); ++from)
{
if(get_forward_root(g,g[from],edges))
{
for(EdgeList::iterator it = edges.begin(); it!= edges.end(); ++it)
root[g[from].label][(*it)->elabel][g[(*it)->to].label].push(id,*it,0);
}
}
}
std::vector<Graph> List;
std::vector<Projected> proj_vec;
std::vector<string> FwEdge;
char ch[1000];
for(Projected_iterator3 fromlabel = root.begin(); fromlabel != root.end(); ++fromlabel)
{
for(Projected_iterator2 elabel = fromlabel ->second.begin(); elabel != fromlabel -> second.end(); ++elabel)
for(Projected_iterator1 tolabel = elabel->second.begin(); tolabel != elabel -> second.end(); ++tolabel)
{
std::cout << "0,1," << fromlabel->first << "," << elabel->first << "," << tolabel->first << std::endl;
sprintf(ch,"%d %d %d %d %d",0,1,fromlabel->first,elabel->first,tolabel->first);
FwEdge.push_back(ch);
Projected proj = tolabel->second;
proj_vec.push_back(proj);
}
}
vector<Graph> sorted;
int x[5];
// //Initial 1-edge graph to start
for(UINT i= 0; i< (int)FwEdge.size(); i++)
{
std::cout << FwEdge[i] << std::endl;
sscanf(FwEdge[i].c_str(),"%d %d %d %d %d",&x[0],&x[1],&x[2],&x[3],&x[4]);
//std::cout << FwEdge[i] << std::endl;
DFS_CODE.push(x[0],x[1],x[2],x[3],x[4]);
Graph g;
DFS_CODE.toGraph(g);
// Calculate_MDL(g,(UINT)NumOfLabels);
// std::set<int> occurrence = total_occurance(proj_vec[i]);
//
// g.MDL = EvaluateGraph(TRANS,g,occurrence);
//g.occurrence = support_counts(proj_vec[i]);
g.Frequency = support(proj_vec[i]);
g.SET_COVER = (double)g.Frequency / (double) TRANS.size();
sorted.push_back(g);
//ListInsert(BestList,g,5);
// std::cout << "MDL = "<< g.MDL << "vertex size = " << g.size() << "Support Count = " << support_counts(proj_vec[i])[0] << std::endl;
project(proj_vec[i]);
DFS_CODE.pop();
}
BestList.insert(BestList.end(),sorted.begin(),sorted.end());
// for(UINT i=0;i<sorted.size();i++)
// {
// ListInsert(BestList,sorted[i],maxBest);
// }
//
// Graph g(directed);
//
// g.resize(2);
// g[0].label = 2;
// g[0].used = false;
// g[1].label = 3;
// g[1].used = false;
//
// g[0].push(0,1,1);
// g[1].push(1,0,1);
// g.buildEdge();
// g.write();
// Calculate_MDL(g,3);
// std::set<int> ss;
// ss.insert(0);
// EvaluateGraph(TRANS,g,ss);
//
// //std::cout <<"Testing G = " << g.MDL << std::endl;
// exit(1);
sorted.clear();
List.clear();
FwEdge.clear();
proj_vec.clear();
}
