graph.hpp

/*
 * Copyright 2016 The George Washington University
 * Written by Hang Liu 
 * Directed by Prof. Howie Huang
 *
 * https://www.seas.gwu.edu/~howie/
 * Contact: iheartgraph@gmail.com
 *
 * 
 * Please cite the following paper:
 * 
 * Hang Liu and H. Howie Huang. 2015. Enterprise: breadth-first graph traversal on GPUs. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC '15). ACM, New York, NY, USA, Article 68 , 12 pages. DOI: http://dx.doi.org/10.1145/2807591.2807594
 
 *
 * This file is part of Enterprise.
 *
 * Enterprise is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Enterprise is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Enterprise.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "graph.h"

template<
typename file_vert_t, typename file_index_t, typename file_weight_t,
typename new_vert_t, typename new_index_t, typename new_weight_t>
graph<file_vert_t,file_index_t, file_weight_t,
new_vert_t,new_index_t,new_weight_t>
::graph(
		const char *outbeg_file,
		const char *csr_file,
		const char *inbeg_file,
		const char *csc_file,
		const char *weight_file)
{
	double tm=wtime();
	FILE *file=NULL;
	file_index_t ret;
	
	vert_count=fsize(outbeg_file)/sizeof(file_index_t) - 1;
	edge_count=fsize(csr_file)/sizeof(file_vert_t);
	
	file=fopen(outbeg_file, "rb");
	if(file!=NULL)
	{
		file_index_t *tmp_outbeg_pos = new file_index_t[vert_count+1];
		ret=fread(tmp_outbeg_pos, sizeof(file_index_t), 
				vert_count+1, file);
		assert(ret==vert_count+1);
		fclose(file);
		std::cout<<"Possible edge count: "<<tmp_outbeg_pos[vert_count]<<"\n";
	
		//converting to new type when different 
		if(sizeof(file_index_t)!=sizeof(new_index_t))
		{
			outbeg_pos = new new_index_t[vert_count+1];
			for(new_index_t i=0;i<vert_count+1;++i)
				outbeg_pos[i]=(new_index_t)tmp_outbeg_pos[i];
			delete[] tmp_outbeg_pos;
		}else{outbeg_pos=(new_index_t*)tmp_outbeg_pos;}
	}else std::cout<<"outbeg file cannot open\n";

    file=fopen(inbeg_file, "rb");
	if(file!=NULL)
	{
		file_index_t *tmp_inbeg_pos = new file_index_t[vert_count+1];
		ret=fread(tmp_inbeg_pos, sizeof(file_index_t), 
				vert_count+1, file);
		assert(ret==vert_count+1);
		fclose(file);
		std::cout<<"Possible edge count: "<<tmp_inbeg_pos[vert_count]<<"\n";
	
		//converting to new type when different 
		if(sizeof(file_index_t)!=sizeof(new_index_t))
		{
			inbeg_pos = new new_index_t[vert_count+1];
			for(new_index_t i=0;i<vert_count+1;++i)
				inbeg_pos[i]=(new_index_t)tmp_inbeg_pos[i];
			delete[] tmp_inbeg_pos;
		}else{inbeg_pos=(new_index_t*)tmp_inbeg_pos;}
	}else std::cout<<"inbeg file cannot open\n";
	
    file=fopen(csr_file, "rb");
	if(file!=NULL)
	{
		file_vert_t *tmp_csr = NULL;
		if(posix_memalign((void **)&tmp_csr,32,sizeof(file_vert_t)*edge_count))
			perror("posix_memalign");
		
		ret=fread(tmp_csr, sizeof(file_vert_t), edge_count, file);
		assert(ret==edge_count);
		fclose(file);
			
		if(sizeof(file_vert_t)!=sizeof(new_vert_t))
		{
			if(posix_memalign((void **)&csr,32,sizeof(new_vert_t)*edge_count))
				perror("posix_memalign");
			for(new_index_t i=0;i<edge_count;++i)
				csr[i]=(new_vert_t)tmp_csr[i];
			delete[] tmp_csr;
		}else csr=(new_vert_t*)tmp_csr;

	}else std::cout<<"CSR file cannot open\n";

    file=fopen(csc_file, "rb");
	if(file!=NULL)
	{
		file_vert_t *tmp_csc = NULL;
		if(posix_memalign((void **)&tmp_csc,32,sizeof(file_vert_t)*edge_count))
			perror("posix_memalign");
		
		ret=fread(tmp_csc, sizeof(file_vert_t), edge_count, file);
		assert(ret==edge_count);
		fclose(file);
			
		if(sizeof(file_vert_t)!=sizeof(new_vert_t))
		{
			if(posix_memalign((void **)&csc,32,sizeof(new_vert_t)*edge_count))
				perror("posix_memalign");
			for(new_index_t i=0;i<edge_count;++i)
				csc[i]=(new_vert_t)tmp_csc[i];
			delete[] tmp_csc;
		}else csc=(new_vert_t*)tmp_csc;

	}else std::cout<<"CSC file cannot open\n";

	file=fopen(weight_file, "rb");
	if(file!=NULL)
	{
		file_weight_t *tmp_weight = NULL;
		if(posix_memalign((void **)&tmp_weight,32,
					sizeof(file_weight_t)*edge_count))
			perror("posix_memalign");
		
		ret=fread(tmp_weight, sizeof(file_weight_t), edge_count, file);
		assert(ret==edge_count);
		fclose(file);
	
		if(sizeof(file_weight_t)!=sizeof(new_weight_t))
		{
			if(posix_memalign((void **)&weight,32,
						sizeof(new_weight_t)*edge_count))
				perror("posix_memalign");
			for(new_index_t i=0;i<edge_count;++i)
				weight[i]=(new_weight_t)tmp_weight[i];
			delete[] tmp_weight;
		}else weight=(new_weight_t*)tmp_weight;
	}
	else std::cout<<"Weight file cannot open\n";

	std::cout<<"Graph load (success): "<<vert_count<<" verts, "
		<<edge_count<<" edges "<<wtime()-tm<<" second(s)\n";
}