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);
}
