void get_string(int argc, char *argv[], int *pos, char *val) { if (*pos + 1 >= argc) { fprintf(stderr, "\n%s: argument %s expects an extra argument; " "none found\n", Progname, argv[*pos]); usage_message(stdout); exit(1); } strcpy(val, argv[*pos+1]); (*pos)++; } /* end get_string() */
/** * Error in dependency specification * * @param fmt the error message format */ static void dep_usage(char const * fmt, ...) { char * msg; { va_list ap; va_start(ap, fmt); (void)vasprintf(&msg, fmt, ap); va_end(ap); } usage_message(USAGE_INVAL_DEP_OPT_FMT, msg); /* NOTREACHED */ }
int main(int argc, char **argv) { struct mace_options opt; Plist clauses; Mace_results results; /* Following says whether to ignore unregognized set/clear/assigns. */ BOOL prover_compatability_mode = member_args(argc, argv, "-c"); init_standard_ladr(); init_mace_options(&opt); /* We must do this before calling usage_message. */ init_attrs(); if (member_args(argc, argv, "help") || member_args(argc, argv, "-help")) { usage_message(stderr, &opt); exit(1); } print_banner(argc, argv, PROGRAM_NAME, PROGRAM_VERSION, PROGRAM_DATE, FALSE); set_program_name(PROGRAM_NAME); /* for conditional input */ signal(SIGINT, mace4_sig_handler); signal(SIGUSR1, mace4_sig_handler); signal(SIGSEGV, mace4_sig_handler); clauses = read_mace4_input(argc, argv, prover_compatability_mode, &opt); print_separator(stdout, "CLAUSES FOR SEARCH", TRUE); fwrite_clause_list(stdout, clauses, "mace4_clauses", CL_FORM_BARE); print_separator(stdout, "end of clauses for search", TRUE); results = mace4(clauses, &opt); mace4_exit(results->return_code); /* print messages and exit */ exit(0); /* won't happen */ } /* main */
int main(int argc, char *argv[]) { int i; FILE *src_fp; int option; int option_index = 0; char *srcFileName; FILE *cloogfp, *outfp; if (argc <= 1) { usage_message(); return 1; } options = pluto_options_alloc(); const struct option pluto_options[] = { {"tile", no_argument, &options->tile, 1}, {"notile", no_argument, &options->tile, 0}, {"intratileopt", no_argument, &options->intratileopt, 1}, {"debug", no_argument, &options->debug, true}, {"moredebug", no_argument, &options->moredebug, true}, {"rar", no_argument, &options->rar, 1}, {"identity", no_argument, &options->identity, 1}, {"nofuse", no_argument, &options->fuse, NO_FUSE}, {"maxfuse", no_argument, &options->fuse, MAXIMAL_FUSE}, {"smartfuse", no_argument, &options->fuse, SMART_FUSE}, {"parallel", no_argument, &options->parallel, 1}, {"parallelize", no_argument, &options->parallel, 1}, {"innerpar", no_argument, &options->innerpar, 1}, {"unroll", no_argument, &options->unroll, 1}, {"nounroll", no_argument, &options->unroll, 0}, {"polyunroll", no_argument, &options->polyunroll, 1}, {"bee", no_argument, &options->bee, 1}, {"ufactor", required_argument, 0, 'u'}, {"prevector", no_argument, &options->prevector, 1}, {"noprevector", no_argument, &options->prevector, 0}, {"context", required_argument, 0, 'c'}, {"cloogf", required_argument, 0, 'F'}, {"cloogl", required_argument, 0, 'L'}, {"cloogsh", no_argument, &options->cloogsh, 1}, {"nocloogbacktrack", no_argument, &options->cloogbacktrack, 0}, {"forceparallel", required_argument, 0, 'p'}, {"ft", required_argument, 0, 'f'}, {"lt", required_argument, 0, 'l'}, {"multipipe", no_argument, &options->multipipe, 1}, {"l2tile", no_argument, &options->l2tile, 1}, {"version", no_argument, 0, 'v'}, {"help", no_argument, 0, 'h'}, {"indent", no_argument, 0, 'i'}, {"silent", no_argument, &options->silent, 1}, {"lastwriter", no_argument, &options->lastwriter, 1}, {"nobound", no_argument, &options->nobound, 1}, {"scalpriv", no_argument, &options->scalpriv, 1}, {"isldep", no_argument, &options->isldep, 1}, {"isldepcompact", no_argument, &options->isldepcompact, 1}, {"readscoplib", no_argument, &options->readscoplib, 1}, {"islsolve", no_argument, &options->islsolve, 1}, {0, 0, 0, 0} }; /* Read command-line options */ while (1) { option = getopt_long(argc, argv, "bhiqvf:l:F:L:c:o:", pluto_options, &option_index); if (option == -1) { break; } switch (option) { case 0: break; case 'F': options->cloogf = atoi(optarg); break; case 'L': options->cloogl = atoi(optarg); break; case 'b': options->bee = 1; break; case 'c': options->context = atoi(optarg); break; case 'd': break; case 'f': options->ft = atoi(optarg); break; case 'g': break; case 'h': usage_message(); return 2; case 'i': /* Handled in polycc */ break; case 'l': options->lt = atoi(optarg); break; case 'm': break; case 'n': break; case 'o': options->out_file = strdup(optarg); break; case 'p': options->forceparallel = atoi(optarg); break; case 'q': options->silent = 1; break; case 's': break; case 'u': options->ufactor = atoi(optarg); break; case 'v': printf("PLUTO %s - An automatic parallelizer and locality optimizer\n\ Copyright (C) 2007--2008 Uday Kumar Bondhugula\n\ This is free software; see the source for copying conditions. There is NO\n\ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n", PLUTO_VERSION); pluto_options_free(options); return 3; default: usage_message(); pluto_options_free(options); return 4; } } if (optind <= argc-1) { srcFileName = alloca(strlen(argv[optind])+1); strcpy(srcFileName, argv[optind]); }else{ /* No non-option argument was specified */ usage_message(); pluto_options_free(options); return 5; } src_fp = fopen(srcFileName, "r"); if (!src_fp) { fprintf(stderr, "pluto: error opening source file: '%s'\n", srcFileName); pluto_options_free(options); return 6; } /* Extract polyhedral representation from input program */ scoplib_scop_p scop; clan_options_p clanOptions = clan_options_malloc(); if (options->readscoplib) scop = scoplib_scop_read(src_fp); else scop = clan_scop_extract(src_fp, clanOptions); if (!scop || !scop->statement) { fprintf(stderr, "Error extracting polyhedra from source file: \'%s'\n", srcFileName); pluto_options_free(options); return 7; } FILE *srcfp = fopen(".srcfilename", "w"); if (srcfp) { fprintf(srcfp, "%s\n", srcFileName); fclose(srcfp); } /* IF_DEBUG(clan_scop_print_dot_scop(stdout, scop, clanOptions)); */ /* Convert clan scop to Pluto program */ PlutoProg *prog = scop_to_pluto_prog(scop, options); clan_options_free(clanOptions); /* Backup irregular program portion in .scop. */ char* irroption = scoplib_scop_tag_content(scop, "<irregular>", "</irregular>"); IF_DEBUG2(pluto_deps_print(stdout, prog)); IF_DEBUG2(pluto_stmts_print(stdout, prog->stmts, prog->nstmts)); int dim_sum=0; for (i=0; i<prog->nstmts; i++) { dim_sum += prog->stmts[i]->dim; } /* Make options consistent */ if (options->multipipe == 1 && options->parallel == 0) { fprintf(stdout, "Warning: multipipe needs parallel to be on; turning on parallel\n"); options->parallel = 1; } /* Disable pre-vectorization if tile is not on */ if (options->tile == 0 && options->prevector == 1) { /* If code will not be tiled, pre-vectorization does not make * sense */ if (!options->silent) { fprintf(stdout, "[Pluto] Warning: pre-vectorization does not fit (--tile is off)\n"); } options->prevector = 0; } if (!options->silent) { fprintf(stdout, "[Pluto] Number of statements: %d\n", prog->nstmts); fprintf(stdout, "[Pluto] Total number of loops: %d\n", dim_sum); fprintf(stdout, "[Pluto] Number of deps: %d\n", prog->ndeps); fprintf(stdout, "[Pluto] Maximum domain dimensionality: %d\n", prog->nvar); fprintf(stdout, "[Pluto] Number of parameters: %d\n", prog->npar); } /* Auto transformation */ if (!options->identity) { pluto_auto_transform(prog); } pluto_detect_transformation_properties(prog); if (!options->silent) { fprintf(stdout, "[Pluto] Affine transformations [<iter coeff's> <const>]\n\n"); /* Print out transformations */ pluto_transformations_pretty_print(prog); pluto_print_hyperplane_properties(prog); } if (options->tile) { pluto_tile(prog); }else{ if (options->intratileopt) { int retval = pluto_intra_tile_optimize(prog, 0); if (retval) { /* Detect properties again */ pluto_detect_transformation_properties(prog); if (!options->silent) { printf("[Pluto] after intra tile opt\n"); pluto_transformations_pretty_print(prog); } } } } if (options->parallel && !options->tile && !options->identity) { /* Obtain wavefront/pipelined parallelization by skewing if * necessary */ int nbands; Band **bands; bands = pluto_get_outermost_permutable_bands(prog, &nbands); bool retval = create_tile_schedule(prog, bands, nbands); pluto_bands_free(bands, nbands); /* If the user hasn't supplied --tile and there is only pipelined * parallelism, we will warn the user */ if (retval) { printf("[Pluto] WARNING: pipelined parallelism exists and --tile is not used.\n"); printf("use --tile for better parallelization \n"); IF_DEBUG(fprintf(stdout, "[Pluto] After skewing:\n");); IF_DEBUG(pluto_transformations_pretty_print(prog););
int _tmain(int argc, TCHAR* argv[]) { struct params_struct p; struct parsestate_struct ps; int ret; int i; int unicode_output=0; const TCHAR *optname; memset(&ps,0,sizeof(struct parsestate_struct)); ps.param_type=PT_NONE; ps.untagged_param_count=0; ps.printversion=0; ps.showhelp=0; #ifdef _UNICODE unicode_output=1; _setmode(_fileno(stdout),_O_U16TEXT); #endif #ifndef IW_NO_LOCALE setlocale(LC_CTYPE,""); unicode_output = (strcmp(nl_langinfo(CODESET), "UTF-8") == 0); #endif memset(&p,0,sizeof(struct params_struct)); p.new_width = -1; p.new_height = -1; p.depth = -1; p.edge_policy = -1; p.bkgd_check_size = 16; p.bestfit = 0; p.offset_r_h=0.0; p.offset_g_h=0.0; p.offset_b_h=0.0; p.offset_r_v=0.0; p.offset_g_v=0.0; p.offset_b_v=0.0; p.infmt=IWCMD_FMT_UNKNOWN; p.outfmt=IWCMD_FMT_UNKNOWN; p.unicode_output=unicode_output; p.resize_alg_x.blur = 1.0; p.resize_alg_y.blur = 1.0; p.resize_alg_alpha.blur = 1.0; p.pngcmprlevel = -1; for(i=1;i<argc;i++) { if(argv[i][0]=='-' && ps.param_type==PT_NONE) { optname = &argv[i][1]; // If the second char is also a '-', ignore it. if(argv[i][1]=='-') optname = &argv[i][2]; if(!process_option_name(&p, &ps, optname)) { return 1; } } else { // Process a parameter of the previous option. if(!process_option_arg(&p, &ps, argv[i])) { return 1; } ps.param_type = PT_NONE; } } if(ps.showhelp) { usage_message(&p); return 0; } if(ps.printversion) { do_printversion(&p); return 0; } if(ps.untagged_param_count!=2 || ps.param_type!=PT_NONE) { usage_message(&p); return 1; } ret=run(&p); return ret?0:1; }
/** * Make a destination name. If the destination option is not provided, * the destination is the base name of the input file. If the destination * is a directory, the base name of the source is always appended. * If the destination is a file, then make certain we only copy one file * to this destination. * * @param[in] sname source file name. * @returns the name of the corresponding output file. */ static inline char const * make_dest_name(char const * sname) { static char const no_dir[] = "no directory component in source name '%s'\n" "and no destination directory was specified.\n"; if (! HAVE_OPT(DESTINATION)) { char const * p = strrchr(sname, '/'); if (p == NULL) usage_message(no_dir, sname); unlink(++p); return strdup_or_die(p); } { static bool been_here = false; char const * dname = OPT_ARG(DESTINATION); struct stat sb; if (stat(dname, &sb) == 0) { if (S_ISDIR(sb.st_mode)) { char const * bn = strrchr(sname, '/'); char * p; bn = bn ? (bn + 1) : sname; p = malloc(strlen(dname) + strlen(bn) + 2); if (p == NULL) fserr(PCOPY_EXIT_NO_MEM, "allocating", "destination name"); sprintf(p, "%s/%s", dname, bn); unlink(p); return p; } if (S_ISREG(sb.st_mode)) { if (been_here) die(PCOPY_EXIT_BAD_CONFIG, "destination for multiple sources is one file"); been_here = true; unlink(dname); return strdup_or_die(dname); } errno = EINVAL; fserr(PCOPY_EXIT_BAD_CONFIG, "invalid destination fs type (not dir or file)", dname); } /* * We could not stat "dname". It must be a file name. Make sure any * directory part exists. If we call this routine again, we should * successfully stat our destination file and trip over the * "been_here" flag. */ dname = strdup_or_die(dname); been_here = true; { static char const bad_stat[] = "stat-ing dir portion"; char * p = strrchr(dname, '/'); if (p == NULL) { /* * No directory part. Destination file is for current dir. */ return dname; } *p = NUL; if (stat(dname, &sb) != 0) fserr(PCOPY_EXIT_BAD_CONFIG, bad_stat, OPT_ARG(DESTINATION)); if (! S_ISDIR(sb.st_mode)) { errno = ENOTDIR; fserr(PCOPY_EXIT_BAD_CONFIG, bad_stat, OPT_ARG(DESTINATION)); } *p = '/'; } return dname; } }