| /************************************************************************* | |
| * | |
| * PathFinder: finding a series of labeled nodes within a | |
| * two-layer directed, cyclic graph. | |
| * Copyright (2013) Sandia Corporation | |
| * | |
| * Copyright (2013) Sandia Corporation. Under the terms of Contract | |
| * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government | |
| * retains certain rights in this software. | |
| * | |
| * This file is part of PathFinder. | |
| * | |
| * PathFinder is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as | |
| * published by the Free Software Foundation, either version 3 of the | |
| * License, or (at your option) any later version. | |
| * | |
| * PathFinder 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 PathFinder. If not, see <http://www.gnu.org/licenses/>. | |
| * | |
| * Questions? Contact J. Brian Rigdon (jbrigdo@sandia.gov) | |
| * | |
| */ | |
| /* | |
| * main.c | |
| * | |
| * Created on: Jan 9, 2013 | |
| * Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder | |
| */ | |
| #include <string.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <ctype.h> | |
| #include <unistd.h> | |
| #include <stdbool.h> | |
| #include <math.h> | |
| #include "parsing.h" | |
| #include "utils.h" | |
| #include "searchAlgorithms.h" | |
| #include "vectorUtils.h" | |
| #include "statistics.h" | |
| #include "configuration.h" | |
| #include "yaml.h" | |
| #ifdef QT | |
| #include "qThreadSearch.h" | |
| #endif /* QT */ | |
| extern double currentTime(); | |
| #define helpString "\nUsage: PathFinder.exe [OPTIONS] [<fileName>]\n\n\ | |
| Operation:\n\ | |
| -c <config file> use configuration file\n\ | |
| -i <data file> interactive search of specified data file\n\ | |
| -x <data file> exhaustive leg search (any label to any label) of data file\n\n\ | |
| Other:\n\ | |
| -o <output file> save optimized graph to file\n\ | |
| -h,u prints this help message.\n\ | |
| -q <depth> use qthread parallelism (config file only). The depth value\n\ | |
| specifies how deep in recursion to continue spawning new tasks\n\ | |
| during searches\n\ | |
| -y create YAML output\n" | |
| /* Forward declarations so that main is the first function we read */ | |
| void runBatch(char *configFile, Configuration *config); | |
| void runInteractively(char *fileName, Configuration *config); | |
| void exhaustiveLegSearch(char *fileName, Configuration *config); | |
| int main(int argc, char *argv[]) | |
| { | |
| char defaultFile[] = "MicroTestData.adj_list"; | |
| char *fileName = NULL; | |
| Configuration *config = Configuration_new(); | |
| signed char c; | |
| int cFlag = 0; // Why did I make these ints instead of bool? JBR - 10/25/13 | |
| int iFlag = 0; | |
| int xFlag = 0; | |
| int tFlag = 0; | |
| int dFlag = 0; | |
| int oFlag = 0; | |
| bool qFlag = 0; | |
| int qCount = 0; | |
| char commandLine[200]; | |
| int i; | |
| printf ( "\n\n" | |
| " PathFinder: finding a series of labeled nodes within a\n" | |
| " two-layer directed, cyclic graph.\n" | |
| " Copyright (2013) Sandia Corporation\n" | |
| "\n" | |
| " Sandia National Laboratories is a multi-program laboratory managed and\n" | |
| " operated by Sandia Corporation, a wholly owned subsidiary of Lockheed\n" | |
| " Martin Corporation, for the U.S. Department of Energy's National Nuclear\n" | |
| " Security Administration under terms of Contract DE-AC04-94AL85000,\n" | |
| " there is a non-exclusive license for use of this work by or on behalf\n" | |
| " of the U.S. Government. Export of this program may require a license \n" | |
| " from the United States Government.\n\n\n" ); | |
| #ifdef DEBUG | |
| printf("\tRunning debug build\n\n"); | |
| #endif | |
| #ifdef OPENMP | |
| printf("\tRunning Open MP build\n\n"); | |
| #endif | |
| #ifdef QT | |
| printf("\tRunning Q Thread build\n\n"); | |
| #endif | |
| if ( !config ) | |
| { | |
| printf("Error: Could not allocation configuration structure.\n\n\t---Exiting\n\n"); | |
| exit(0); | |
| } | |
| if ( argc < 2 ) | |
| { | |
| exhaustiveLegSearch(defaultFile, config); | |
| } | |
| else | |
| { | |
| while ( (c = getopt(argc, argv, "c:i:x:o:q:huy")) != -1 ) | |
| { | |
| switch (c) | |
| { | |
| case '?': /* we had a problem */ | |
| if ( optopt == 'c' ) | |
| fprintf(stderr, "\tPlease specify configuration file.\n\n"); | |
| else if ( optopt == 'i' || optopt == 'x' ) | |
| fprintf(stderr, "\tPlease specify data file.\n\n"); | |
| else if ( optopt == 'o' ) | |
| fprintf(stderr, "\tPlease specify output graph data file.\n\n"); | |
| else if ( optopt == 'q' ) | |
| fprintf(stderr, "\tPlease specify recursion depth to keep spawning tasks.\n\n"); | |
| return(1); | |
| break; /* Superfluous, I know */ | |
| case 'h': | |
| case 'u': | |
| printf ("\n%s\n\n", helpString); | |
| return(0); /* Nothing else matters */ | |
| break; /* Superfluous, I know. */ | |
| case 'c': /* configuration file */ | |
| fileName = optarg; | |
| cFlag = 1; | |
| break; | |
| case 'i': /* interactive */ | |
| fileName = optarg; | |
| iFlag = 1; | |
| break; | |
| case 'x': /* exhaustive leg search */ | |
| fileName = optarg; | |
| xFlag = 1; | |
| break; | |
| case 'o': /* Save optimized paths in a new graph definition data file */ | |
| config->searchOptions->outputFile = optarg; | |
| config->searchOptions->writeOutputFile = true; | |
| oFlag = 1; | |
| break; | |
| case 's': | |
| config->searchOptions->doStatistics = true; | |
| break; | |
| case 'q': | |
| qCount = atoi(optarg); | |
| if ( qCount < 1 ) | |
| qCount = 1; | |
| config->qThreadCount = qCount; | |
| break; | |
| case 'y': | |
| /* if ( commandLine != NULL ) */ | |
| { | |
| YAMLOpen(); | |
| commandLine[0] = '\0'; | |
| for ( i = 0; i < argc; ++i ) | |
| sprintf(commandLine, "%s %s", commandLine, argv[i] ); | |
| YAMLWriteString("Command", commandLine+1); | |
| } | |
| break; | |
| default : | |
| break; | |
| } | |
| } | |
| /* Debug --* / | |
| if (cFlag) printf ("cFlag "); | |
| if (iFlag) printf ("iFlag "); | |
| if (xFlag) printf ("xFlag "); | |
| if (oFlag) printf ("oFlag "); | |
| if (fileName) printf ( " - %s", fileName ); | |
| if (outFile) printf ( " - %s", outFile); | |
| printf ("\n"); | |
| / *-- End Debug */ | |
| if ( (cFlag+iFlag+xFlag) > 1 ) | |
| { | |
| fprintf(stderr, "-c -i and -x are mutually exclusive, PathFinder can only do one of those.\n\n"); | |
| return(1); | |
| } | |
| if ( (cFlag+iFlag+xFlag) == 0 ) | |
| { | |
| fprintf(stderr, "-c (config file) -i (interactive) or -x (exhaustive) must be specified.\n\n"); | |
| return(1); | |
| } | |
| if ( oFlag && !xFlag ) | |
| { | |
| fprintf(stderr, "-o (optimized graph output) is only compatible with -x (exhaustive searches).\n\n"); | |
| return(1); | |
| } | |
| if ( cFlag ) | |
| runBatch(fileName, config); | |
| else if ( iFlag ) | |
| runInteractively(fileName, config); | |
| else | |
| { | |
| exhaustiveLegSearch(fileName, config); | |
| } | |
| } | |
| YAMLClose(); /* works even if YAML logging isn't present */ | |
| return(0); /* zero means no error */ | |
| } | |
| void runBatch(char *configFile, Configuration *config) | |
| { | |
| bool success; | |
| int i; | |
| int j; | |
| double tick, tock; | |
| int hours; | |
| int min; | |
| double sec; | |
| if ( !configFile ) | |
| { | |
| printf("Error: No config file entered.\n\n\t---Exiting---"); | |
| exit(0); | |
| } | |
| // printf("config file: %s\n", configFile); | |
| tick = currentTime(); | |
| success = parseConfigFile(configFile, config); | |
| tock = currentTime(); | |
| sec = tock-tick; | |
| hours = (int)sec/3600; | |
| sec = fmod( sec, 3600.0 ); | |
| min = (int)sec/60; | |
| sec = fmod(sec, 60.0); | |
| printf ("\n\nOverall Parse Time: %02d:%02d:%02.3f\n", hours, min, sec); | |
| /* Debug --* / | |
| for ( i = 0; config->signatures[i] != NULL; ++i ); | |
| for ( j = 0; config->graphs[j] != NULL; ++j ); | |
| printf( "%d files, %d signatures \n", j, i ); | |
| exit(1); | |
| / *-- End Debug */ | |
| if ( success ) | |
| { | |
| #ifdef QT | |
| doMultiSearchesQT(config); | |
| #else | |
| doMultiSearches(config); | |
| #endif | |
| } | |
| printf ("\n\nSearches complete.\n"); | |
| } | |
| void mygets(char *str, size_t n) | |
| { | |
| size_t len; | |
| if ( fgets(str, n, stdin) == NULL ) | |
| { | |
| printf("Error: No input provided.\n\n\t---Exiting---"); | |
| exit(0); | |
| } | |
| len = strlen(str); | |
| if ( len > 0 && str[len - 1] == '\n' ) | |
| str[len - 1] = '\0'; | |
| } | |
| void runInteractively(char *fileName, Configuration *config) | |
| { | |
| char stringBuffer[200]; | |
| Graph *graph; | |
| char *labels[25]; /* Do we need an interactive signature bigger than 25? */ | |
| NodePtrVec *path = NULL; | |
| bool success = false; | |
| int i, j; | |
| int fullIntSignature[3] = { 0, 0, -1 }; | |
| graph = parseFile(fileName); | |
| if ( !graph ) | |
| return; | |
| while ( 1 ) | |
| { | |
| i = 0; | |
| do { | |
| printf("\nPlease insert a node label for this signature (\"\" to complete, \"bail\" to exit):\n"); | |
| mygets(stringBuffer, sizeof stringBuffer); | |
| if ( strcmp (stringBuffer, "bail") == 0 ) | |
| exit(1); | |
| if ( strcmp(stringBuffer, "") != 0 ) | |
| { | |
| labels[i] = strdup(stringBuffer); | |
| ++i; | |
| } | |
| } while ( i < 25 && strcmp(stringBuffer, "") != 0 ); | |
| labels[i] = NULL; | |
| /* Debug */ | |
| printf("\nSignature: "); | |
| for ( j = 0; j < i; ++j ) | |
| { | |
| printf("'%s'", labels[j]); | |
| if ( j < i-1 ) | |
| printf(" -> "); | |
| else | |
| printf("\n\n"); | |
| } | |
| /* end debug */ | |
| path = NodePtrVec_new(50); | |
| success = findLabelPath(graph, (Signature)labels, path, config->searchOptions->searchType); | |
| /* Sanity check to verify that a valid path exists */ | |
| if( success ) | |
| { | |
| /* printStack ( path ); */ | |
| printf ("Found, resultant path has %d steps.\n", path->contentSize); | |
| } | |
| else | |
| printf("\n\tPath not found for signature.\n"); | |
| NodePtrVec_delete(path); | |
| } | |
| } | |
| void exhaustiveLegSearch(char *fileName, Configuration *config) | |
| { | |
| Graph *graph; | |
| int found; | |
| graph = parseFile(fileName); | |
| if ( !graph || !config ) | |
| return; | |
| if ( config->searchOptions->outputFile == NULL ) | |
| found = findAllPossibleLegs(graph, config->searchOptions->searchType); | |
| else | |
| found = findAndLogAllPossibleLegs(graph, config->searchOptions); | |
| printf("\n\nTotal %d legs found\n\n", found); | |
| Graph_delete(graph); | |
| } |