typedef struct Set { } int main (int argc, char const * argv[]) { inputGraph(); sortEdges(); printGraph(); return 0; }
//****main**** int main(){ struct gnode *adj[MAX]; int num; printf("\nEnter no. of nodes in weighted graph: "); scanf("%d",&num); num-=1; createGraph(adj,num); inputGraph(adj,num); printGraph(adj,num); minimumSpanningTreePrim(adj,num); deleteGraph(adj,num); return 0; }
/** The main program. */ int main(int argc, char *argv[]) { Parameters param(argc, argv); // parse the command-line arguments if(param.noOfNodes() == std::numeric_limits<unsigned int>::max() || param.noOfEdges() ==std::numeric_limits<unsigned int>::max()) { STXXL_MSG("Either number of vertices or edges is not speicifed. Exiting!!!"); return 0; } Graph inputGraph(param.noOfNodes(),param.noOfEdges()); if (param.randomGraph()) { STXXL_MSG("Generating random graph"); inputGraph.generateGraph(); inputGraph.printGraph(); } else if (param.importInputFilename() != "") { // import graph from file STXXL_MSG("Import graph" << std::endl ); if(param.otherGraph()) importFromFile(param.importInputFilename(),inputGraph ); else importEdgeVector( param.importInputFilename(),inputGraph ); } // export input graph if (param.outputFilename() != "") { STXXL_MSG("Export graph" << std::endl ); std::ofstream outFile(param.outputFilename().c_str()); exportEdgeVector(outFile, inputGraph); } stxxl::stats_data stats_begin(*stxxl::stats::get_instance()); stxxl::timer Timer; MST mst(inputGraph.getNoVertices()); mst.clearMST(); float B = (float) BLOCK_SIZE/(float)(sizeof(Edge)); float M = (10 * 1024 * 1024)/(float)(sizeof(Edge)); float N = param.noOfNodes()+2*param.noOfEdges(); STXXL_MSG("N: "<<N<<" M: "<<M<<" B: "<<B<<" Sizeof Edge: "<<sizeof(Edge)); if(N > M) { stxxl::stats_data stats_begin(*stxxl::stats::get_instance()); Timer.reset(); Timer.start(); stage(inputGraph,mst); STXXL_MSG("Part-1 build elapsed time: " << (Timer.mseconds() / 1000.) <<" seconds : " << (double(inputGraph.getNoEdges()) / (Timer.mseconds() / 1000.)) << " edges per sec"); std::cout << stats_total; } if(inputGraph.getNoEdges() != 0) { stats_begin = *stxxl::stats::get_instance(); Timer.reset(); Timer.start(); ExternalPrim prim; prim.buildMST(inputGraph,mst); STXXL_MSG("MST build elapsed time: " << (Timer.mseconds() / 1000.) <<" seconds : " << (double(inputGraph.getNoEdges()) / (Timer.mseconds() / 1000.)) << " edges per sec"); std::cout << stxxl::stats_data(*stxxl::stats::get_instance()) - stats_begin; } mst.printMST(); return 0; }
bool CoreDriver::parse(int argc, const char *argv[], CoreLinkingContext &ctx, raw_ostream &diagnostics) { // Parse command line options using CoreOptions.td std::unique_ptr<llvm::opt::InputArgList> parsedArgs; CoreOptTable table; unsigned missingIndex; unsigned missingCount; parsedArgs.reset( table.ParseArgs(&argv[1], &argv[argc], missingIndex, missingCount)); if (missingCount) { diagnostics << "error: missing arg value for '" << parsedArgs->getArgString(missingIndex) << "' expected " << missingCount << " argument(s).\n"; return false; } std::unique_ptr<InputGraph> inputGraph(new InputGraph()); // Set default options ctx.setOutputPath("-"); ctx.setDeadStripping(false); ctx.setGlobalsAreDeadStripRoots(false); ctx.setPrintRemainingUndefines(false); ctx.setAllowRemainingUndefines(true); ctx.setSearchArchivesToOverrideTentativeDefinitions(false); // Process all the arguments and create Input Elements for (auto inputArg : *parsedArgs) { switch (inputArg->getOption().getID()) { case OPT_mllvm: ctx.appendLLVMOption(inputArg->getValue()); break; case OPT_entry: ctx.setEntrySymbolName(inputArg->getValue()); break; case OPT_output: ctx.setOutputPath(inputArg->getValue()); break; case OPT_dead_strip: ctx.setDeadStripping(true); break; case OPT_keep_globals: ctx.setGlobalsAreDeadStripRoots(true); break; case OPT_undefines_are_errors: ctx.setPrintRemainingUndefines(true); ctx.setAllowRemainingUndefines(false); break; case OPT_commons_search_archives: ctx.setSearchArchivesToOverrideTentativeDefinitions(true); break; case OPT_add_pass: ctx.addPassNamed(inputArg->getValue()); break; case OPT_INPUT: inputGraph->addInputElement(std::unique_ptr<InputElement>( new COREFileNode(ctx, inputArg->getValue()))); break; default: break; } } if (!inputGraph->size()) { diagnostics << "No input files\n"; return false; } ctx.setInputGraph(std::move(inputGraph)); // Validate the combination of options used. return ctx.validate(diagnostics); }
bool DarwinLdDriver::parse(int argc, const char *argv[], MachOLinkingContext &ctx, raw_ostream &diagnostics) { // Parse command line options using DarwinLdOptions.td std::unique_ptr<llvm::opt::InputArgList> parsedArgs; DarwinLdOptTable table; unsigned missingIndex; unsigned missingCount; bool globalWholeArchive = false; parsedArgs.reset( table.ParseArgs(&argv[1], &argv[argc], missingIndex, missingCount)); if (missingCount) { diagnostics << "error: missing arg value for '" << parsedArgs->getArgString(missingIndex) << "' expected " << missingCount << " argument(s).\n"; return false; } for (auto it = parsedArgs->filtered_begin(OPT_UNKNOWN), ie = parsedArgs->filtered_end(); it != ie; ++it) { diagnostics << "warning: ignoring unknown argument: " << (*it)->getAsString(*parsedArgs) << "\n"; } // Figure out output kind ( -dylib, -r, -bundle, -preload, or -static ) if ( llvm::opt::Arg *kind = parsedArgs->getLastArg(OPT_dylib, OPT_relocatable, OPT_bundle, OPT_static, OPT_preload)) { switch (kind->getOption().getID()) { case OPT_dylib: ctx.setOutputFileType(llvm::MachO::MH_DYLIB); ctx.setGlobalsAreDeadStripRoots(true); break; case OPT_relocatable: ctx.setPrintRemainingUndefines(false); ctx.setAllowRemainingUndefines(true); ctx.setOutputFileType(llvm::MachO::MH_OBJECT); break; case OPT_bundle: ctx.setOutputFileType(llvm::MachO::MH_BUNDLE); break; case OPT_static: ctx.setOutputFileType(llvm::MachO::MH_EXECUTE); break; case OPT_preload: ctx.setOutputFileType(llvm::MachO::MH_PRELOAD); break; } } // Handle -e xxx if (llvm::opt::Arg *entry = parsedArgs->getLastArg(OPT_entry)) ctx.setEntrySymbolName(entry->getValue()); // Handle -o xxx if (llvm::opt::Arg *outpath = parsedArgs->getLastArg(OPT_output)) ctx.setOutputPath(outpath->getValue()); // Handle -dead_strip if (parsedArgs->getLastArg(OPT_dead_strip)) ctx.setDeadStripping(true); // Handle -all_load if (parsedArgs->getLastArg(OPT_all_load)) globalWholeArchive = true; // Handle -install_name if (llvm::opt::Arg *installName = parsedArgs->getLastArg(OPT_install_name)) ctx.setInstallName(installName->getValue()); // Handle -mark_dead_strippable_dylib if (parsedArgs->getLastArg(OPT_mark_dead_strippable_dylib)) ctx.setDeadStrippableDylib(true); // Handle -compatibility_version and -current_version if (llvm::opt::Arg *vers = parsedArgs->getLastArg(OPT_compatibility_version)) { if (ctx.outputFileType() != llvm::MachO::MH_DYLIB) { diagnostics << "error: -compatibility_version can only be used with -dylib\n"; return false; } uint32_t parsedVers; if (MachOLinkingContext::parsePackedVersion(vers->getValue(), parsedVers)) { diagnostics << "error: -compatibility_version value is malformed\n"; return false; } ctx.setCompatibilityVersion(parsedVers); } if (llvm::opt::Arg *vers = parsedArgs->getLastArg(OPT_current_version)) { if (ctx.outputFileType() != llvm::MachO::MH_DYLIB) { diagnostics << "-current_version can only be used with -dylib\n"; return false; } uint32_t parsedVers; if (MachOLinkingContext::parsePackedVersion(vers->getValue(), parsedVers)) { diagnostics << "error: -current_version value is malformed\n"; return false; } ctx.setCurrentVersion(parsedVers); } // Handle -bundle_loader if (llvm::opt::Arg *loader = parsedArgs->getLastArg(OPT_bundle_loader)) ctx.setBundleLoader(loader->getValue()); // Handle -arch xxx if (llvm::opt::Arg *archStr = parsedArgs->getLastArg(OPT_arch)) { ctx.setArch(MachOLinkingContext::archFromName(archStr->getValue())); if (ctx.arch() == MachOLinkingContext::arch_unknown) { diagnostics << "error: unknown arch named '" << archStr->getValue() << "'\n"; return false; } } // Handle -macosx_version_min or -ios_version_min if (llvm::opt::Arg *minOS = parsedArgs->getLastArg( OPT_macosx_version_min, OPT_ios_version_min, OPT_ios_simulator_version_min)) { switch (minOS->getOption().getID()) { case OPT_macosx_version_min: if (ctx.setOS(MachOLinkingContext::OS::macOSX, minOS->getValue())) { diagnostics << "error: malformed macosx_version_min value\n"; return false; } break; case OPT_ios_version_min: if (ctx.setOS(MachOLinkingContext::OS::iOS, minOS->getValue())) { diagnostics << "error: malformed ios_version_min value\n"; return false; } break; case OPT_ios_simulator_version_min: if (ctx.setOS(MachOLinkingContext::OS::iOS_simulator, minOS->getValue())) { diagnostics << "error: malformed ios_simulator_version_min value\n"; return false; } break; } } else { // No min-os version on command line, check environment variables } // Handle -help if (parsedArgs->getLastArg(OPT_help)) { table.PrintHelp(llvm::outs(), argv[0], "LLVM Darwin Linker", false); // If only -help on command line, don't try to do any linking if (argc == 2) { ctx.setDoNothing(true); return true; } } // Handle -mllvm for (llvm::opt::arg_iterator it = parsedArgs->filtered_begin(OPT_mllvm), ie = parsedArgs->filtered_end(); it != ie; ++it) { ctx.appendLLVMOption((*it)->getValue()); } std::unique_ptr<InputGraph> inputGraph(new InputGraph()); // Handle input files for (llvm::opt::arg_iterator it = parsedArgs->filtered_begin(OPT_INPUT), ie = parsedArgs->filtered_end(); it != ie; ++it) { inputGraph->addInputElement(std::unique_ptr<InputElement>( new MachOFileNode(ctx, (*it)->getValue(), globalWholeArchive))); } if (!inputGraph->size()) { diagnostics << "No input files\n"; return false; } ctx.setInputGraph(std::move(inputGraph)); // Validate the combination of options used. return ctx.validate(diagnostics); }