Robust/src/Benchmarks/oooJava/labyrinth/Labyrinth.java

   1 /* =============================================================================
   2  *
   3  * Labyrinth.java
   4  *
   5  * =============================================================================
   6  *
   7  * Copyright (C) Stanford University, 2006.  All Rights Reserved.
   8  * Author: Chi Cao Minh
   9  *
  10  * =============================================================================
  11  *
  12  * For the license of bayes/sort.h and bayes/sort.c, please see the header
  13  * of the files.
  14  *
  15  * ------------------------------------------------------------------------
  16  *
  17  * For the license of kmeans, please see kmeans/LICENSE.kmeans
  18  *
  19  * ------------------------------------------------------------------------
  20  *
  21  * For the license of ssca2, please see ssca2/COPYRIGHT
  22  *
  23  * ------------------------------------------------------------------------
  24  *
  25  * For the license of lib/mt19937ar.c and lib/mt19937ar.h, please see the
  26  * header of the files.
  27  *
  28  * ------------------------------------------------------------------------
  29  *
  30  * For the license of lib/rbtree.h and lib/rbtree.c, please see
  31  * lib/LEGALNOTICE.rbtree and lib/LICENSE.rbtree
  32  *
  33  * ------------------------------------------------------------------------
  34  *
  35  * Unless otherwise noted, the following license applies to STAMP files:
  36  *
  37  * Copyright (c) 2007, Stanford University
  38  * All rights reserved.
  39  *
  40  * Redistribution and use in source and binary forms, with or without
  41  * modification, are permitted provided that the following conditions are
  42  * met:
  43  *
  44  *     * Redistributions of source code must retain the above copyright
  45  *       notice, this list of conditions and the following disclaimer.
  46  *
  47  *     * Redistributions in binary form must reproduce the above copyright
  48  *       notice, this list of conditions and the following disclaimer in
  49  *       the documentation and/or other materials provided with the
  50  *       distribution.
  51  *
  52  *     * Neither the name of Stanford University nor the names of its
  53  *       contributors may be used to endorse or promote products derived
  54  *       from this software without specific prior written permission.
  55  *
  56  * THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY
  57  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  58  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  59  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE
  60  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  61  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  62  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  63  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  64  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  65  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  66  * THE POSSIBILITY OF SUCH DAMAGE.
  67  *
  68  * =============================================================================
  69  */
  70
  71 public class Labyrinth
  72 {
  73     static String global_inputFile;
  74     static boolean global_doPrint;
  75     int numThread;
  76     int bendCost;
  77     int xCost;
  78     int yCost;
  79     int zCost;
  80
  81
  82     // For threads
  83     int threadID;
  84     Solve_Arg routerArg;
  85
  86     //For rblocks
  87     int global_workload;
  88
  89     private void setDefaultParams() {
  90
  91         /* default values */
  92         global_inputFile = null;
  93         global_doPrint = false;
  94         bendCost = 1;
  95         xCost = 1;
  96         yCost = 1;
  97         zCost = 2;
  98         numThread = 1;
  99
 100         global_workload = 100;
 101     }
 102
 103     private void parseArg(String[] argv) {
 104         int i=0;
 105         String arg;
 106         boolean opterr = false;
 107
 108
 109         setDefaultParams();
 110
 111         while (i < argv.length) {
 112
 113             if(argv[i].charAt(0) == '-' ) {
 114                 arg = argv[i++];
 115                 // check options
 116                 if(arg.equals("-b")) {
 117                     bendCost = Integer.parseInt(argv[i++]);
 118                 }
 119                 else if(arg.equals("-x")) {
 120                     xCost = Integer.parseInt(argv[i++]);
 121                     }
 122                 else if(arg.equals("-y")) {
 123                     yCost = Integer.parseInt(argv[i++]);
 124                     }
 125                 else if(arg.equals("-z")) {
 126                     zCost = Integer.parseInt(argv[i++]);
 127                     }
 128                 else if(arg.equals("-t")) {
 129                         numThread = Integer.parseInt(argv[i++]);
 130                 }
 131                 else if(arg.equals("-i")) {
 132                     global_inputFile = argv[i++];
 133                     }
 134                 else if(arg.equals("-p")) {
 135                         global_doPrint = true;
 136                 }
 137                 else if(arg.equals("-w")){
 138                         global_workload = Integer.parseInt(argv[i++]);
 139                 }
 140                 else {
 141                     System.out.println("Non-option argument: " + argv[i]);
 142                     opterr = true;
 143                 }
 144
 145             }
 146         }
 147         if(opterr) {
 148             displayUsage();
 149             System.exit(1);
 150         }
 151     }
 152
 153     public Labyrinth(String[] argv)
 154     {
 155         parseArg(argv);
 156     }
 157
 158
 159     public Labyrinth(int myID,Solve_Arg rArg)
 160     {
 161         threadID = myID;
 162         routerArg = rArg;
 163     }
 164
 165     public void displayUsage()
 166     {
 167         System.out.println("Usage: Labyrinth [options]");
 168         System.out.println("Options:");
 169         System.out.println("    b <INT>     bend cost");
 170         System.out.println("    i <FILE>    input file name");
 171         System.out.println("    p           print routed maze");
 172         System.out.println("    t <INT>     Number of threads");
 173         System.out.println("    x <INT>     x movement cost");
 174         System.out.println("    y <INT>     y movement cost");
 175         System.out.println("    z <INT>     z movement cost");
 176         System.out.println("    w <INT>     Workload per rBlock");
 177     }
 178
 179
 180     public static void main(String[] argv)
 181     {
 182         /*
 183          * Initailization
 184          */
 185         Maze maze = new Maze();
 186         Router router = new Router();
 187         Labyrinth labyrinth = new Labyrinth(argv);
 188
 189         Maze mazePtr = maze.alloc();
 190
 191         int numPathToRoute =  mazePtr.readMaze(labyrinth.global_inputFile);
 192
 193         Router routerPtr = router.alloc(labyrinth.xCost,labyrinth.yCost,
 194                                         labyrinth.zCost,labyrinth.bendCost);
 195
 196         List_t list_t = new List_t();
 197         List_t pathVectorListPtr = list_t.alloc(0);     // list_t.alloc(null)
 198         Solve_Arg routerArg = new Solve_Arg(routerPtr,mazePtr,pathVectorListPtr, labyrinth.global_workload);
 199
 200         /* Create and start thread */
 201         long start = System.currentTimeMillis();
 202         routerPtr.solve(routerArg);
 203
 204         /* End of Solve */
 205         long finish = System.currentTimeMillis();
 206         long diff=finish-start;
 207         System.out.println("TIME= " + diff);
 208
 209
 210         int numPathRouted = 0;
 211         List_Iter it = new List_Iter();
 212
 213         it.reset(pathVectorListPtr);
 214         while(it.hasNext(pathVectorListPtr)) {
 215                 Vector_t pathVectorPtr = (Vector_t)it.next(pathVectorListPtr);
 216                 numPathRouted += pathVectorPtr.vector_getSize();
 217         }
 218
 219         double elapsed = (finish-start)/1000.0;
 220
 221         System.out.println("Paths routed    = " + numPathRouted);
 222         System.out.println("Elapsed time    = " + elapsed);
 223
 224         boolean stats = mazePtr.checkPaths(pathVectorListPtr,labyrinth.global_doPrint);
 225         if(!stats)
 226             System.out.println("Verification not passed");
 227         else
 228             System.out.println("Verification passed.");
 229
 230         System.out.println("Finished");
 231     }
 232 }
 233
 234 /* =============================================================================
 235  *
 236  * End of labyrinth.c
 237  *
 238  * =============================================================================
 239  */