int main(int argc, char** argv) {
GRAPH_L_ADJ graph;
if (argc != 2) {
printf("%s\n", "Veuillez specifier un fichier de graphe.");
exit(-1);
}
graph = load_graph(argv[1]);
//Marquage topologique
printf("Nombre de predecesseur de chacun des noeuds du graphe : \n");
for (int i = 0; i < graph.nbSom; i++) {
printf("Noeud %d : %d\n", i, graph.predNumber[i]);
}
printf("\n");
QUEUE_INT topologicalQueue = topologicalMarking(&graph);
computeEarlyDate(&graph); //fournir date au plus tot
computeLateDate(&graph); //date au plus tard
computeTolerances(&graph); //marge de toutes les taches
computeCritacalTasks(&graph, topologicalQueue); //liste des taches critiques
//date de fin de travaux
printf("Date de fin des travaux : %d\n", graph.nodeTab[graph.nbSom - 1]->lateDate); //Date au plus tard de omega.
free(graph.predNumber);
free(graph.nodeTab);
free(graph.predTab);
free(graph.succTab);
return 0;
}
void test_core_layout(){
int radius = 5, width=1;
graph_t *g = load_graph("datasets/email/edges.txt", false);
int n = graph_num_vertices(g);
coord_t *p = malloc(n * sizeof(*p));
graph_layout_core_shell(g, width+radius, true, p);
color_t solid_red = {255, 0, 0, 255};
color_t black = {0, 0, 0, 255};
circle_style_t point_style;
point_style.radius = radius;
point_style.width = width;
color_copy(point_style.fill, solid_red);
color_copy(point_style.stroke, black);
path_style_t edge_style;
edge_style.width = width;
color_copy(edge_style.color, black);
graph_print_svg_one_style("test/test_core_layout.svg", 0, 0, g, p,
point_style, edge_style);
free(p);
delete_graph(g);
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
Graph::Graph(const std::string& fname) {
// init members
graph_fname = fname;
// load graph as is
load_graph();
// update label
label = fname.substr(fname.find_last_of("/") + 1);
label = label.substr(0, label.find_first_of("_"));
}
void setup()
{
if (setup_done) {
return;
}
graph = &the_graph;
vertices = &graph->vertices[0];
q = the_queue;
load_graph("example.graph", &parse_simple_space_delimited_line, graph);
setup_done = TRUE;
}
int main(int argc, char** argv) {
if (argc == 2) {
char* filename = argv[1];
printf("Carregando...\n");
Graph* graph = load_graph(filename);
printf("Arquivo aberto: \"%s\".\n", filename);
int node_count = graph->node_count;
int edge_count = 0;
printf("%d vertices encontrados.\n", node_count);
for (int i = 0; i < node_count; i++) {
for (int j = 0; j < node_count; j++) {
if (contains_edge(graph, i, j)) {
edge_count++;
}
/*if(j == 0){
printf("Total edges found = %7d; checking edges from node %5d\r", edge_count >> 1, i);
}*/
}
}
printf("%d arestas encontradas.\n", edge_count >> 1);
create_general_options(graph);
return (EXIT_SUCCESS);
} else {
/* Load the the command line options into opts */
static Options load_options(int argc, char *argv[]) {
/* Uses the built-in C standard library function getopt to process the
* command line arguments. */
extern char *optarg;
extern int optind;
int c;
Options opts = {
.sort = NONE,
.method = NULL,
.verify = false,
.print = false,
.output = NULL,
.exe = argv[0],
.input = NULL,
};
while ((c = getopt(argc, argv, "m:ap:v")) != -1) {
switch (c) {
case 'm':
opts.sort = atoi(optarg);
switch (opts.sort) {
case DFS : opts.method = "DFS" ; break;
case KAHN: opts.method = "Kahn"; break;
default:
fprintf(stderr, "Unrecognised sort method\n");
usage_exit(opts.exe);
}
break;
case 'p':
opts.print = true;
opts.output = optarg;
break;
case 'v': opts.verify = true; break;
case '?':
default: usage_exit(opts.exe);
}
}
/* Check that one of -p, -m or -v is specified. */
if (!(opts.print || opts.sort || opts.verify)) {
fprintf(stderr, "One of -p, -v or -m must be specified\n");
usage_exit(opts.exe);
}
/* Check that only one of -m or -v is specified. */
if (opts.sort && opts.verify) {
fprintf(stderr, "Only one of -v or -m may be specified\n");
usage_exit(opts.exe);
}
/* Check that input is specified. */
if (optind + 1 > argc) {
fprintf(stderr, "Missing input file\n");
usage_exit(opts.exe);
} else {
opts.input = argv[optind];
}
return opts;
}
/* Main driver for the program */
int main(int argc, char *argv[]) {
List sorted = NULL;
Options opts = load_options(argc, argv);
Graph graph = load_graph(opts.input);
if (opts.print)
print_graph(opts.output, graph);
clock_t start = clock();
switch (opts.sort) {
case DFS : sorted = dfs_sort(graph); break;
case KAHN: sorted = kahn_sort(graph); break;
}
clock_t end = clock();
if (sorted) {
char *performance = "%s sort: %d vertices, %d edges, %ld clock ticks\n";
fprintf(stderr
, performance
, opts.method
, graph->order
, graph->size
, end - start);
print_list(print_vertex_id, stdout, sorted);
}
if (opts.verify) {
sorted = load_vertex_sequence(stdin, graph);
const char *sort_succ = "Valid topological ordering\n";
const char *sort_fail = "Invalid topological ordering\n";
printf(verify(graph, sorted) ? sort_succ : sort_fail);
}
free_list(sorted);
free_graph(graph);
exit(EXIT_SUCCESS);
}
void run(context_t& ctx, bool directed) {
bool is_master = ctx.dc.procid() == 0;
timer_start(is_master);
#ifdef GRANULA
granula::operation powergraphJob("PowerGraph", "Id.Unique", "Job", "Id.Unique");
granula::operation loadGraph("PowerGraph", "Id.Unique", "LoadGraph", "Id.Unique");
if(is_master) {
cout<<powergraphJob.getOperationInfo("StartTime", powergraphJob.getEpoch())<<endl;
cout<<loadGraph.getOperationInfo("StartTime", loadGraph.getEpoch())<<endl;
}
#endif
// process parmaeters
global_directed = directed;
// load graph
timer_next("load graph");
graph_type graph(ctx.dc);
load_graph(graph, ctx);
graph.finalize();
#ifdef GRANULA
if(is_master) {
cout<<loadGraph.getOperationInfo("EndTime", loadGraph.getEpoch())<<endl;
}
#endif
// start engine
timer_next("initialize engine");
graphlab::omni_engine<triangle_count> engine(ctx.dc, graph, "synchronous", ctx.clopts);
engine.signal_all();
#ifdef GRANULA
granula::operation processGraph("PowerGraph", "Id.Unique", "ProcessGraph", "Id.Unique");
if(is_master) {
cout<<processGraph.getOperationInfo("StartTime", processGraph.getEpoch())<<endl;
}
#endif
// run algorithm
timer_next("run algorithm");
engine.start();
#ifdef GRANULA
if(is_master) {
cout<<processGraph.getOperationInfo("EndTime", processGraph.getEpoch())<<endl;
}
#endif
#ifdef GRANULA
granula::operation offloadGraph("PowerGraph", "Id.Unique", "OffloadGraph", "Id.Unique");
if(is_master) {
cout<<offloadGraph.getOperationInfo("StartTime", offloadGraph.getEpoch())<<endl;
}
#endif
// print output
if (ctx.output_enabled) {
timer_next("print output");
vector<pair<graphlab::vertex_id_type, vertex_data_type> > data;
collect_vertex_data(graph, data, is_master);
for (size_t i = 0; i < data.size(); i++) {
(*ctx.output_stream) << data[i].first << " " << data[i].second.clustering_coef << endl;
}
}
timer_end();
#ifdef GRANULA
if(is_master) {
cout<<offloadGraph.getOperationInfo("EndTime", offloadGraph.getEpoch())<<endl;
cout<<powergraphJob.getOperationInfo("EndTime", powergraphJob.getEpoch())<<endl;
}
#endif
}
int main(int argc, char* argv[]){
load_graph("");
return 0;
}
int main(int argc, char* argv[])
{
vis_graph g;
load_graph(::g_filename + ".co", g);
load_graph(::g_filename + ".gr", g);
::omp_set_num_threads(::g_nthreads);
size_t real_nthreads = ::omp_get_max_threads();
size_t offset = (g.v_count() + real_nthreads - 1) / real_nthreads;
#pragma omp parallel
{
size_t threadid = ::omp_get_thread_num();
calculate_reaches (g, offset*threadid, std::min(offset*(threadid+1), g.v_count()), threadid);
}
/*
for (size_t i = 0; i < verts_arr.size(); ++i)
{
calculate_reach(g, verts_arr[i], reaches);
std::cout << "Visiting " << i << "...\n";
}
for (size_t i = 0; i < verts_arr.size(); ++i)
{
std::cout << "Reach for " << i << ": " << reaches[verts_arr[i]] << "\n";
}
*/
/*
for (int i=0; i<100; ++i)
{
my_graph::vertex_id vid = (rand()*RAND_MAX + rand()) % g.v_count();
std::cout << "Vertex: " << vid << "\n";
calculate_reach (g, vid);
}
*/
//std::cout << "max depth: " << depth << "\n";
/*
const size_t thread_size = 100;
#pragma omp parallel num_threads(2)
{
const size_t thread_id = ::omp_get_thread_num ();
const size_t offset = thread_size * thread_id;
for (size_t i = offset; i < offset + thread_size && i < verts_arr.size(); ++i)
{
calculate_reach (g, verts_arr[i]);
if ((i-offset) % 10 == 0)
{
#pragma omp critical
{
std::cout << thread_id << ": " << i << "\n";
}
}
}
}
*/
return 0;
}
