tests/jvm98/mpegaudio.diff

   1 diff -Nu mpegaudio1/Context.java mpegaudio/Context.java
   2 --- mpegaudio1/Context.java     Thu Jan  1 01:00:00 1970
   3 +++ mpegaudio/Context.java      Tue Nov 26 11:35:40 2002
   4 @@ -0,0 +1,444 @@
   5 +/*
   6 + * @(#)Context.java    1.31 06/17/98
   7 + *
   8 + * Copyright (c) 1998 Standard Performance Evaluation Corporation (SPEC)
   9 + *               All rights reserved.
  10 + * Copyright (c) 1997,1998 Sun Microsystems, Inc. All rights reserved.
  11 + *
  12 + * This source code is provided as is, without any express or implied warranty.
  13 + */
  14 +
  15 +package spec.harness;
  16 +
  17 +/**
  18 + * This class is used to define the context for the execution of the
  19 + * benchmark. This container class has the parameters which can hold
  20 + * the benchmark run specific parameters like the run time, speed,
  21 + * files opened, number of cached_files, SpecBasePath, console window
  22 + * for displaying the trace
  23 + */
  24 +
  25 +
  26 +public final class Context{
  27 +
  28 +/**
  29 + * SpecBasePath is used to define the base directory of the specJava
  30 + * @see java.lang.String
  31 + */
  32 +  private static String SpecBasePath = "";
  33 +
  34 +/**
  35 + * NetworkAccess flag is used to define whether the benchmark uses
  36 + * the network or not
  37 + */
  38 +  static boolean NetworkAccess = false;
  39 +
  40 +/**
  41 + * BasePath
  42 + * @see java.lang.String
  43 + */
  44 +  static String BasePath = "";
  45 +
  46 +/**
  47 + * speed is used to define the benchmark run length. The benchmarks
  48 + * can be run at 1%, 10% and 100% of their full length of execution.
  49 + * Some times the % variation is reflected by just altering the loop
  50 + * count in the benchmark (ie repeatedly executing the same benchmark)
  51 + */
  52 +  static int speed = 100;
  53 +
  54 +/**
  55 + * CachedInput is flag used to indicate, whether the classes have to
  56 + * be cached or not. When the benchmark is run by the harness. The
  57 + * classes are fetched over the net during the first run. The execution
  58 + * time in this case includes the network load time. Depending on the
  59 + * user selection this flag will be toggled and used to cache the
  60 + * classes loaded first time. The second run uses these cached
  61 + * classes if flag is turned on.
  62 + */
  63 +  static boolean CachedInput = true;
  64 +
  65 +/**
  66 + * IOtime is gives the cumilative io time of the all the io calls in
  67 + * in the execution of the benchmark. The refference time is taken
  68 + * before entering the io routine and the refference time is taken at
  69 + * the time of exiting from the routine. The difference between them
  70 + * gives the time sepent in that routine. All such times are
  71 + * accumilated to give the overall io time in the benchmark execution.
  72 + * see @java.lang.System#getSystemTime
  73 + */
  74 +  static boolean batch = false;
  75 +
  76 +/**
  77 + * This flag is used to turn on/off the graphicsMode. Some of the tests
  78 + * have the graphics in them. The graphics are conditionally enabled or
  79 + * disabled depending on the final version of SpecJava
  80 + */
  81 +  static boolean graphicsMode = false;
  82 +
  83 +/**
  84 + * The parameter is used to for storing the IOtime of the current benchmark
  85 + * under execution.
  86 + */
  87 +  static long IOtime = 0;
  88 +
  89 +/**
  90 + * num_files_open is an integer variable to hold the number of files
  91 + * opened during the benchmark run.
  92 + */
  93 +  static int num_files_open = 0;
  94 +
  95 +/**
  96 + * cached_data is an integer variable to hold the number of bytes of
  97 + * data that is cached. This can be more than zero for the first run
  98 + * but this has to be zero for the subsequent runs.
  99 + */
 100 +  static int cached_data = 0;
 101 +
 102 +/**
 103 + * num_cached_files is an integer variable to hold the number of files
 104 + * cached during the run of the benchmark.
 105 + */
 106 +  static int num_cached_files = 0;
 107 +
 108 +/**
 109 + * userPropFile is the string used to hold the user profile file name
 110 + * The user profile file has the user specific data, which can also be
 111 + * modified by using the setup key. The Setup parameters are initialized
 112 + * with the data from the user profile file
 113 + */
 114 +  static String userPropFile;
 115 +
 116 +/**
 117 + * verify flag is used to turn on/off the verification process of benchmark
 118 + * runs.
 119 + */
 120 +  static boolean verify = true;
 121 +
 122 +/**
 123 + * commandLineMode is a flag that holds the value which indicate whether the
 124 + * benchmark is running in command line mode or as an applet.
 125 + */
 126 +  static boolean commandLineMode = false;
 127 +
 128 +/**
 129 + * window is the ConsoleWindow object type where the trace of the
 130 + * benchmark execution is displayed.
 131 + * @see spec.harness.ConsoleWindow
 132 + */
 133 +
 134 +/**
 135 + * out is the PrintStream into which the trace messages will be written.
 136 + * This is assigned to the System.output stream by default
 137 + */
 138 +  public static java.io.PrintStream out = System.out;
 139 +
 140 +/**
 141 + * This function returns the integer value given the String form
 142 + * of it. In case of any number format exception, the function returns
 143 + * default value.
 144 + * @param s String value passed
 145 + * @param deft the default value to be returned.
 146 + */
 147 +  public static int getValue(String s, int deft) {
 148 +
 149 +      try {
 150 +         return Integer.parseInt(s, 10);
 151 +      } catch(NumberFormatException x) {}
 152 +
 153 +      return deft;
 154 +  }
 155 +
 156 +/**
 157 + * This function creates the new Console window and the print stream
 158 + * @see spec.harness.ConsoleWindow
 159 + */
 160 +  public static void setupConsoleWindow(){
 161 +  }
 162 +
 163 +/**
 164 + * This function set the  SpecBasePath to the string value passed with
 165 + * some data stripped.
 166 + * @param basePath The URL of the file
 167 + */
 168 +  public static void setSpecBasePath(String basepath){
 169 +    if (basepath.indexOf("file:" , 0) == 0){
 170 +       SpecBasePath = basepath.substring(5);
 171 +    }
 172 +    else{
 173 +        SpecBasePath = basepath;
 174 +    }
 175 +
 176 +    if (SpecBasePath.indexOf("http:" , 0) == 0){
 177 +       NetworkAccess = true;
 178 +    } else {
 179 +       while (SpecBasePath.charAt(0) == '/' && SpecBasePath.charAt(1) == '/') {
 180 +           SpecBasePath = SpecBasePath.substring(1);
 181 +       }
 182 +    }
 183 +  }
 184 +
 185 +/**
 186 +  returns the specbase path
 187 + */
 188 +  public static String getSpecBasePath(){
 189 +       return SpecBasePath;
 190 +  }
 191 +
 192 +/**
 193 + * Increments the the cached_data parameter by the integer passed.
 194 + * @param num increment value
 195 + */
 196 +  public static void addCachedDataSize(int num){
 197 +    cached_data += num;
 198 +  }
 199 +
 200 +/**
 201 + * gets the cached data size.
 202 + * @return The cached_data value
 203 + */
 204 +  public static int getCachedDataSize(){
 205 +    return cached_data;
 206 +  }
 207 +
 208 +/**
 209 + * Increments the the num_cached_files parameter by 1.
 210 + */
 211 +  public static void IncrementNumCachedFiles(){
 212 +    num_cached_files++;
 213 +  }
 214 +
 215 +/**
 216 + * gets the numbef of cached files.
 217 + * @return The num_cached_files value
 218 + */
 219 +  public static int getNumCachedFiles(){
 220 +    return num_cached_files;
 221 +  }
 222 +
 223 +/**
 224 + * Increments the number of Files open parameter. The number of files
 225 + * open parameter is used for debugging purposes to findout whether the
 226 + * finalizers are called or not
 227 + */
 228 +  public static void IncrementNumOpenFiles(){
 229 +    num_files_open++;
 230 +  }
 231 +
 232 +/**
 233 + Decrements the number of Files open parameter
 234 + */
 235 +  public static void DecrementNumOpenFiles(){
 236 +    num_files_open--;
 237 +  }
 238 +
 239 +/**
 240 + returns the number of files open
 241 + */
 242 +  public static int getNumOpenFiles(){
 243 +    return num_files_open;
 244 +  }
 245 +
 246 +/**
 247 + *  sets the benchmark relative path. For example if  SpecBasepath is
 248 + * /var/htdocs/v11/spec, The relative benchmark path path for
 249 + * _201_compress is benchmarks/_201_compress. This function adds these
 250 + * two strings and forms the BasePath
 251 + * BasePath = /var/htdocs/v11/spec + benchmarks/_201_compress
 252 + * @param rpath Relative path of the benchmark
 253 + */
 254 +  public static void setBenchmarkRelPath(String rpath){
 255 +    BasePath = SpecBasePath + rpath;
 256 +  }
 257 +
 258 +
 259 +/**
 260 + * This function changes the basepath to point to the input directory
 261 + * of the benchmark. this function just concatinates the "/input"
 262 + * to the existing basepath if it is not added already.
 263 + */
 264 +  public static void cdInput(){
 265 +    if( !BasePath.endsWith( "input/" )) {
 266 +       BasePath = BasePath + "input/" ;
 267 +    }
 268 +  }
 269 +
 270 +/**
 271 + * Sets the network access flag
 272 + * @param flag Flag indicating the network access
 273 + */
 274 +  public static void setNetworkAccess(boolean flag){
 275 +
 276 +    NetworkAccess = flag;
 277 +  }
 278 +
 279 +/**
 280 + Returns the spec base path. This function is handly in loading the files
 281 + from the relative directories.
 282 + */
 283 +  public static String getBasePath(){
 284 +
 285 +    return BasePath;
 286 +  }
 287 +
 288 +/**
 289 + Indicates whether SpecJVMClient is running as an applet or application
 290 + */
 291 +  public static boolean isNetworkAccess(){
 292 +
 293 +    return NetworkAccess;
 294 +
 295 +  }
 296 +
 297 +/**
 298 + * Sets the speed of execution to the value passed. Depending on the
 299 + * user's selection, the speed of execution is set as 1% 10% or 100%
 300 + * @param n Speed selected by the user
 301 + */
 302 +  public static void setSpeed( int n ) {
 303 +    speed = n;
 304 +  }
 305 +
 306 +/**
 307 + Returns the speed of the benchmark.
 308 + */
 309 +  public static int getSpeed() {
 310 +    return speed;
 311 +  }
 312 +
 313 +/**
 314 + Sets the CachedInput flag. The data is read from the Cache during the second
 315 + run if this flag is set.\7f
 316 + */
 317 +  public static void setCachedInputFlag( boolean cif ){
 318 +    CachedInput = cif;
 319 +  }
 320 +
 321 +/**
 322 + Sets the batch flag
 323 + @param b boolean value for the batch flag
 324 + */
 325 +  public static void setBatch( boolean b ){
 326 +    batch = b;
 327 +  }
 328 +
 329 +/**
 330 + Returns whether SpecJVMClient is running in batch mode
 331 + */
 332 +  public static boolean isBatch(){
 333 +    return batch;
 334 +  }
 335 +
 336 +/**
 337 + Sets the graphics mode. Normally SepcJVM client runs with graphics disabled.
 338 + This flag is for future extensions and debugging
 339 + */
 340 +  public static void setGraphicsMode (boolean mode){
 341 +    graphicsMode = mode;
 342 +  }
 343 +
 344 +/**
 345 + Returns the graphic mode flag value
 346 + */
 347 +  public static boolean getGraphicsMode(){
 348 +    return graphicsMode;
 349 +  }
 350 +
 351 +/**
 352 + Sets the user properties file. These properties are stored in the mail sent at
 353 + the end of the test
 354 + @param s Properties file name
 355 + */
 356 +  public static void setUserPropFile( String s){
 357 +    userPropFile = s;
 358 +  }
 359 +
 360 +/**
 361 + Returns the properties file name
 362 + */
 363 +  public static String getUserPropFile(){
 364 +    return userPropFile;
 365 +  }
 366 +
 367 +/**
 368 + Returns the cached input flag
 369 + */
 370 +  public static boolean isCachedInput(){
 371 +    return CachedInput;
 372 +  }
 373 +
 374 +/**
 375 + Clears the IOtiming. This is normally done before starting a benchmark
 376 + */
 377 +  public static void clearIOtime(){
 378 +    IOtime = 0;
 379 +  }
 380 +
 381 +/**
 382 + Increments the IOTime by the value provided
 383 + @param time Incremental value
 384 + */
 385 +  public static void addIOtime(long time){
 386 +    IOtime = IOtime + time;
 387 +  }
 388 +
 389 +/**
 390 + Returns the IO time
 391 + */
 392 +  public static long getIOtime(){
 393 +    return IOtime;
 394 +  }
 395 +
 396 +    /**
 397 +     * Set commandLineMode flag
 398 +     */
 399 +    public static void setCommandLineMode(boolean value) {
 400 +       commandLineMode = value;
 401 +    }
 402 +
 403 +
 404 +    /**
 405 +     * Get commandLineMode flag
 406 +     */
 407 +    public static boolean getCommandLineMode() {
 408 +       return commandLineMode;
 409 +    }
 410 +
 411 +
 412 +    /**
 413 +     * Set verify flag
 414 +     */
 415 +    public static void setVerify(boolean value) {
 416 +       verify = value;
 417 +    }
 418 +
 419 +
 420 +    /**
 421 +     * Get verify flag
 422 +     */
 423 +    public static boolean getVerify() {
 424 +       return verify;
 425 +    }
 426 +
 427 +
 428 +    /**
 429 +     * Start output window
 430 +     */
 431 +    public static void startOutputWindow() {
 432 +    }
 433 +
 434 +
 435 +    /**
 436 +     * Stop output window
 437 +     */
 438 +    public static void stopOutputWindow() {
 439 +    }
 440 +
 441 +    /**
 442 +     * Output to console window
 443 +     */
 444 +    public static void appendWindow(String s) {
 445 +           System.out.print(s);
 446 +    }
 447 +}
 448 +
 449 diff -Nu mpegaudio1/File.java mpegaudio/File.java
 450 --- mpegaudio1/File.java        Thu Jan  1 01:00:00 1970
 451 +++ mpegaudio/File.java Tue Nov 26 11:02:12 2002
 452 @@ -0,0 +1,356 @@
 453 +/*
 454 + * @(#)File.java       1.5 06/17/98
 455 + *
 456 + * Copyright (c) 1998 Standard Performance Evaluation Corporation (SPEC)
 457 + *               All rights reserved.
 458 + * Copyright (c) 1997,1998 Sun Microsystems, Inc. All rights reserved.
 459 + *
 460 + * This source code is provided as is, without any express or implied warranty.
 461 + */
 462 +
 463 +package spec.io;
 464 +
 465 +/**
 466 + This class extends the java.io.File and provides some extra functionality.
 467 + File object maintains a static table of files called the Table of existing
 468 + files. The files listed in the TableOfExisting files are loaded from the
 469 + local disk. All the other files are loaded over the network.
 470 +*/
 471 +public class File extends java.io.File{
 472 +
 473 +/**
 474 + Variable representing the file name
 475 + */
 476 +
 477 +  String filename;
 478 +
 479 +/**
 480 + Table to hold the ListOfExisting files
 481 + */
 482 +  private static TableOfExistingFiles tef = new TableOfExistingFiles();
 483 +
 484 +/**
 485 + Constructor.
 486 + @param Path of the file (includes the file name also)
 487 + */
 488 +  public File(String path){
 489 +
 490 +    super(path);
 491 +
 492 +    //System.out.println("Inside constructor File(" + path + ")");
 493 +
 494 +    filename = path;
 495 +
 496 +  }
 497 +
 498 +/**
 499 + Overloaded constructor which takes the path and the files name to load the
 500 + file
 501 + @param path Directory of the file
 502 + @param name file name
 503 + */
 504 +  public File(String path , String name){
 505 +
 506 +    super(path , name);
 507 +
 508 +    //System.out.println("Inside constructor File(" + path + " , " + name + ")");
 509 +
 510 +    filename = path + name;
 511 +
 512 +  }
 513 +
 514 +/**
 515 + Overloaded constructor which takes the directory in the File object format
 516 + and a name of the file.
 517 + @param dir Directory of the file in the File object format
 518 + @param name file name
 519 + */
 520 +  public File(File dir , String name){
 521 +
 522 +    super(dir , name);
 523 +
 524 +    //System.out.println("Inside constructor File(dir, name) , dir.getName = " + dir.getName());
 525 +
 526 +    filename = dir.getPath() + name;
 527 +
 528 +  }
 529 +
 530 +/**
 531 + returns the name of the file
 532 + @return name of file
 533 + */
 534 +  public String getName(){
 535 +
 536 +    String returnvalue = super.getName();
 537 +
 538 +    //System.out.println("Inside File.getName() , \nfilename = " + filename + "\nreturnvalue = " +returnvalue);
 539 +
 540 +
 541 +    return returnvalue;
 542 +
 543 +  }
 544 +
 545 +/**
 546 + returns the path of the file
 547 + */
 548 +  public String getPath(){
 549 +
 550 +    String returnvalue = super.getPath();
 551 +
 552 +    //System.out.println("Inside File.getPath() ,  filename = " + filename + " returnvalue = " +returnvalue);
 553 +
 554 +    return returnvalue;
 555 +
 556 +  }
 557 +
 558 +/**
 559 + returns tha absolutePath of the file Dir + name
 560 + */
 561 +  public String getAbsolutePath(){
 562 +
 563 +    String returnvalue = super.getAbsolutePath();
 564 +
 565 +    //System.out.println("Inside File.getAbsolutePath() ,  filename = " + filename + " returnvalue = " + returnvalue);
 566 +
 567 +    return returnvalue;
 568 +
 569 +  }
 570 +
 571 +/**
 572 + returns the Parent directory name
 573 + */
 574 +
 575 +  public String getParent(){
 576 +
 577 +    String returnvalue = super.getParent();
 578 +
 579 +    //String returnvalue = null;
 580 +
 581 +    //System.out.println("Inside File.getParent() ,  filename = " + filename + " returnvalue = " + returnvalue);
 582 +
 583 +    return returnvalue;
 584 +
 585 +  }
 586 +
 587 +/**
 588 + Checks whether the given file name exists or not
 589 + */
 590 +  public boolean exists(){
 591 +
 592 +    //boolean returnvalue = super.exists();
 593 +
 594 +    boolean returnvalue = tef.exists( filename.replace( '\\', '/' ) );
 595 +
 596 +    //System.out.println("Inside File.exists() ,  filename = " + filename + " returnvalue = " + returnvalue);
 597 +
 598 +    return returnvalue;
 599 +
 600 +  }
 601 +
 602 +/**
 603 + Checks whether the given file is writablle or not
 604 + */
 605 +  public boolean canWrite(){
 606 +
 607 +    boolean returnvalue = super.canWrite();
 608 +
 609 +    //System.out.println("Inside File.canWrite() ,  filename = " + filename + " returnvalue = " + returnvalue);
 610 +
 611 +    return returnvalue;
 612 +
 613 +  }
 614 +
 615 +/**
 616 + Checks whether the given file is readable
 617 + */
 618 +  public boolean canRead(){
 619 +
 620 +    boolean returnvalue = super.canRead();
 621 +
 622 +    //System.out.println("Inside File.canRead() ,  filename = " + filename + " returnvalue = " + returnvalue);
 623 +
 624 +    return returnvalue;
 625 +
 626 +  }
 627 +
 628 +/**
 629 + Checks whether the given file name is a file or directory
 630 + The functionality is modified to return whether the file name is classes.zip
 631 + or not
 632 + */
 633 +  public boolean isFile(){
 634 +
 635 +    //boolean returnvalue = super.isFile();
 636 +
 637 +    boolean returnvalue = filename.endsWith("classes.zip");
 638 +
 639 +    //System.out.println("Inside File.isFile() ,  filename = " + filename + " returnvalue = " + returnvalue);
 640 +
 641 +    return returnvalue;
 642 +
 643 +  }
 644 +
 645 +/**
 646 + Checks whether the given file name is directory or not
 647 + */
 648 +  public boolean isDirectory(){
 649 +
 650 +    boolean returnvalue = super.isDirectory();
 651 +
 652 +    //System.out.println("Inside File.isDirectory() ,  filename = " + filename + " returnvalue = " + returnvalue);
 653 +
 654 +    return returnvalue;
 655 +
 656 +  }
 657 +
 658 +/**
 659 + Returns the date of last modification
 660 + */
 661 +  public long lastModified(){
 662 +
 663 +    long returnvalue = super.lastModified();
 664 +
 665 +    //System.out.println("Inside File.lastModified() ,  filename = " + filename + " returnvalue = " + returnvalue);
 666 +
 667 +    return returnvalue;
 668 +
 669 +  }
 670 +
 671 +/**
 672 + Returns the length of the file
 673 + */
 674 +  public long length(){
 675 +
 676 +    long returnvalue = super.length();
 677 +
 678 +    //System.out.println("Inside File.length() ,  filename = " + filename + " returnvalue = " + returnvalue);
 679 +
 680 +    return returnvalue;
 681 +
 682 +  }
 683 +
 684 +/**
 685 + Creates a new directory
 686 + */
 687 +  public boolean mkdir(){
 688 +
 689 +    boolean returnvalue = super.mkdir();
 690 +
 691 +    //System.out.println("Inside File.mkdir() ,  filename = " + filename + " returnvalue = " + returnvalue);
 692 +
 693 +    return returnvalue;
 694 +
 695 +  }
 696 +
 697 +/**
 698 + Renames the file
 699 + */
 700 +  public boolean renameTo(File dest){
 701 +
 702 +    boolean returnvalue = super.renameTo(dest);
 703 +
 704 +    //System.out.println("Inside File.renameTo() ,  filename = " + filename +  " returnvalue = " + returnvalue);
 705 +
 706 +    return returnvalue;
 707 +
 708 +  }
 709 +
 710 +/**
 711 +  Creates a directory whose pathname is specified by this File object,
 712 +  including any necessary parent directories.
 713 + */
 714 +  public boolean mkdirs() {
 715 +
 716 +    boolean returnvalue = super.mkdirs();
 717 +
 718 +    //System.out.println("Inside File.mkdirs() ,  filename = " + filename +  " returnvalue = " + returnvalue);
 719 +
 720 +    return returnvalue;
 721 +
 722 +  }
 723 +
 724 +/**
 725 + Returns a list of the files in the directory specified by this File object
 726 +*/
 727 +  public String[] list(){
 728 +
 729 +    String[] returnvalue = super.list();
 730 +
 731 +    //System.out.println("Inside File.list() ,  filename = " + filename +  " returnvalue = " + returnvalue);
 732 +
 733 +    return returnvalue;
 734 +
 735 +  }
 736 +
 737 +/**
 738 + Returns a list of the files in the directory specified by this File that
 739 + satisfy the specified filter.
 740 +*/
 741 +  public String[] list(java.io.FilenameFilter filter){
 742 +
 743 +    String[] returnvalue = super.list(filter);
 744 +
 745 +    //System.out.println("Inside File.list(filter) ,  filename = " + filename +  " returnvalue = " + returnvalue);
 746 +
 747 +    return returnvalue;
 748 +
 749 +  }
 750 +
 751 +/**
 752 + Deletes the file specified by this object.
 753 + */
 754 +  public boolean delete(){
 755 +
 756 +    boolean returnvalue = super.delete();
 757 +
 758 +    //System.out.println("Inside File.delete() ,  filename = " + filename +  " returnvalue = " + returnvalue);
 759 +
 760 +    return returnvalue;
 761 +
 762 +  }
 763 +
 764 +/**
 765 + Computes a hashcode for the file.
 766 + */
 767 +  public int hashCode(){
 768 +
 769 +    int returnvalue = super.hashCode();
 770 +
 771 +    //System.out.println("Inside File.hashcode() ,  filename = " + filename +    " returnvalue = " + returnvalue);
 772 +
 773 +    return returnvalue;
 774 +
 775 +  }
 776 +
 777 +/**
 778 + Compares this object against the specified object.
 779 + */
 780 +  public boolean equals(Object obj){
 781 +
 782 +    boolean returnvalue = super.equals(obj);
 783 +
 784 +    //System.out.println("Inside File.equals() ,  filename = " + filename +  " returnvalue = " + returnvalue);
 785 +
 786 +    return returnvalue;
 787 +  }
 788 +
 789 +/**
 790 + Returns a string representation of this object.
 791 +*/
 792 +  public String toString(){
 793 +
 794 +    String returnvalue = super.toString();
 795 +
 796 +    //System.out.println("Inside File.toString() ,  filename = " + filename +  " returnvalue = " + returnvalue);
 797 +
 798 +    return returnvalue;
 799 +
 800 +  }
 801 +
 802 +}
 803 +
 804 +
 805 +
 806 +
 807 +
 808 +
 809 diff -Nu mpegaudio1/FileCacheData.java mpegaudio/FileCacheData.java
 810 --- mpegaudio1/FileCacheData.java       Thu Jan  1 01:00:00 1970
 811 +++ mpegaudio/FileCacheData.java        Tue Nov 26 11:01:41 2002
 812 @@ -0,0 +1,105 @@
 813 +/*
 814 + * @(#)FileCacheData.java      1.3 06/17/98
 815 + *
 816 + * Copyright (c) 1998 Standard Performance Evaluation Corporation (SPEC)
 817 + *               All rights reserved.
 818 + * Copyright (c) 1997,1998 Sun Microsystems, Inc. All rights reserved.
 819 + *
 820 + * This source code is provided as is, without any express or implied warranty.
 821 + */
 822 +
 823 +package spec.io;
 824 +
 825 +import java.util.*;
 826 +
 827 +/**
 828 + SpecJVMClient maintains the internal cache. The data is read over the network
 829 + for the first run and it is cached. The cached data is used for subsequent runs
 830 + The FileInputStream object contains a FileCacheData object which caches data
 831 + @see spec.io.FileInputStream
 832 +  */
 833 +public class FileCacheData{
 834 +
 835 +/**
 836 + Data buffer to cache data
 837 + */
 838 +  private byte[] data = null;
 839 +
 840 +/**
 841 + Total number of bytes present in the data buffer at anytime
 842 + */
 843 +  private int total_num_bytes = 0;
 844 +
 845 +/**
 846 + Constructor
 847 + @param len Length of the file. The byte array of 'len' size is created
 848 + */
 849 +  public FileCacheData(int len){
 850 +
 851 +    data = new byte[len];
 852 +
 853 +  }
 854 +
 855 +/**
 856 + Creates the byte array to hold the file data. The size of the file is passed
 857 + as argument.
 858 + @param len Length of the file
 859 + */
 860 +  public void createData(int len){
 861 +
 862 +    data = new byte[len];
 863 +
 864 +  }
 865 +
 866 +/**
 867 + Copies the given specified of bytes from the given buffer from given offset
 868 + to the data buffer of the FileCacheData object
 869 + @param b[] 'from' byte array
 870 + @param off Offset within the byte array
 871 + @param num_bytes Number of bytes to be copied
 872 + */
 873 +  public void copyData(byte b[] , int off , int num_bytes){
 874 +
 875 +    System.arraycopy(b,off,data,total_num_bytes, num_bytes);
 876 +    total_num_bytes += num_bytes;
 877 +
 878 +  }
 879 +
 880 +/**
 881 + Copies the byte to the data buffer. Increments the number of bytes field
 882 + @param b byte to be copied
 883 + */
 884 +  public void copyData(byte b){
 885 +
 886 +    data[total_num_bytes] = b;
 887 +    total_num_bytes += 1;
 888 +
 889 +  }
 890 +
 891 +/**
 892 + Skips a portion of buffer
 893 + */
 894 +  public void skipPos(long n){
 895 +    total_num_bytes += n;
 896 +  }
 897 +
 898 + /**
 899 +  Converts the data buffer array to InputStream
 900 +  */
 901 +  public java.io.InputStream getInputStream(){
 902 +
 903 +    return new java.io.ByteArrayInputStream(data , 0 , total_num_bytes);
 904 +
 905 +  }
 906 +
 907 +/**
 908 + Returns the length of the buffer.
 909 + */
 910 +  public int getLength(){
 911 +    return total_num_bytes;
 912 +  }
 913 +
 914 +}
 915 +
 916 +
 917 +
 918 diff -Nu mpegaudio1/FileInputStream.java mpegaudio/FileInputStream.java
 919 --- mpegaudio1/FileInputStream.java     Thu Jan  1 01:00:00 1970
 920 +++ mpegaudio/FileInputStream.java      Tue Nov 26 11:28:57 2002
 921 @@ -0,0 +1,893 @@
 922 +/*
 923 + * @(#)FileInputStream.java    1.33 06/17/98
 924 + *
 925 + * Copyright (c) 1998 Standard Performance Evaluation Corporation (SPEC)
 926 + *               All rights reserved.
 927 + * Copyright (c) 1997,1998 Sun Microsystems, Inc. All rights reserved.
 928 + *
 929 + * This source code is provided as is, without any express or implied warranty.
 930 + */
 931 +
 932 +package spec.io;
 933 +
 934 +import java.util.*;
 935 +import java.net.*;
 936 +//import spec.harness.*;
 937 +
 938 +
 939 +/**
 940 + This class extends the java.io.InputStream and provides some extra functionality
 941 + for caching the data. It also keeps a count of the number of filestreams
 942 + opened by the SpecJVMClient, number of files read, number of bytes read,
 943 + io times spent
 944 + @see java.io.InputStream
 945 + @see spec.io.FileCacheData
 946 + */
 947 +public class FileInputStream extends java.io.InputStream{
 948 +
 949 +
 950 +
 951 +  //************************* Static variables****************************//
 952 +  // Constants
 953 +  private static final int LENGTH_ERROR = -1;
 954 +
 955 +  // Cache variables
 956 +
 957 +/**
 958 + Maintains a list of cached files
 959 + */
 960 +  private static Hashtable filecache = new Hashtable();
 961 +
 962 +/**
 963 + Maintains a list of opened InputStreams
 964 + */
 965 +  private static Vector openedInputStreams = new Vector();
 966 +
 967 +/**
 968 + Enables or disables the Debug mode of operation
 969 + */
 970 +  public  static boolean debug = false;
 971 +  public  static boolean testing = false;
 972 +
 973 +/**
 974 + Keeps a count of closed filestreams
 975 + */
 976 +  public  static int numofCloses = 0;
 977 +
 978 +  // How and whether to retry http operations
 979 +/**
 980 + Number of retries before declaring the error in opening the file
 981 + */
 982 +  private static int nRetry = 5;               // times to try
 983 +
 984 +/**
 985 + Sleep time between two successive retries
 986 + */
 987 +  private static int retryDelay = 5000;                // milliseconds
 988 +
 989 +/**
 990 + Total retries made throughout the benchmark suit
 991 + */
 992 +  private static int totalRetries = 0;         // count over all benchmarks
 993 +
 994 +/**
 995 + A flag to control which API to be used
 996 + */
 997 +  private static boolean use11net = true;      // use 1.1 API instead of
 998 +
 999 +  // IO Stats variables
1000 +
1001 +/**
1002 + Number of open files
1003 + */
1004 +  private static int num_open_files = 0;
1005 +
1006 +/**
1007 + Number of files used
1008 + */
1009 +  private static int num_files_used = 0;
1010 +
1011 +/**
1012 + Number of cached files
1013 + */
1014 +  private static int num_cached_files = 0;
1015 +
1016 +/**
1017 + Size of the cache at a given time
1018 + */
1019 +  private static int size_cached_data = 0;
1020 +
1021 +/**
1022 + Total number of bytes read from the cache for executing this benchmark
1023 + */
1024 +  private static int total_num_of_byte_reads_from_cache = 0;
1025 +
1026 +/**
1027 + Total number of bytes read from file
1028 + */
1029 +  private static int total_num_of_byte_reads_from_file = 0;
1030 +
1031 +/**
1032 + Total number of bytes read from the URL
1033 + */
1034 +  private static int total_num_of_byte_reads_from_url = 0;
1035 +
1036 +/**
1037 + Number of cache hits
1038 + */
1039 +  private static int num_cache_hits = 0;
1040 +
1041 +/**
1042 + Number of cache misses or number of files hits
1043 + */
1044 +  private static int num_cache_misses = 0;
1045 +
1046 +/**
1047 + IOtime for executing this benchmark
1048 + */
1049 +  private static long IOtime =0;
1050 +
1051 +/**
1052 + Caching time for executing this benchmark
1053 + */
1054 +  private static long Cachingtime = 0;
1055 +  //********************** End Static variables****************************//
1056 +
1057 +
1058 +
1059 +  //************************* Static methods******************************//
1060 +
1061 +  // Cache methods
1062 +
1063 +/**
1064 + Clears the cache data and updates the Caching parameters
1065 + */
1066 +  public static void clearCache(){
1067 +    filecache = new Hashtable();
1068 +    num_cached_files = 0;
1069 +    size_cached_data = 0;
1070 +    num_cache_hits = 0;
1071 +    num_cache_misses = 0;
1072 +  }
1073 +
1074 +/**
1075 + Closes all the opened streams
1076 + */
1077 +  public static void closeAll() throws java.io.IOException{
1078 +
1079 +    Enumeration all_opened_in_streams = openedInputStreams.elements();
1080 +    if(debug) {
1081 +        System.out.println("Close all called");
1082 +    }
1083 +
1084 +    while(all_opened_in_streams.hasMoreElements()){
1085 +
1086 +      try{
1087 +       java.io.InputStream in = (java.io.InputStream)all_opened_in_streams.nextElement();
1088 +       in.close();
1089 +       num_open_files--;
1090 +      }catch(NoSuchElementException e){
1091 +      }
1092 +    }
1093 +
1094 +  }
1095 +
1096 +
1097 +  // IO Stats methods
1098 +
1099 +  /*
1100 +   * could be useful in debugging
1101 +  public static String getListCachedFiles(){
1102 +      StringBuffer buf = new StringBuffer();
1103 +      for (Enumeration e = filecache.keys(); e.hasMoreElements(); ){
1104 +         buf.append ((String)(e.nextElement()));
1105 +         buf.append (",");
1106 +      }
1107 +      return buf.toString();
1108 +  }
1109 +   */
1110 +/**
1111 + Returns the number of open files
1112 + */
1113 +  public static int getNumOpenFiles(){
1114 +    return num_open_files;
1115 +  }
1116 +
1117 +/**
1118 + Returns the number of used files
1119 + */
1120 +  public static int getNumUsedFiles(){
1121 +    return num_files_used;
1122 +  }
1123 +
1124 +/**
1125 + Returns the number of Cached files
1126 +*/
1127 +  public static int getNumCachedFiles(){
1128 +    return num_cached_files;
1129 +  }
1130 +
1131 +/**
1132 + Returns the size of the cached data
1133 +*/
1134 +  public static int getCachedDataSize(){
1135 +    return size_cached_data;
1136 +  }
1137 +
1138 + /**
1139 +  Returns the number of bytes read from the cache
1140 +  */
1141 +  public static int getNumCacheByteReads(){
1142 +    return total_num_of_byte_reads_from_cache;
1143 +  }
1144 +
1145 + /**
1146 +  Returns the number of bytes read from the file
1147 +  */
1148 +  public static int getNumFileByteReads(){
1149 +    return total_num_of_byte_reads_from_file;
1150 +  }
1151 +
1152 +/**
1153 + Returns the number of bytes read form the URL
1154 + */
1155 +  public static int getNumUrlByteReads(){
1156 +    return total_num_of_byte_reads_from_url;
1157 +  }
1158 +
1159 +/**
1160 + Returns the number of cache hits in executing the current benchmark
1161 + */
1162 +  public static int getNumCacheHits(){
1163 +    return num_cache_hits;
1164 +  }
1165 +
1166 +/**
1167 + Returns the number of cache misses in executing the current benchmark
1168 + */
1169 +  public static int getNumCacheMisses(){
1170 +    return  num_cache_misses;
1171 +  }
1172 +
1173 +/**
1174 + Returns the IO time spent in executing the current benchmark
1175 + */
1176 +  public static long getIOtime(){
1177 +    return IOtime;
1178 +  }
1179 +
1180 +/**
1181 + Returns the Caching time
1182 + */
1183 +  public static long getCachingtime(){
1184 +    return Cachingtime;
1185 +  }
1186 +
1187 +/**
1188 + Return the total retries
1189 + */
1190 +  public static int getTotalRetries(){
1191 +    return totalRetries;
1192 +  }
1193 +
1194 +/**
1195 + Clears the IO statistics variables.
1196 + */
1197 +  public static void clearIOStats(){
1198 +    num_files_used = 0;
1199 +    total_num_of_byte_reads_from_cache = 0;
1200 +    total_num_of_byte_reads_from_file = 0;
1201 +    total_num_of_byte_reads_from_url = 0;
1202 +    IOtime = 0;
1203 +    Cachingtime = 0;
1204 +  }
1205 +
1206 +/**
1207 + Checks whether the given URL is valid or not.
1208 + */
1209 +  public static boolean IsURLOk(URL url){
1210 +
1211 +    /* should have no leading/trailing LWS
1212 +     * expedite the typical case by assuming it has
1213 +     * form "HTTP/1.x <WS> 2XX <mumble>"
1214 +     */
1215 +    int ind;
1216 +    try {
1217 +
1218 +      URLConnection urlc = url.openConnection();
1219 +
1220 +      String resp = urlc.getHeaderField(0);
1221 +
1222 +      if( resp == null ) {
1223 +//       System.out.println( "resp == NULL in IsURLOk" );
1224 +         return true;
1225 +      }
1226 +
1227 +      ind = resp.indexOf(' ');
1228 +      while(resp.charAt(ind) == ' ')
1229 +       ind++;
1230 +      int responseCode = Integer.parseInt(resp.substring(ind, ind + 3));
1231 +
1232 +      if (debug){
1233 +       System.out.println("responseCode = " + responseCode);
1234 +      }
1235 +
1236 +      return !( ((responseCode >= 400) && (responseCode <= 415)) ||
1237 +               ((responseCode >= 500) && (responseCode <= 505))
1238 +               );
1239 +
1240 +    } catch (java.io.IOException e) {
1241 +      System.out.println("Exception in IsURLOk " + e );
1242 +      return false;
1243 +    }
1244 +
1245 +  }
1246 +
1247 +
1248 +/**
1249 + Constructs the URL for the server file given the file name
1250 + */
1251 +  private static String makeGoodUrl(String str){
1252 +
1253 +    String retstr;
1254 +
1255 +    retstr = str.replace( '\\', '/' );
1256 +
1257 +    int ind = 0;
1258 +
1259 +    if (retstr.startsWith("http")){
1260 +      ind = 6;
1261 +    }
1262 +
1263 +    if (retstr.indexOf("//" , ind) != -1){
1264 +      char c[] = retstr.toCharArray();
1265 +      int len = retstr.length();
1266 +      for(int i = ind; i < len; i++){
1267 +
1268 +       if (c[i] == '/'){
1269 +         int j = i+1;
1270 +
1271 +         while( (j < len) && (c[j] == '/') ){
1272 +           j = j+1;
1273 +         }
1274 +         if (j > (i+1)){
1275 +           for(int k = i+1 , l = j; l < len; l++ , k++){
1276 +             c[k] = c[l];
1277 +           }
1278 +           len = len - (j-i-1);
1279 +         }
1280 +       }
1281 +       retstr = new String(c , 0 , len);
1282 +      }
1283 +    }
1284 +    return retstr;
1285 +  }
1286 +
1287 +  //********************** End Static methods****************************//
1288 +
1289 +
1290 +
1291 +/**
1292 + The file URL
1293 + */
1294 +  private String my_file_url;
1295 +
1296 +/**
1297 +
1298 + */
1299 +  private java.io.InputStream orig_in;
1300 +
1301 +/**
1302 + Length of the FileInputStream
1303 + */
1304 +  private int len = 0;
1305 +
1306 +/**
1307 + Flag indicating whether the file stream is closed or not
1308 + */
1309 +  private boolean closed = false;
1310 +
1311 +/**
1312 + Flag indicating whether to cache the data during the first loading or not
1313 + */
1314 +  private boolean doCache;
1315 +
1316 +/**
1317 + Flag indicating whether the data is from the Cache
1318 + */
1319 +  private boolean fromCache = false;
1320 +
1321 +/**
1322 + Flag indicating whether the data is from URL
1323 + */
1324 +  private boolean fromUrl = false;
1325 +
1326 + /**
1327 +  Updates the file read statistics
1328 +  @param len Length of the FileStream
1329 +  */
1330 +  private void collectReadStats(int len){
1331 +
1332 +    if (len <= 0){
1333 +      return;
1334 +    }
1335 +
1336 +    if (fromCache){
1337 +      total_num_of_byte_reads_from_cache += len;
1338 +    }
1339 +    else{
1340 +      if (fromUrl){
1341 +       total_num_of_byte_reads_from_url += len;
1342 +      }
1343 +      else{
1344 +       total_num_of_byte_reads_from_file += len;
1345 +      }
1346 +    }
1347 +
1348 +  }
1349 +
1350 +
1351 +    /**
1352 +     * Main class constructor.
1353 +     *
1354 +     * Try and find the strange URL open bug by catching any exceptions and calling the
1355 +     * System finalizer to try and close the sockets.
1356 +     */
1357 +    public FileInputStream(String input_filename) throws java.io.FileNotFoundException,
1358 +                                   java.net.MalformedURLException , java.io.IOException {
1359 +       super();
1360 +
1361 +       try {
1362 +            construct(input_filename);
1363 +       } catch(Exception a) {
1364 +           System.out.println ( "----------------------------------");
1365 +           System.out.println ( "spec.io.FileInputStream: Caught exception in constructor: "+a);
1366 +           System.out.println ( "trying to open: " + input_filename); //wnb
1367 +           System.out.println ( "spec.io.FileInputStream: Attempting recovery with System.runFinalization()");
1368 +           System.gc();
1369 +           System.runFinalization();
1370 +           try {
1371 +               construct(input_filename);
1372 +           } catch(Exception b){
1373 +               System.out.println ( "----------------------------------");
1374 +               System.out.println ( "spec.io.FileInputStream: Caught exception in constructor at second level: "+a);
1375 +               if ( !(b instanceof java.io.FileNotFoundException) ) {
1376 +                   System.out.println ( "spec.io.FileInputStream: Exiting benchmark");
1377 +                   printStackTrace(b);
1378 +                   throw new StopBenchmarkException( "spec.io.FileInputStream failure" );
1379 +               } else {
1380 +                   throw (java.io.FileNotFoundException)b;
1381 +               }
1382 +           }
1383 +       }
1384 +    }
1385 +
1386 +/**
1387 + Constructs thd FileInputStream object from the given file name
1388 + */
1389 +  private void construct(String input_filename) throws Exception{
1390 +
1391 +       long startTime = System.currentTimeMillis();
1392 +
1393 +       my_file_url = makeGoodUrl(input_filename);
1394 +
1395 +       num_open_files++;
1396 +       num_files_used++;
1397 +
1398 +       if (filecache.containsKey(my_file_url)){
1399 +
1400 +         long cacheStartTime = System.currentTimeMillis();
1401 +
1402 +         doCache = false;    // no need to cache data -- data is already in cache
1403 +         fromCache = true;   // read data from cache
1404 +
1405 +         num_cache_hits++;   // we have a hit
1406 +
1407 +         if (debug){
1408 +           System.out.println("\n++++++++making InputStream from cached " + my_file_url);
1409 +         }
1410 +
1411 +
1412 +         // Get the cached data from the filecache
1413 +         FileCacheData fcd = (FileCacheData)filecache.get(my_file_url);
1414 +
1415 +         // Get the length of the data
1416 +         len = fcd.getLength();
1417 +
1418 +         // Get an inputStream to read data form the cache
1419 +         orig_in = fcd.getInputStream();
1420 +
1421 +         long cacheEndTime = System.currentTimeMillis();
1422 +         Cachingtime += (cacheEndTime - cacheStartTime);
1423 +       }
1424 +       else{
1425 +
1426 +         num_cache_misses++;  // we have a miss
1427 +
1428 +         if (debug){
1429 +           System.out.println("\n++++++++Opening InputStream for " + my_file_url);
1430 +         }
1431 +
1432 +
1433 +         openStream();  // open an inputStream through network or file I/O
1434 +
1435 +
1436 +         if (false){
1437 +
1438 +           long cacheStartTime = System.currentTimeMillis();
1439 +
1440 +           doCache = true;  // we have to cache data
1441 +
1442 +           // create a new FileCacheData object of size len and put it in the filecache
1443 +           // with my_file_url as the key
1444 +
1445 +           FileCacheData fcd = new FileCacheData(len);
1446 +           filecache.put(my_file_url , fcd);
1447 +
1448 +           size_cached_data += len;
1449 +           num_cached_files++;
1450 +
1451 +           long cacheEndTime = System.currentTimeMillis();
1452 +           Cachingtime += (cacheEndTime - cacheStartTime);
1453 +         }
1454 +         else{
1455 +           doCache = false;
1456 +         }
1457 +
1458 +         // Keep track of all the InputStreams opened so far.
1459 +         openedInputStreams.addElement(orig_in);
1460 +
1461 +
1462 +       }
1463 +
1464 +       long endTime = System.currentTimeMillis();
1465 +       long totalTime = endTime - startTime;
1466 +
1467 +
1468 +       IOtime += totalTime;
1469 +  }
1470 +
1471 +
1472 +  /**
1473 +   * Prints the stack backtrace to Context.out. If this is an instance of
1474 +   * spec.io.PrintStream (it normally will be) then the default validity
1475 +   * check value is changed to '1'. This is the code that means all data
1476 +   * should be compaired and will ensure that the benchmark fails the
1477 +   * validity check process.
1478 +   */
1479 +  void printStackTrace(Exception x) {
1480 +      java.io.PrintStream str = System.out;
1481 +      x.printStackTrace(System.out);
1482 +  }
1483 +
1484 +/**
1485 + Opens the FileInputStream
1486 + */
1487 +  private void openStream() throws java.io.FileNotFoundException,
1488 +      java.net.MalformedURLException , java.io.IOException{
1489 +
1490 +    if (false){
1491 +      fromUrl = true;
1492 +      URL url = new URL(my_file_url);
1493 +      URLConnection urlc = url.openConnection();
1494 +      len = urlc.getHeaderFieldInt("content-length", LENGTH_ERROR);
1495 +      for (int retry=0; retry < nRetry && len == LENGTH_ERROR; retry++){
1496 +        if (urlc instanceof HttpURLConnection)
1497 +          ((HttpURLConnection) urlc).disconnect();
1498 +        urlc = null;
1499 +        System.gc();
1500 +        System.runFinalization();
1501 +       if (debug)
1502 +            System.out.println ("GET failed on " + my_file_url);
1503 +        try{
1504 +          Thread.sleep (retryDelay);
1505 +        }catch (InterruptedException e){}
1506 +        urlc = url.openConnection();
1507 +        urlc.connect();
1508 +        len = urlc.getHeaderFieldInt("content-length", LENGTH_ERROR);
1509 +       totalRetries++;
1510 +      }
1511 +      if (use11net && (urlc instanceof HttpURLConnection)){
1512 +       HttpURLConnection urlh = (HttpURLConnection) urlc;
1513 +       if (urlh.getResponseCode() != HttpURLConnection.HTTP_OK)
1514 +         throw new java.io.FileNotFoundException( my_file_url +
1515 +           ": " + urlh.getResponseMessage());
1516 +      }else{
1517 +        if (!IsURLOk(url))
1518 +         throw new java.io.FileNotFoundException( my_file_url );
1519 +      }
1520 +
1521 +      if (len == LENGTH_ERROR){
1522 +       throw new java.io.IOException("Cannot establish URL content-length");
1523 +/*
1524 +       System.out.println("Error getting size of file -- turning off caching");
1525 +       spec.harness.Context.setCachedInputFlag(false);
1526 +*/
1527 +      }
1528 +
1529 +      if (debug){
1530 +       if (len == LENGTH_ERROR){
1531 +         if (urlc == null){
1532 +           System.out.println("urlc is null");
1533 +         }
1534 +         else{
1535 +           System.out.println("urlc = " + urlc);
1536 +         }
1537 +       }
1538 +       System.out.println("++++++++spec.io.FileInputStream url len = " + len);
1539 +      }
1540 +
1541 +      try{
1542 +       orig_in = urlc.getInputStream();
1543 +      }catch(java.io.IOException ioe){
1544 +       System.out.println("Error trying to get an inputStream from url connection " + urlc);
1545 +       throw ioe;
1546 +      }
1547 +
1548 +    }else{    // NOT (Context.isNetworkAccess())
1549 +
1550 +      File file = new File(my_file_url);
1551 +      len = (int)file.length();
1552 +
1553 +      if (debug){
1554 +       System.out.println("++++++++spec.io.FileInputStream file len = " + len);
1555 +      }
1556 +      orig_in = new java.io.FileInputStream(my_file_url);
1557 +
1558 +    }
1559 +  }
1560 +
1561 +/**
1562 + Constructor
1563 + @param file File object
1564 + */
1565 +  public FileInputStream(spec.io.File file) throws java.io.FileNotFoundException,
1566 +    java.net.MalformedURLException , java.io.IOException{
1567 +        this(file.getPath());
1568 +  }
1569 +
1570 +/**
1571 + Returns the stream length
1572 + */
1573 +  public int getContentLength(){
1574 +
1575 +    return len;
1576 +
1577 +  }
1578 +
1579 +/**
1580 +  Returns the number of bytes that can be read from this input stream without
1581 +  blocking.
1582 + */
1583 +  public synchronized int available() throws java.io.IOException{
1584 +
1585 +    try{
1586 +
1587 +      return orig_in.available();
1588 +
1589 +    }catch(java.io.IOException ioe){
1590 +      printStackTrace(ioe);
1591 +      throw new StopBenchmarkException(ioe.toString());
1592 +    }
1593 +  }
1594 +
1595 +/**
1596 + Reads the next byte of data from this input stream.
1597 + */
1598 +  public synchronized int read() throws java.io.IOException{
1599 +
1600 +    try{
1601 +
1602 +      long startTime = System.currentTimeMillis();
1603 +
1604 +      int byte_read = orig_in.read();
1605 +      if ((doCache) && (byte_read != -1)){
1606 +
1607 +       long cacheStartTime = System.currentTimeMillis();
1608 +       ((FileCacheData)filecache.get(my_file_url)).copyData((byte)byte_read);
1609 +       long cacheEndTime = System.currentTimeMillis();
1610 +       Cachingtime += (cacheEndTime - cacheStartTime);
1611 +      }
1612 +
1613 +      long endTime = System.currentTimeMillis();
1614 +      long totalTime = endTime - startTime;
1615 +
1616 +
1617 +      IOtime += totalTime;
1618 +
1619 +      if( debug ){
1620 +//        System.out.println("byte_read = " + byte_read);
1621 +      }
1622 +
1623 +      collectReadStats(1);
1624 +      return byte_read;
1625 +
1626 +    }catch(java.io.IOException ioe){
1627 +      printStackTrace(ioe);
1628 +      throw new StopBenchmarkException(ioe.toString());
1629 +    }
1630 +  }
1631 +
1632 +/**
1633 + Reads up to byte.length bytes of data from this input stream into an array of
1634 + bytes. This method blocks until some input is available.
1635 +
1636 + The read method of FilterInputStream calls the read method of three arguments
1637 + with the arguments b, 0, and b.length, and returns whatever value that method
1638 + returns.
1639 +
1640 + Note that this method does not call the one-argument read method of its
1641 + underlying stream with the single argument b. Subclasses of FilterInputStream
1642 + do not need to override this method if they have overridden the three-argument
1643 + read method.
1644 + @param b Buffer into which the data is read
1645 +*/
1646 +  public int read(byte b[]) throws java.io.IOException{
1647 +
1648 +    try{
1649 +      long startTime = System.currentTimeMillis();
1650 +
1651 +      int bytes_read = orig_in.read(b);
1652 +
1653 +      if ((doCache) && (bytes_read > 0)){
1654 +
1655 +       long cacheStartTime = System.currentTimeMillis();
1656 +       ((FileCacheData)filecache.get(my_file_url)).copyData(b, 0, bytes_read);
1657 +       long cacheEndTime = System.currentTimeMillis();
1658 +       Cachingtime += (cacheEndTime - cacheStartTime);
1659 +      }
1660 +
1661 +      long endTime = System.currentTimeMillis();
1662 +      long totalTime = endTime - startTime;
1663 +
1664 +
1665 +      IOtime += totalTime;
1666 +
1667 +
1668 +      if( debug ){
1669 +       System.out.println("bytes_read = " + bytes_read);
1670 +      }
1671 +
1672 +      collectReadStats(bytes_read);
1673 +      return bytes_read;
1674 +    }catch(java.io.IOException ioe){
1675 +      printStackTrace(ioe);
1676 +      throw new StopBenchmarkException(ioe.toString());
1677 +    }
1678 +  }
1679 +
1680 +/**
1681 + Reads up to len bytes of data from this input stream into an array of bytes.
1682 + This method blocks until some input is available.
1683 +
1684 + The read method of FilterInputStream calls the read method of its underlying
1685 + input stream with the same arguments and returns whatever value that method
1686 + returns.
1687 + @param b - the buffer into which the data is read
1688 + @param off - the start offset of the data
1689 + @param len - the maximum number of bytes read
1690 + */
1691 +
1692 +  public synchronized int read(byte b[], int off, int len) throws java.io.IOException{
1693 +
1694 +
1695 +    try{
1696 +
1697 +      long startTime = System.currentTimeMillis();
1698 +
1699 +      int bytes_read = orig_in.read(b, off, len);
1700 +      if ((doCache) && (bytes_read > 0)){
1701 +
1702 +       long cacheStartTime = System.currentTimeMillis();
1703 +       ((FileCacheData)filecache.get(my_file_url)).copyData(b, off, bytes_read);
1704 +       long cacheEndTime = System.currentTimeMillis();
1705 +       Cachingtime += (cacheEndTime - cacheStartTime);
1706 +      }
1707 +      long endTime = System.currentTimeMillis();
1708 +      long totalTime = endTime - startTime;
1709 +
1710 +
1711 +      IOtime += totalTime;
1712 +
1713 +
1714 +      if( debug ){
1715 +        System.out.println("bytes_read = " + bytes_read);
1716 +      }
1717 +
1718 +      collectReadStats(bytes_read);
1719 +      return bytes_read;
1720 +
1721 +    }catch(java.io.IOException ioe){
1722 +      printStackTrace(ioe);
1723 +      throw new StopBenchmarkException(ioe.toString());
1724 +    }
1725 +  }
1726 +
1727 +/**
1728 + Closes this input stream and releases any system resources associated with the
1729 + stream. The close method of FilterInputStream calls the close method of its
1730 + underlying input stream.
1731 + */
1732 +  public void close() throws java.io.IOException{
1733 +
1734 +    try{
1735 +      if (!closed){
1736 +
1737 +       orig_in.close();
1738 +       numofCloses ++;
1739 +       num_open_files--;
1740 +
1741 +
1742 +       if (debug || testing){
1743 +         System.out.println("++++++++Closing InputStream for " + my_file_url +
1744 +           " " + num_open_files + " " + numofCloses);
1745 +       }
1746 +
1747 +       closed = true;
1748 +
1749 +      }
1750 +      else{
1751 +       if (debug){
1752 +         System.out.println("++++++++InputStream for " + my_file_url + " has been closed before");
1753 +       }
1754 +      }
1755 +    }catch(java.io.IOException ioe){
1756 +      printStackTrace(ioe);
1757 +      throw new StopBenchmarkException(ioe.toString());
1758 +    }
1759 +
1760 +  }
1761 +
1762 +/**
1763 + Skips over and discards n bytes of data from the input stream. The skip method
1764 + may, for a variety of reasons, end up skipping over some smaller number of
1765 + bytes, possibly 0. The actual number of bytes skipped is returned.
1766 +
1767 + The skip method of FilterInputStream calls the skip method of its underlying
1768 + input stream with the same argument, and returns whatever value that method
1769 + does.
1770 + @param n - number of bytes to be skipped
1771 + */
1772 +  public long skip(long n) throws java.io.IOException{
1773 +
1774 +    try{
1775 +      if (debug){
1776 +       System.out.println("++++++++ Skipping " + n + " positions in InputStream for " + my_file_url);
1777 +      }
1778 +
1779 +      if (doCache){
1780 +       ((FileCacheData)filecache.get(my_file_url)).skipPos(n);
1781 +      }
1782 +      return orig_in.skip(n);
1783 +    }catch(java.io.IOException ioe){
1784 +      printStackTrace(ioe);
1785 +      throw new StopBenchmarkException(ioe.toString());
1786 +    }
1787 +
1788 +  }
1789 +
1790 +  /**
1791 +   Finalization method.
1792 +   */
1793 +
1794 +  protected void finalize() throws java.io.IOException{
1795 +
1796 +  //  try{
1797 +      if (!closed){
1798 +
1799 +       if (debug || testing ){
1800 +         System.out.println("++++++++Calling close Inside finalize for " + my_file_url );
1801 +       }
1802 +
1803 +       this.close();
1804 +
1805 +      }
1806 +  /*  }catch(java.io.IOException ioe){
1807 +      printStackTrace(ioe);
1808 +      throw new StopBenchmarkException(ioe.toString());
1809 +    }
1810 +  */
1811 +
1812 +  }
1813 +
1814 +}
1815 diff -Nu mpegaudio1/FileOutputStream.java mpegaudio/FileOutputStream.java
1816 --- mpegaudio1/FileOutputStream.java    Thu Jan  1 01:00:00 1970
1817 +++ mpegaudio/FileOutputStream.java     Tue Nov 26 11:36:25 2002
1818 @@ -0,0 +1,128 @@
1819 +/*
1820 + * @(#)FileOutputStream.java   1.11 06/17/98
1821 + *
1822 + * Copyright (c) 1998 Standard Performance Evaluation Corporation (SPEC)
1823 + *               All rights reserved.
1824 + * Copyright (c) 1997,1998 Sun Microsystems, Inc. All rights reserved.
1825 + *
1826 + * This source code is provided as is, without any express or implied warranty.
1827 + */
1828 +
1829 +package spec.io;
1830 +import spec.harness.Context;
1831 +
1832 +/**
1833 + * Dummy output stream that is only used as a place holder and for a little
1834 + * benchmark validity checking
1835 + */
1836 +public class FileOutputStream extends java.io.OutputStream {
1837 +
1838 +    /**
1839 +     * Development debug flag
1840 +     */
1841 +    final static boolean debug = false;
1842 +
1843 +    /**
1844 +     * Count of bytes written
1845 +     */
1846 +    static int byteCount = -99999999;
1847 +
1848 +    /**
1849 +     * Checksum
1850 +     */
1851 +    static int checksum = 0;
1852 +
1853 +    /**
1854 +     * Standard constructor. It creates the file if it is not existing, but it
1855 +        * truncates the existing data if the file already exists
1856 +     */
1857 +    public FileOutputStream(String name) throws java.io.IOException{
1858 +    }
1859 +
1860 +    /**
1861 +     * Standard constructor. It opens the existing file but doesn't truncate
1862 +        * existing data
1863 +        * @see java.io.FileOutPutStream
1864 +     */
1865 +    public FileOutputStream(String name, boolean append) throws java.io.IOException {
1866 +    }
1867 +
1868 +    /**
1869 +     * Standard constructor
1870 +     */
1871 +    public FileOutputStream(spec.io.File file) throws java.io.IOException {
1872 +    }
1873 +
1874 +    /**
1875 +     * Writes specified byte into output stream.
1876 +        * @param b - byte to be written
1877 +     */
1878 +    public void write(int b) throws java.io.IOException {
1879 +        byteCount++;
1880 +        checksum += specialTrace("W", b );
1881 +    }
1882 +
1883 +    /**
1884 +     * Write b.length bytes into output stream
1885 +        * @param b - byte array to be written
1886 +     */
1887 +    public void write(byte b[]) throws java.io.IOException {
1888 +       int len = b.length;
1889 +       byteCount += len;
1890 +       if (len > 0) {
1891 +           checksum += specialTrace("X", b[0] );; // Just checksum the first character
1892 +       }
1893 +       if( debug ) {
1894 +            System.out.println("Inside spec.io.FileOutStream.write() -- throwing away output");
1895 +       }
1896 +    }
1897 +
1898 +/**
1899 + Writes len bytes from the specified byte array starting at offset off to this
1900 + output stream. The write method of FilterOutputStream calls the write method
1901 + of one argument on each byte to output.
1902 +
1903 + Note that this method does not call the write method of its underlying input
1904 + stream with the same arguments. Subclasses of FilterOutputStream should
1905 + provide a more efficient implementation of this method
1906 +*/
1907 +    public void write(byte b[], int off, int len) throws java.io.IOException {
1908 +       byteCount += len;
1909 +
1910 +       if (len > 0) {
1911 +           checksum += specialTrace("Z",b[off]); // Just checksum the first character
1912 +       }
1913 +       if( debug ) {
1914 +            System.out.println("Inside spec.io.FileOutStream.write() -- throwing away output");
1915 +       }
1916 +    }
1917 +
1918 +    /**
1919 +     * Chears the byte counter
1920 +     */
1921 +    public static void clearCount() {
1922 +       byteCount = 0;
1923 +       checksum  = 0;
1924 +    }
1925 +
1926 +    /**
1927 +     * Prints the byte counter in validity check mode '1'
1928 +        * @param check - Indicates whether the validation is enabled or not
1929 +     */
1930 +    public static void printCount(boolean check) {
1931 +        spec.io.PrintStream s = (spec.io.PrintStream)Context.out;
1932 +        if( check ) {
1933 +           s.println('1',"File output byte count = "+byteCount+" checksum = "+checksum);
1934 +        } else {
1935 +           s.println('1',"File output byte count = "+byteCount);
1936 +       }
1937 +    }
1938 +
1939 +
1940 +    public static int specialTrace(String rtn, int ch) {
1941 +//     ((spec.io.PrintStream)Context.out).println('1',rtn+ch);
1942 +       return ch;
1943 +    }
1944 +}
1945 +
1946 +
1947 diff -Nu mpegaudio1/StopBenchmarkException.java mpegaudio/StopBenchmarkException.java
1948 --- mpegaudio1/StopBenchmarkException.java      Thu Jan  1 01:00:00 1970
1949 +++ mpegaudio/StopBenchmarkException.java       Tue Nov 26 11:31:12 2002
1950 @@ -0,0 +1,9 @@
1951 +package spec.io;
1952 +
1953 +import java.io.IOException;
1954 +
1955 +class StopBenchmarkException extends IOException {
1956 +    public StopBenchmarkException(String a) {
1957 +       super(a);
1958 +    }
1959 +};
1960 diff -Nu mpegaudio1/TableOfExistingFiles.java mpegaudio/TableOfExistingFiles.java
1961 --- mpegaudio1/TableOfExistingFiles.java        Thu Jan  1 01:00:00 1970
1962 +++ mpegaudio/TableOfExistingFiles.java Tue Nov 26 11:03:06 2002
1963 @@ -0,0 +1,672 @@
1964 +/*
1965 + * @(#)TableOfExistingFiles.java       1.5 06/17/98
1966 + *
1967 + * Copyright (c) 1998 Standard Performance Evaluation Corporation (SPEC)
1968 + *               All rights reserved.
1969 + * Copyright (c) 1997,1998 Sun Microsystems, Inc. All rights reserved.
1970 + *
1971 + * This source code is provided as is, without any express or implied warranty.
1972 + */
1973 +
1974 +package spec.io;
1975 +
1976 +/**
1977 + This class maintains a list of the files that should not be loaded across
1978 + the net. Any other class or data file required by the SpecJVMClient are
1979 + loaded across the net.
1980 + */
1981 +public class TableOfExistingFiles extends java.util.Hashtable{
1982 +
1983 +/**
1984 + Constructor.
1985 + */
1986 +public TableOfExistingFiles(){
1987 +super();
1988 +
1989 +String o = "Java programmers make better lovers.";
1990 +super.put("lib/java/util" , o);
1991 +super.put("lib/java/io" , o);
1992 +super.put("lib/java/lang/Object.class" , o);
1993 +super.put("lib/java/lang/Exception.class" , o);
1994 +super.put("lib/java/lang/Integer.class" , o);
1995 +super.put("lib/java/lang/NumberFormatException.class" , o);
1996 +super.put("lib/java/lang/Throwable.class" , o);
1997 +super.put("lib/java/lang/Class.class" , o);
1998 +super.put("lib/java/lang/IllegalAccessException.class" , o);
1999 +super.put("lib/java/lang/StringBuffer.class" , o);
2000 +super.put("lib/java/lang/ClassNotFoundException.class" , o);
2001 +super.put("lib/java/lang/IllegalArgumentException.class" , o);
2002 +super.put("lib/java/lang/Number.class" , o);
2003 +super.put("lib/java/lang/InterruptedException.class" , o);
2004 +super.put("lib/java/lang/String.class" , o);
2005 +super.put("lib/java/lang/RuntimeException.class" , o);
2006 +super.put("lib/java/lang/InternalError.class" , o);
2007 +super.put("lib/java/lang/Long.class" , o);
2008 +super.put("lib/java/lang/Character.class" , o);
2009 +super.put("lib/java/lang/CloneNotSupportedException.class" , o);
2010 +super.put("lib/java/lang/InstantiationException.class" , o);
2011 +super.put("lib/java/lang/VirtualMachineError.class" , o);
2012 +super.put("lib/java/lang/Double.class" , o);
2013 +super.put("lib/java/lang/Error.class" , o);
2014 +super.put("lib/java/lang/NullPointerException.class" , o);
2015 +super.put("lib/java/lang/Cloneable.class" , o);
2016 +super.put("lib/java/lang/System.class" , o);
2017 +super.put("lib/java/lang/ClassLoader.class" , o);
2018 +super.put("lib/java/lang/Math.class" , o);
2019 +super.put("lib/java/lang/Float.class" , o);
2020 +super.put("lib/java/lang/Runtime.class" , o);
2021 +super.put("lib/java/lang/StringIndexOutOfBoundsException.class" , o);
2022 +super.put("lib/java/lang/IndexOutOfBoundsException.class" , o);
2023 +super.put("lib/java/lang/SecurityException.class" , o);
2024 +super.put("lib/java/lang/LinkageError.class" , o);
2025 +super.put("lib/java/lang/Runnable.class" , o);
2026 +super.put("lib/java/lang/Process.class" , o);
2027 +super.put("lib/java/lang/SecurityManager.class" , o);
2028 +super.put("lib/java/lang/Thread.class" , o);
2029 +super.put("lib/java/lang/UnsatisfiedLinkError.class" , o);
2030 +super.put("lib/java/lang/IncompatibleClassChangeError.class" , o);
2031 +super.put("lib/java/lang/NoSuchMethodError.class" , o);
2032 +super.put("lib/java/lang/IllegalThreadStateException.class" , o);
2033 +super.put("lib/java/lang/ThreadGroup.class" , o);
2034 +super.put("lib/java/lang/ThreadDeath.class" , o);
2035 +super.put("lib/java/lang/ArrayIndexOutOfBoundsException.class" , o);
2036 +super.put("lib/java/lang/Boolean.class" , o);
2037 +super.put("lib/java/lang/Compiler.class" , o);
2038 +super.put("lib/java/lang/NoSuchMethodException.class" , o);
2039 +super.put("lib/java/lang/ArithmeticException.class" , o);
2040 +super.put("lib/java/lang/ArrayStoreException.class" , o);
2041 +super.put("lib/java/lang/ClassCastException.class" , o);
2042 +super.put("lib/java/lang/NegativeArraySizeException.class" , o);
2043 +super.put("lib/java/lang/IllegalMonitorStateException.class" , o);
2044 +super.put("lib/java/lang/ClassCircularityError.class" , o);
2045 +super.put("lib/java/lang/ClassFormatError.class" , o);
2046 +super.put("lib/java/lang/AbstractMethodError.class" , o);
2047 +super.put("lib/java/lang/IllegalAccessError.class" , o);
2048 +super.put("lib/java/lang/InstantiationError.class" , o);
2049 +super.put("lib/java/lang/NoSuchFieldError.class" , o);
2050 +super.put("lib/java/lang/NoClassDefFoundError.class" , o);
2051 +super.put("lib/java/lang/VerifyError.class" , o);
2052 +super.put("lib/java/lang/OutOfMemoryError.class" , o);
2053 +super.put("lib/java/lang/StackOverflowError.class" , o);
2054 +super.put("lib/java/lang/UnknownError.class" , o);
2055 +super.put("lib/java/lang/Win32Process.class" , o);
2056 +super.put("lib/java/io/FilterOutputStream.class" , o);
2057 +super.put("lib/java/io/OutputStream.class" , o);
2058 +super.put("lib/java/io/IOException.class" , o);
2059 +super.put("lib/java/io/PrintStream.class" , o);
2060 +super.put("lib/java/io/FileInputStream.class" , o);
2061 +super.put("lib/java/io/InterruptedIOException.class" , o);
2062 +super.put("lib/java/io/File.class" , o);
2063 +super.put("lib/java/io/InputStream.class" , o);
2064 +super.put("lib/java/io/BufferedInputStream.class" , o);
2065 +super.put("lib/java/io/FileOutputStream.class" , o);
2066 +super.put("lib/java/io/FileNotFoundException.class" , o);
2067 +super.put("lib/java/io/BufferedOutputStream.class" , o);
2068 +super.put("lib/java/io/FileDescriptor.class" , o);
2069 +super.put("lib/java/io/FilenameFilter.class" , o);
2070 +super.put("lib/java/io/FilterInputStream.class" , o);
2071 +super.put("lib/java/io/PipedInputStream.class" , o);
2072 +super.put("lib/java/io/PipedOutputStream.class" , o);
2073 +super.put("lib/java/io/EOFException.class" , o);
2074 +super.put("lib/java/io/UTFDataFormatException.class" , o);
2075 +super.put("lib/java/io/DataInput.class" , o);
2076 +super.put("lib/java/io/DataOutput.class" , o);
2077 +super.put("lib/java/io/DataInputStream.class" , o);
2078 +super.put("lib/java/io/PushbackInputStream.class" , o);
2079 +super.put("lib/java/io/ByteArrayInputStream.class" , o);
2080 +super.put("lib/java/io/SequenceInputStream.class" , o);
2081 +super.put("lib/java/io/StringBufferInputStream.class" , o);
2082 +super.put("lib/java/io/LineNumberInputStream.class" , o);
2083 +super.put("lib/java/io/DataOutputStream.class" , o);
2084 +super.put("lib/java/io/ByteArrayOutputStream.class" , o);
2085 +super.put("lib/java/io/RandomAccessFile.class" , o);
2086 +super.put("lib/java/io/StreamTokenizer.class" , o);
2087 +super.put("lib/java/util/Hashtable.class" , o);
2088 +super.put("lib/java/util/Enumeration.class" , o);
2089 +super.put("lib/java/util/HashtableEnumerator.class" , o);
2090 +super.put("lib/java/util/Properties.class" , o);
2091 +super.put("lib/java/util/HashtableEntry.class" , o);
2092 +super.put("lib/java/util/Dictionary.class" , o);
2093 +super.put("lib/java/util/Date.class" , o);
2094 +super.put("lib/java/util/NoSuchElementException.class" , o);
2095 +super.put("lib/java/util/StringTokenizer.class" , o);
2096 +super.put("lib/java/util/Random.class" , o);
2097 +super.put("lib/java/util/VectorEnumerator.class" , o);
2098 +super.put("lib/java/util/Vector.class" , o);
2099 +super.put("lib/java/util/BitSet.class" , o);
2100 +super.put("lib/java/util/EmptyStackException.class" , o);
2101 +super.put("lib/java/util/Observable.class" , o);
2102 +super.put("lib/java/util/Observer.class" , o);
2103 +super.put("lib/java/util/ObserverList.class" , o);
2104 +super.put("lib/java/util/Stack.class" , o);
2105 +super.put("lib/java/awt/Toolkit.class" , o);
2106 +super.put("lib/java/awt/peer/WindowPeer.class" , o);
2107 +super.put("lib/java/awt/peer/TextFieldPeer.class" , o);
2108 +super.put("lib/java/awt/peer/ContainerPeer.class" , o);
2109 +super.put("lib/java/awt/peer/PanelPeer.class" , o);
2110 +super.put("lib/java/awt/peer/CanvasPeer.class" , o);
2111 +super.put("lib/java/awt/peer/FramePeer.class" , o);
2112 +super.put("lib/java/awt/peer/ChoicePeer.class" , o);
2113 +super.put("lib/java/awt/peer/CheckboxMenuItemPeer.class" , o);
2114 +super.put("lib/java/awt/peer/TextAreaPeer.class" , o);
2115 +super.put("lib/java/awt/peer/FileDialogPeer.class" , o);
2116 +super.put("lib/java/awt/peer/TextComponentPeer.class" , o);
2117 +super.put("lib/java/awt/peer/ScrollbarPeer.class" , o);
2118 +super.put("lib/java/awt/peer/ButtonPeer.class" , o);
2119 +super.put("lib/java/awt/peer/ComponentPeer.class" , o);
2120 +super.put("lib/java/awt/peer/MenuComponentPeer.class" , o);
2121 +super.put("lib/java/awt/peer/MenuItemPeer.class" , o);
2122 +super.put("lib/java/awt/peer/CheckboxPeer.class" , o);
2123 +super.put("lib/java/awt/peer/MenuPeer.class" , o);
2124 +super.put("lib/java/awt/peer/ListPeer.class" , o);
2125 +super.put("lib/java/awt/peer/MenuBarPeer.class" , o);
2126 +super.put("lib/java/awt/peer/LabelPeer.class" , o);
2127 +super.put("lib/java/awt/peer/DialogPeer.class" , o);
2128 +super.put("lib/java/awt/Image.class" , o);
2129 +super.put("lib/java/awt/MenuItem.class" , o);
2130 +super.put("lib/java/awt/MenuComponent.class" , o);
2131 +super.put("lib/java/awt/image/ImageProducer.class" , o);
2132 +super.put("lib/java/awt/image/ColorModel.class" , o);
2133 +super.put("lib/java/awt/image/DirectColorModel.class" , o);
2134 +super.put("lib/java/awt/image/ImageConsumer.class" , o);
2135 +super.put("lib/java/awt/image/ImageObserver.class" , o);
2136 +super.put("lib/java/awt/image/CropImageFilter.class" , o);
2137 +super.put("lib/java/awt/image/ImageFilter.class" , o);
2138 +super.put("lib/java/awt/image/FilteredImageSource.class" , o);
2139 +super.put("lib/java/awt/image/IndexColorModel.class" , o);
2140 +super.put("lib/java/awt/image/MemoryImageSource.class" , o);
2141 +super.put("lib/java/awt/image/PixelGrabber.class" , o);
2142 +super.put("lib/java/awt/image/RGBImageFilter.class" , o);
2143 +super.put("lib/java/awt/FontMetrics.class" , o);
2144 +super.put("lib/java/awt/Checkbox.class" , o);
2145 +super.put("lib/java/awt/CheckboxGroup.class" , o);
2146 +super.put("lib/java/awt/MenuContainer.class" , o);
2147 +super.put("lib/java/awt/Menu.class" , o);
2148 +super.put("lib/java/awt/Insets.class" , o);
2149 +super.put("lib/java/awt/MenuBar.class" , o);
2150 +super.put("lib/java/awt/List.class" , o);
2151 +super.put("lib/java/awt/Label.class" , o);
2152 +super.put("lib/java/awt/Component.class" , o);
2153 +super.put("lib/java/awt/TextField.class" , o);
2154 +super.put("lib/java/awt/TextComponent.class" , o);
2155 +super.put("lib/java/awt/Dialog.class" , o);
2156 +super.put("lib/java/awt/Font.class" , o);
2157 +super.put("lib/java/awt/Window.class" , o);
2158 +super.put("lib/java/awt/FocusManager.class" , o);
2159 +super.put("lib/java/awt/Panel.class" , o);
2160 +super.put("lib/java/awt/Container.class" , o);
2161 +super.put("lib/java/awt/Graphics.class" , o);
2162 +super.put("lib/java/awt/CheckboxMenuItem.class" , o);
2163 +super.put("lib/java/awt/Canvas.class" , o);
2164 +super.put("lib/java/awt/Frame.class" , o);
2165 +super.put("lib/java/awt/Choice.class" , o);
2166 +super.put("lib/java/awt/Event.class" , o);
2167 +super.put("lib/java/awt/TextArea.class" , o);
2168 +super.put("lib/java/awt/AWTError.class" , o);
2169 +super.put("lib/java/awt/Polygon.class" , o);
2170 +super.put("lib/java/awt/FlowLayout.class" , o);
2171 +super.put("lib/java/awt/Point.class" , o);
2172 +super.put("lib/java/awt/FileDialog.class" , o);
2173 +super.put("lib/java/awt/Scrollbar.class" , o);
2174 +super.put("lib/java/awt/Dimension.class" , o);
2175 +super.put("lib/java/awt/Color.class" , o);
2176 +super.put("lib/java/awt/Button.class" , o);
2177 +super.put("lib/java/awt/LayoutManager.class" , o);
2178 +super.put("lib/java/awt/Rectangle.class" , o);
2179 +super.put("lib/java/awt/BorderLayout.class" , o);
2180 +super.put("lib/java/awt/GridLayout.class" , o);
2181 +super.put("lib/java/awt/GridBagConstraints.class" , o);
2182 +super.put("lib/java/awt/GridBagLayout.class" , o);
2183 +super.put("lib/java/awt/GridBagLayoutInfo.class" , o);
2184 +super.put("lib/java/awt/CardLayout.class" , o);
2185 +super.put("lib/java/awt/MediaTracker.class" , o);
2186 +super.put("lib/java/awt/MediaEntry.class" , o);
2187 +super.put("lib/java/awt/ImageMediaEntry.class" , o);
2188 +super.put("lib/java/awt/AWTException.class" , o);
2189 +super.put("lib/java/net/URL.class" , o);
2190 +super.put("lib/java/net/URLStreamHandlerFactory.class" , o);
2191 +super.put("lib/java/net/InetAddress.class" , o);
2192 +super.put("lib/java/net/UnknownContentHandler.class" , o);
2193 +super.put("lib/java/net/UnknownHostException.class" , o);
2194 +super.put("lib/java/net/URLStreamHandler.class" , o);
2195 +super.put("lib/java/net/URLConnection.class" , o);
2196 +super.put("lib/java/net/MalformedURLException.class" , o);
2197 +super.put("lib/java/net/ContentHandlerFactory.class" , o);
2198 +super.put("lib/java/net/ContentHandler.class" , o);
2199 +super.put("lib/java/net/UnknownServiceException.class" , o);
2200 +super.put("lib/java/net/ServerSocket.class" , o);
2201 +super.put("lib/java/net/PlainSocketImpl.class" , o);
2202 +super.put("lib/java/net/SocketImpl.class" , o);
2203 +super.put("lib/java/net/ProtocolException.class" , o);
2204 +super.put("lib/java/net/SocketException.class" , o);
2205 +super.put("lib/java/net/SocketInputStream.class" , o);
2206 +super.put("lib/java/net/Socket.class" , o);
2207 +super.put("lib/java/net/SocketImplFactory.class" , o);
2208 +super.put("lib/java/net/SocketOutputStream.class" , o);
2209 +super.put("lib/java/net/DatagramPacket.class" , o);
2210 +super.put("lib/java/net/DatagramSocket.class" , o);
2211 +super.put("lib/java/net/URLEncoder.class" , o);
2212 +super.put("lib/java/applet/Applet.class" , o);
2213 +super.put("lib/java/applet/AppletContext.class" , o);
2214 +super.put("lib/java/applet/AudioClip.class" , o);
2215 +super.put("lib/java/applet/AppletStub.class" , o);
2216 +super.put("lib/sun/tools/debug/BreakpointQueue.class" , o);
2217 +super.put("lib/sun/tools/debug/DebuggerCallback.class" , o);
2218 +super.put("lib/sun/tools/debug/RemoteThread.class" , o);
2219 +super.put("lib/sun/tools/debug/StackFrame.class" , o);
2220 +super.put("lib/sun/tools/debug/RemoteAgent.class" , o);
2221 +super.put("lib/sun/tools/debug/AgentConstants.class" , o);
2222 +super.put("lib/sun/tools/debug/AgentIn.class" , o);
2223 +super.put("lib/sun/tools/debug/RemoteObject.class" , o);
2224 +super.put("lib/sun/tools/debug/RemoteStackVariable.class" , o);
2225 +super.put("lib/sun/tools/debug/RemoteValue.class" , o);
2226 +super.put("lib/sun/tools/debug/RemoteClass.class" , o);
2227 +super.put("lib/sun/tools/debug/Agent.class" , o);
2228 +super.put("lib/sun/tools/debug/RemoteBoolean.class" , o);
2229 +super.put("lib/sun/tools/debug/RemoteChar.class" , o);
2230 +super.put("lib/sun/tools/debug/RemoteString.class" , o);
2231 +super.put("lib/sun/tools/debug/NoSessionException.class" , o);
2232 +super.put("lib/sun/tools/debug/Field.class" , o);
2233 +super.put("lib/sun/tools/debug/NoSuchLineNumberException.class" , o);
2234 +super.put("lib/sun/tools/debug/RemoteShort.class" , o);
2235 +super.put("lib/sun/tools/debug/RemoteThreadGroup.class" , o);
2236 +super.put("lib/sun/tools/debug/RemoteInt.class" , o);
2237 +super.put("lib/sun/tools/debug/ResponseStream.class" , o);
2238 +super.put("lib/sun/tools/debug/RemoteDouble.class" , o);
2239 +super.put("lib/sun/tools/debug/LocalVariable.class" , o);
2240 +super.put("lib/sun/tools/debug/BreakpointSet.class" , o);
2241 +super.put("lib/sun/tools/debug/RemoteStackFrame.class" , o);
2242 +super.put("lib/sun/tools/debug/MainThread.class" , o);
2243 +super.put("lib/sun/tools/debug/BreakpointHandler.class" , o);
2244 +super.put("lib/sun/tools/debug/AgentOutputStream.class" , o);
2245 +super.put("lib/sun/tools/debug/RemoteLong.class" , o);
2246 +super.put("lib/sun/tools/debug/RemoteFloat.class" , o);
2247 +super.put("lib/sun/tools/debug/RemoteArray.class" , o);
2248 +super.put("lib/sun/tools/debug/InvalidPCException.class" , o);
2249 +super.put("lib/sun/tools/debug/LineNumber.class" , o);
2250 +super.put("lib/sun/tools/debug/RemoteField.class" , o);
2251 +super.put("lib/sun/tools/debug/NoSuchFieldException.class" , o);
2252 +super.put("lib/sun/tools/debug/RemoteByte.class" , o);
2253 +super.put("lib/sun/tools/debug/EmptyApp.class" , o);
2254 +super.put("lib/sun/tools/debug/RemoteDebugger.class" , o);
2255 +super.put("lib/sun/tools/java/RuntimeConstants.class" , o);
2256 +super.put("lib/sun/tools/java/Constants.class" , o);
2257 +super.put("lib/sun/tools/java/Environment.class" , o);
2258 +super.put("lib/sun/tools/java/ClassPath.class" , o);
2259 +super.put("lib/sun/tools/java/ClassDeclaration.class" , o);
2260 +super.put("lib/sun/tools/java/FieldDefinition.class" , o);
2261 +super.put("lib/sun/tools/java/Type.class" , o);
2262 +super.put("lib/sun/tools/java/ClassNotFound.class" , o);
2263 +super.put("lib/sun/tools/java/ClassType.class" , o);
2264 +super.put("lib/sun/tools/java/ClassDefinition.class" , o);
2265 +super.put("lib/sun/tools/java/Parser.class" , o);
2266 +super.put("lib/sun/tools/java/ClassPathEntry.class" , o);
2267 +super.put("lib/sun/tools/java/CompilerError.class" , o);
2268 +super.put("lib/sun/tools/java/Identifier.class" , o);
2269 +super.put("lib/sun/tools/java/Package.class" , o);
2270 +super.put("lib/sun/tools/java/ClassFile.class" , o);
2271 +super.put("lib/sun/tools/java/Imports.class" , o);
2272 +super.put("lib/sun/tools/java/ArrayType.class" , o);
2273 +super.put("lib/sun/tools/java/AmbiguousField.class" , o);
2274 +super.put("lib/sun/tools/java/MethodType.class" , o);
2275 +super.put("lib/sun/tools/java/Scanner.class" , o);
2276 +super.put("lib/sun/tools/java/SyntaxError.class" , o);
2277 +super.put("lib/sun/tools/java/BinaryClass.class" , o);
2278 +super.put("lib/sun/tools/java/BinaryField.class" , o);
2279 +super.put("lib/sun/tools/java/AmbiguousClass.class" , o);
2280 +super.put("lib/sun/tools/java/BinaryConstantPool.class" , o);
2281 +super.put("lib/sun/tools/java/ScannerInputStream.class" , o);
2282 +super.put("lib/sun/tools/java/BinaryAttribute.class" , o);
2283 +super.put("lib/sun/tools/java/BinaryCode.class" , o);
2284 +super.put("lib/sun/tools/java/BinaryExceptionHandler.class" , o);
2285 +super.put("lib/sun/tools/javac/Main.class" , o);
2286 +super.put("lib/sun/tools/javac/SourceClass.class" , o);
2287 +super.put("lib/sun/tools/javac/CompilerField.class" , o);
2288 +super.put("lib/sun/tools/javac/SourceField.class" , o);
2289 +super.put("lib/sun/tools/javac/BatchEnvironment.class" , o);
2290 +super.put("lib/sun/tools/javac/ErrorConsumer.class" , o);
2291 +super.put("lib/sun/tools/javac/ErrorMessage.class" , o);
2292 +super.put("lib/sun/tools/javac/BatchParser.class" , o);
2293 +super.put("lib/sun/tools/zip/ZipFile.class" , o);
2294 +super.put("lib/sun/tools/zip/ZipEntry.class" , o);
2295 +super.put("lib/sun/tools/zip/ZipFileInputStream.class" , o);
2296 +super.put("lib/sun/tools/zip/ZipConstants.class" , o);
2297 +super.put("lib/sun/tools/zip/ZipFormatException.class" , o);
2298 +super.put("lib/sun/tools/zip/ZipReaderInputStream.class" , o);
2299 +super.put("lib/sun/tools/zip/ZipReader.class" , o);
2300 +super.put("lib/sun/tools/tree/ConstantExpression.class" , o);
2301 +super.put("lib/sun/tools/tree/LocalField.class" , o);
2302 +super.put("lib/sun/tools/tree/Expression.class" , o);
2303 +super.put("lib/sun/tools/tree/IncDecExpression.class" , o);
2304 +super.put("lib/sun/tools/tree/SuperExpression.class" , o);
2305 +super.put("lib/sun/tools/tree/NaryExpression.class" , o);
2306 +super.put("lib/sun/tools/tree/StringExpression.class" , o);
2307 +super.put("lib/sun/tools/tree/UnaryExpression.class" , o);
2308 +super.put("lib/sun/tools/tree/Context.class" , o);
2309 +super.put("lib/sun/tools/tree/ExpressionStatement.class" , o);
2310 +super.put("lib/sun/tools/tree/ConditionVars.class" , o);
2311 +super.put("lib/sun/tools/tree/Node.class" , o);
2312 +super.put("lib/sun/tools/tree/CharExpression.class" , o);
2313 +super.put("lib/sun/tools/tree/CaseStatement.class" , o);
2314 +super.put("lib/sun/tools/tree/LessExpression.class" , o);
2315 +super.put("lib/sun/tools/tree/IntegerExpression.class" , o);
2316 +super.put("lib/sun/tools/tree/SubtractExpression.class" , o);
2317 +super.put("lib/sun/tools/tree/ArrayAccessExpression.class" , o);
2318 +super.put("lib/sun/tools/tree/TryStatement.class" , o);
2319 +super.put("lib/sun/tools/tree/BinaryEqualityExpression.class" , o);
2320 +super.put("lib/sun/tools/tree/Statement.class" , o);
2321 +super.put("lib/sun/tools/tree/AssignSubtractExpression.class" , o);
2322 +super.put("lib/sun/tools/tree/FinallyStatement.class" , o);
2323 +super.put("lib/sun/tools/tree/ForStatement.class" , o);
2324 +super.put("lib/sun/tools/tree/DivRemExpression.class" , o);
2325 +super.put("lib/sun/tools/tree/BinaryExpression.class" , o);
2326 +super.put("lib/sun/tools/tree/ShiftRightExpression.class" , o);
2327 +super.put("lib/sun/tools/tree/AssignMultiplyExpression.class" , o);
2328 +super.put("lib/sun/tools/tree/BooleanExpression.class" , o);
2329 +super.put("lib/sun/tools/tree/BinaryArithmeticExpression.class" , o);
2330 +super.put("lib/sun/tools/tree/ThrowStatement.class" , o);
2331 +super.put("lib/sun/tools/tree/AssignDivideExpression.class" , o);
2332 +super.put("lib/sun/tools/tree/AssignShiftLeftExpression.class" , o);
2333 +super.put("lib/sun/tools/tree/NewArrayExpression.class" , o);
2334 +super.put("lib/sun/tools/tree/AndExpression.class" , o);
2335 +super.put("lib/sun/tools/tree/AssignBitOrExpression.class" , o);
2336 +super.put("lib/sun/tools/tree/BreakStatement.class" , o);
2337 +super.put("lib/sun/tools/tree/SynchronizedStatement.class" , o);
2338 +super.put("lib/sun/tools/tree/PreDecExpression.class" , o);
2339 +super.put("lib/sun/tools/tree/CompoundStatement.class" , o);
2340 +super.put("lib/sun/tools/tree/DoubleExpression.class" , o);
2341 +super.put("lib/sun/tools/tree/ConvertExpression.class" , o);
2342 +super.put("lib/sun/tools/tree/NullExpression.class" , o);
2343 +super.put("lib/sun/tools/tree/LessOrEqualExpression.class" , o);
2344 +super.put("lib/sun/tools/tree/IdentifierExpression.class" , o);
2345 +super.put("lib/sun/tools/tree/ReturnStatement.class" , o);
2346 +super.put("lib/sun/tools/tree/BitNotExpression.class" , o);
2347 +super.put("lib/sun/tools/tree/LongExpression.class" , o);
2348 +super.put("lib/sun/tools/tree/VarDeclarationStatement.class" , o);
2349 +super.put("lib/sun/tools/tree/MethodExpression.class" , o);
2350 +super.put("lib/sun/tools/tree/ThisExpression.class" , o);
2351 +super.put("lib/sun/tools/tree/BitOrExpression.class" , o);
2352 +super.put("lib/sun/tools/tree/PositiveExpression.class" , o);
2353 +super.put("lib/sun/tools/tree/IfStatement.class" , o);
2354 +super.put("lib/sun/tools/tree/FloatExpression.class" , o);
2355 +super.put("lib/sun/tools/tree/NotEqualExpression.class" , o);
2356 +super.put("lib/sun/tools/tree/InstanceOfExpression.class" , o);
2357 +super.put("lib/sun/tools/tree/NotExpression.class" , o);
2358 +super.put("lib/sun/tools/tree/BitAndExpression.class" , o);
2359 +super.put("lib/sun/tools/tree/DivideExpression.class" , o);
2360 +super.put("lib/sun/tools/tree/ShortExpression.class" , o);
2361 +super.put("lib/sun/tools/tree/RemainderExpression.class" , o);
2362 +super.put("lib/sun/tools/tree/NewInstanceExpression.class" , o);
2363 +super.put("lib/sun/tools/tree/SwitchStatement.class" , o);
2364 +super.put("lib/sun/tools/tree/AddExpression.class" , o);
2365 +super.put("lib/sun/tools/tree/AssignOpExpression.class" , o);
2366 +super.put("lib/sun/tools/tree/EqualExpression.class" , o);
2367 +super.put("lib/sun/tools/tree/PostIncExpression.class" , o);
2368 +super.put("lib/sun/tools/tree/GreaterExpression.class" , o);
2369 +super.put("lib/sun/tools/tree/PostDecExpression.class" , o);
2370 +super.put("lib/sun/tools/tree/AssignExpression.class" , o);
2371 +super.put("lib/sun/tools/tree/WhileStatement.class" , o);
2372 +super.put("lib/sun/tools/tree/ContinueStatement.class" , o);
2373 +super.put("lib/sun/tools/tree/ConditionalExpression.class" , o);
2374 +super.put("lib/sun/tools/tree/AssignAddExpression.class" , o);
2375 +super.put("lib/sun/tools/tree/BinaryBitExpression.class" , o);
2376 +super.put("lib/sun/tools/tree/CastExpression.class" , o);
2377 +super.put("lib/sun/tools/tree/AssignBitXorExpression.class" , o);
2378 +super.put("lib/sun/tools/tree/ArrayExpression.class" , o);
2379 +super.put("lib/sun/tools/tree/InlineMethodExpression.class" , o);
2380 +super.put("lib/sun/tools/tree/InlineNewInstanceExpression.class" , o);
2381 +super.put("lib/sun/tools/tree/CodeContext.class" , o);
2382 +super.put("lib/sun/tools/tree/AssignShiftRightExpression.class" , o);
2383 +super.put("lib/sun/tools/tree/UnsignedShiftRightExpression.class" , o);
2384 +super.put("lib/sun/tools/tree/AssignBitAndExpression.class" , o);
2385 +super.put("lib/sun/tools/tree/ShiftLeftExpression.class" , o);
2386 +super.put("lib/sun/tools/tree/CatchStatement.class" , o);
2387 +super.put("lib/sun/tools/tree/IntExpression.class" , o);
2388 +super.put("lib/sun/tools/tree/TypeExpression.class" , o);
2389 +super.put("lib/sun/tools/tree/CommaExpression.class" , o);
2390 +super.put("lib/sun/tools/tree/AssignUnsignedShiftRightExpression.class" , o);
2391 +super.put("lib/sun/tools/tree/ExprExpression.class" , o);
2392 +super.put("lib/sun/tools/tree/AssignRemainderExpression.class" , o);
2393 +super.put("lib/sun/tools/tree/ByteExpression.class" , o);
2394 +super.put("lib/sun/tools/tree/BinaryAssignExpression.class" , o);
2395 +super.put("lib/sun/tools/tree/DoStatement.class" , o);
2396 +super.put("lib/sun/tools/tree/DeclarationStatement.class" , o);
2397 +super.put("lib/sun/tools/tree/MultiplyExpression.class" , o);
2398 +super.put("lib/sun/tools/tree/InlineReturnStatement.class" , o);
2399 +super.put("lib/sun/tools/tree/BitXorExpression.class" , o);
2400 +super.put("lib/sun/tools/tree/BinaryCompareExpression.class" , o);
2401 +super.put("lib/sun/tools/tree/BinaryShiftExpression.class" , o);
2402 +super.put("lib/sun/tools/tree/CheckContext.class" , o);
2403 +super.put("lib/sun/tools/tree/PreIncExpression.class" , o);
2404 +super.put("lib/sun/tools/tree/GreaterOrEqualExpression.class" , o);
2405 +super.put("lib/sun/tools/tree/FieldExpression.class" , o);
2406 +super.put("lib/sun/tools/tree/OrExpression.class" , o);
2407 +super.put("lib/sun/tools/tree/BinaryLogicalExpression.class" , o);
2408 +super.put("lib/sun/tools/tree/NegativeExpression.class" , o);
2409 +super.put("lib/sun/tools/tree/LengthExpression.class" , o);
2410 +super.put("lib/sun/tools/asm/Assembler.class" , o);
2411 +super.put("lib/sun/tools/asm/Instruction.class" , o);
2412 +super.put("lib/sun/tools/asm/LocalVariable.class" , o);
2413 +super.put("lib/sun/tools/asm/ArrayData.class" , o);
2414 +super.put("lib/sun/tools/asm/LocalVariableTable.class" , o);
2415 +super.put("lib/sun/tools/asm/SwitchDataEnumeration.class" , o);
2416 +super.put("lib/sun/tools/asm/ConstantPool.class" , o);
2417 +super.put("lib/sun/tools/asm/ConstantPoolData.class" , o);
2418 +super.put("lib/sun/tools/asm/NameAndTypeConstantData.class" , o);
2419 +super.put("lib/sun/tools/asm/NumberConstantData.class" , o);
2420 +super.put("lib/sun/tools/asm/FieldConstantData.class" , o);
2421 +super.put("lib/sun/tools/asm/TryData.class" , o);
2422 +super.put("lib/sun/tools/asm/Label.class" , o);
2423 +super.put("lib/sun/tools/asm/SwitchData.class" , o);
2424 +super.put("lib/sun/tools/asm/CatchData.class" , o);
2425 +super.put("lib/sun/tools/asm/StringExpressionConstantData.class" , o);
2426 +super.put("lib/sun/tools/asm/NameAndTypeData.class" , o);
2427 +super.put("lib/sun/tools/asm/StringConstantData.class" , o);
2428 +super.put("lib/sun/tools/asm/ClassConstantData.class" , o);
2429 +super.put("lib/sun/tools/ttydebug/TTY.class" , o);
2430 +super.put("lib/sun/tools/javadoc/Main.class" , o);
2431 +super.put("lib/sun/tools/javadoc/DocumentationGenerator.class" , o);
2432 +super.put("lib/sun/tools/javadoc/HTMLDocumentationGenerator.class" , o);
2433 +super.put("lib/sun/tools/javadoc/MIFDocumentationGenerator.class" , o);
2434 +super.put("lib/sun/tools/javadoc/MIFPrintStream.class" , o);
2435 +super.put("lib/sun/net/MulticastSocket.class" , o);
2436 +super.put("lib/sun/net/URLCanonicalizer.class" , o);
2437 +super.put("lib/sun/net/NetworkClient.class" , o);
2438 +super.put("lib/sun/net/NetworkServer.class" , o);
2439 +super.put("lib/sun/net/ProgressData.class" , o);
2440 +super.put("lib/sun/net/ProgressEntry.class" , o);
2441 +super.put("lib/sun/net/TelnetInputStream.class" , o);
2442 +super.put("lib/sun/net/TelnetProtocolException.class" , o);
2443 +super.put("lib/sun/net/TelnetOutputStream.class" , o);
2444 +super.put("lib/sun/net/TransferProtocolClient.class" , o);
2445 +super.put("lib/sun/net/ftp/FtpInputStream.class" , o);
2446 +super.put("lib/sun/net/ftp/FtpClient.class" , o);
2447 +super.put("lib/sun/net/ftp/FtpLoginException.class" , o);
2448 +super.put("lib/sun/net/ftp/FtpProtocolException.class" , o);
2449 +super.put("lib/sun/net/ftp/IftpClient.class" , o);
2450 +super.put("lib/sun/net/nntp/NewsgroupInfo.class" , o);
2451 +super.put("lib/sun/net/nntp/NntpClient.class" , o);
2452 +super.put("lib/sun/net/nntp/UnknownNewsgroupException.class" , o);
2453 +super.put("lib/sun/net/nntp/NntpProtocolException.class" , o);
2454 +super.put("lib/sun/net/nntp/NntpInputStream.class" , o);
2455 +super.put("lib/sun/net/smtp/SmtpPrintStream.class" , o);
2456 +super.put("lib/sun/net/smtp/SmtpClient.class" , o);
2457 +super.put("lib/sun/net/smtp/SmtpProtocolException.class" , o);
2458 +super.put("lib/sun/net/www/auth/Authenticator.class" , o);
2459 +super.put("lib/sun/net/www/auth/basic.class" , o);
2460 +super.put("lib/sun/net/www/content/text/Generic.class" , o);
2461 +super.put("lib/sun/net/www/content/text/plain.class" , o);
2462 +super.put("lib/sun/net/www/content/image/gif.class" , o);
2463 +super.put("lib/sun/net/www/content/image/jpeg.class" , o);
2464 +super.put("lib/sun/net/www/content/image/x_xbitmap.class" , o);
2465 +super.put("lib/sun/net/www/content/image/x_xpixmap.class" , o);
2466 +super.put("lib/sun/net/www/FormatException.class" , o);
2467 +super.put("lib/sun/net/www/MessageHeader.class" , o);
2468 +super.put("lib/sun/net/www/MeteredStream.class" , o);
2469 +super.put("lib/sun/net/www/ProgressReport.class" , o);
2470 +super.put("lib/sun/net/www/MimeEntry.class" , o);
2471 +super.put("lib/sun/net/www/MimeLauncher.class" , o);
2472 +super.put("lib/sun/net/www/MimeTable.class" , o);
2473 +super.put("lib/sun/net/www/URLConnection.class" , o);
2474 +super.put("lib/sun/net/www/UnknownContentException.class" , o);
2475 +super.put("lib/sun/net/www/UnknownContentHandler.class" , o);
2476 +super.put("lib/sun/net/www/protocol/file/Handler.class" , o);
2477 +super.put("lib/sun/net/www/protocol/file/FileURLConnection.class" , o);
2478 +super.put("lib/sun/net/www/protocol/http/Handler.class" , o);
2479 +super.put("lib/sun/net/www/protocol/http/HttpURLConnection.class" , o);
2480 +super.put("lib/sun/net/www/protocol/http/HttpPostBufferStream.class" , o);
2481 +super.put("lib/sun/net/www/protocol/doc/Handler.class" , o);
2482 +super.put("lib/sun/net/www/protocol/verbatim/Handler.class" , o);
2483 +super.put("lib/sun/net/www/protocol/verbatim/VerbatimConnection.class" , o);
2484 +super.put("lib/sun/net/www/protocol/gopher/GopherClient.class" , o);
2485 +super.put("lib/sun/net/www/protocol/gopher/GopherInputStream.class" , o);
2486 +super.put("lib/sun/net/www/http/UnauthorizedHttpRequestException.class" , o);
2487 +super.put("lib/sun/net/www/http/HttpClient.class" , o);
2488 +super.put("lib/sun/net/www/http/AuthenticationInfo.class" , o);
2489 +super.put("lib/sun/awt/HorizBagLayout.class" , o);
2490 +super.put("lib/sun/awt/VerticalBagLayout.class" , o);
2491 +super.put("lib/sun/awt/VariableGridLayout.class" , o);
2492 +super.put("lib/sun/awt/FocusingTextField.class" , o);
2493 +super.put("lib/sun/awt/win32/MToolkit.class" , o);
2494 +super.put("lib/sun/awt/win32/MMenuBarPeer.class" , o);
2495 +super.put("lib/sun/awt/win32/MButtonPeer.class" , o);
2496 +super.put("lib/sun/awt/win32/Win32Image.class" , o);
2497 +super.put("lib/sun/awt/win32/MScrollbarPeer.class" , o);
2498 +super.put("lib/sun/awt/win32/MDialogPeer.class" , o);
2499 +super.put("lib/sun/awt/win32/MCheckboxMenuItemPeer.class" , o);
2500 +super.put("lib/sun/awt/win32/Win32Graphics.class" , o);
2501 +super.put("lib/sun/awt/win32/MListPeer.class" , o);
2502 +super.put("lib/sun/awt/win32/MWindowPeer.class" , o);
2503 +super.put("lib/sun/awt/win32/MMenuItemPeer.class" , o);
2504 +super.put("lib/sun/awt/win32/ModalThread.class" , o);
2505 +super.put("lib/sun/awt/win32/MCanvasPeer.class" , o);
2506 +super.put("lib/sun/awt/win32/MFileDialogPeer.class" , o);
2507 +super.put("lib/sun/awt/win32/MTextAreaPeer.class" , o);
2508 +super.put("lib/sun/awt/win32/MPanelPeer.class" , o);
2509 +super.put("lib/sun/awt/win32/MComponentPeer.class" , o);
2510 +super.put("lib/sun/awt/win32/MCheckboxPeer.class" , o);
2511 +super.put("lib/sun/awt/win32/MLabelPeer.class" , o);
2512 +super.put("lib/sun/awt/win32/Win32FontMetrics.class" , o);
2513 +super.put("lib/sun/awt/win32/MFramePeer.class" , o);
2514 +super.put("lib/sun/awt/win32/MMenuPeer.class" , o);
2515 +super.put("lib/sun/awt/win32/MChoicePeer.class" , o);
2516 +super.put("lib/sun/awt/win32/MTextFieldPeer.class" , o);
2517 +super.put("lib/sun/awt/win32/Win32PrintJob.class" , o);
2518 +super.put("lib/sun/awt/image/URLImageSource.class" , o);
2519 +super.put("lib/sun/awt/image/ImageWatched.class" , o);
2520 +super.put("lib/sun/awt/image/InputStreamImageSource.class" , o);
2521 +super.put("lib/sun/awt/image/ConsumerQueue.class" , o);
2522 +super.put("lib/sun/awt/image/ImageDecoder.class" , o);
2523 +super.put("lib/sun/awt/image/ImageRepresentation.class" , o);
2524 +super.put("lib/sun/awt/image/ImageInfoGrabber.class" , o);
2525 +super.put("lib/sun/awt/image/XbmImageDecoder.class" , o);
2526 +super.put("lib/sun/awt/image/GifImageDecoder.class" , o);
2527 +super.put("lib/sun/awt/image/ImageFetcher.class" , o);
2528 +super.put("lib/sun/awt/image/PixelStore.class" , o);
2529 +super.put("lib/sun/awt/image/JPEGImageDecoder.class" , o);
2530 +super.put("lib/sun/awt/image/PixelStore8.class" , o);
2531 +super.put("lib/sun/awt/image/ImageFetchable.class" , o);
2532 +super.put("lib/sun/awt/image/OffScreenImageSource.class" , o);
2533 +super.put("lib/sun/awt/image/PixelStore32.class" , o);
2534 +super.put("lib/sun/awt/image/ImageFormatException.class" , o);
2535 +super.put("lib/sun/awt/image/FileImageSource.class" , o);
2536 +super.put("lib/sun/awt/image/Image.class" , o);
2537 +super.put("lib/sun/awt/UpdateClient.class" , o);
2538 +super.put("lib/sun/awt/ScreenUpdaterEntry.class" , o);
2539 +super.put("lib/sun/awt/ScreenUpdater.class" , o);
2540 +super.put("lib/sun/misc/Ref.class" , o);
2541 +super.put("lib/sun/misc/MessageUtils.class" , o);
2542 +super.put("lib/sun/misc/Cache.class" , o);
2543 +super.put("lib/sun/misc/CacheEntry.class" , o);
2544 +super.put("lib/sun/misc/CacheEnumerator.class" , o);
2545 +super.put("lib/sun/misc/CEFormatException.class" , o);
2546 +super.put("lib/sun/misc/CEStreamExhausted.class" , o);
2547 +super.put("lib/sun/misc/CRC16.class" , o);
2548 +super.put("lib/sun/misc/CharacterDecoder.class" , o);
2549 +super.put("lib/sun/misc/BASE64Decoder.class" , o);
2550 +super.put("lib/sun/misc/UCDecoder.class" , o);
2551 +super.put("lib/sun/misc/UUDecoder.class" , o);
2552 +super.put("lib/sun/misc/CharacterEncoder.class" , o);
2553 +super.put("lib/sun/misc/BASE64Encoder.class" , o);
2554 +super.put("lib/sun/misc/HexDumpEncoder.class" , o);
2555 +super.put("lib/sun/misc/UCEncoder.class" , o);
2556 +super.put("lib/sun/misc/UUEncoder.class" , o);
2557 +super.put("lib/sun/misc/Timeable.class" , o);
2558 +super.put("lib/sun/misc/TimerTickThread.class" , o);
2559 +super.put("lib/sun/misc/Timer.class" , o);
2560 +super.put("lib/sun/misc/TimerThread.class" , o);
2561 +super.put("lib/sun/misc/ConditionLock.class" , o);
2562 +super.put("lib/sun/misc/Lock.class" , o);
2563 +super.put("lib/sun/audio/AudioDataStream.class" , o);
2564 +super.put("lib/sun/audio/AudioData.class" , o);
2565 +super.put("lib/sun/audio/AudioDevice.class" , o);
2566 +super.put("lib/sun/audio/AudioPlayer.class" , o);
2567 +super.put("lib/sun/audio/AudioStream.class" , o);
2568 +super.put("lib/sun/audio/NativeAudioStream.class" , o);
2569 +super.put("lib/sun/audio/InvalidAudioFormatException.class" , o);
2570 +super.put("lib/sun/audio/AudioTranslatorStream.class" , o);
2571 +super.put("lib/sun/audio/AudioStreamSequence.class" , o);
2572 +super.put("lib/sun/audio/ContinuousAudioDataStream.class" , o);
2573 +super.put("lib/sun/applet/StdAppletViewerFactory.class" , o);
2574 +super.put("lib/sun/applet/TextFrame.class" , o);
2575 +super.put("lib/sun/applet/AppletViewerFactory.class" , o);
2576 +super.put("lib/sun/applet/AppletViewer.class" , o);
2577 +super.put("lib/sun/applet/AppletCopyright.class" , o);
2578 +super.put("lib/sun/applet/AppletAudioClip.class" , o);
2579 +super.put("lib/sun/applet/AppletSecurity.class" , o);
2580 +super.put("lib/sun/applet/AppletThreadGroup.class" , o);
2581 +super.put("lib/sun/applet/AppletClassLoader.class" , o);
2582 +super.put("lib/sun/applet/AppletPanel.class" , o);
2583 +super.put("lib/sun/applet/AppletViewerPanel.class" , o);
2584 +super.put("lib/sun/applet/AppletProps.class" , o);
2585 +super.put("lib/sun/applet/AppletSecurityException.class" , o);
2586 +super.put("lib/sun/applet/AppletZipClassLoader.class" , o);
2587 +super.put("lib/spec/benchmarks/_202_jess/Activation.java" , o);
2588 +super.put("lib/spec/benchmarks/_202_jess/Binding.java" , o);
2589 +super.put("lib/spec/benchmarks/_202_jess/Context.java" , o);
2590 +super.put("lib/spec/benchmarks/_202_jess/ContextState.java" , o);
2591 +super.put("lib/spec/benchmarks/_202_jess/Deffacts.java" , o);
2592 +super.put("lib/spec/benchmarks/_202_jess/Deffunction.java" , o);
2593 +super.put("lib/spec/benchmarks/_202_jess/Defglobal.java" , o);
2594 +super.put("lib/spec/benchmarks/_202_jess/Defrule.java" , o);
2595 +super.put("lib/spec/benchmarks/_202_jess/Deftemplate.java" , o);
2596 +super.put("lib/spec/benchmarks/_202_jess/Fact.java" , o);
2597 +super.put("lib/spec/benchmarks/_202_jess/Funcall.java" , o);
2598 +super.put("lib/spec/benchmarks/_202_jess/GlobalContext.java" , o);
2599 +super.put("lib/spec/benchmarks/_202_jess/Jesp.java" , o);
2600 +super.put("lib/spec/benchmarks/_202_jess/Jess.java" , o);
2601 +super.put("lib/spec/benchmarks/_202_jess/Main.java" , o);
2602 +super.put("lib/spec/benchmarks/_202_jess/Node.java" , o);
2603 +super.put("lib/spec/benchmarks/_202_jess/Node1.java" , o);
2604 +super.put("lib/spec/benchmarks/_202_jess/Node2.java" , o);
2605 +super.put("lib/spec/benchmarks/_202_jess/NodeNot2.java" , o);
2606 +super.put("lib/spec/benchmarks/_202_jess/NodeTerm.java" , o);
2607 +super.put("lib/spec/benchmarks/_202_jess/NullDisplay.java" , o);
2608 +super.put("lib/spec/benchmarks/_202_jess/Pattern.java" , o);
2609 +super.put("lib/spec/benchmarks/_202_jess/RU.java" , o);
2610 +super.put("lib/spec/benchmarks/_202_jess/Rete.java" , o);
2611 +super.put("lib/spec/benchmarks/_202_jess/ReteCompiler.java" , o);
2612 +super.put("lib/spec/benchmarks/_202_jess/ReteDisplay.java" , o);
2613 +super.put("lib/spec/benchmarks/_202_jess/ReteException.java" , o);
2614 +super.put("lib/spec/benchmarks/_202_jess/StringFunctions.java" , o);
2615 +super.put("lib/spec/benchmarks/_202_jess/Successor.java" , o);
2616 +super.put("lib/spec/benchmarks/_202_jess/Test1.java" , o);
2617 +super.put("lib/spec/benchmarks/_202_jess/Test2.java" , o);
2618 +super.put("lib/spec/benchmarks/_202_jess/Token.java" , o);
2619 +super.put("lib/spec/benchmarks/_202_jess/TokenVector.java" , o);
2620 +super.put("lib/spec/benchmarks/_202_jess/Userfunction.java" , o);
2621 +super.put("lib/spec/benchmarks/_202_jess/Value.java" , o);
2622 +super.put("lib/spec/benchmarks/_202_jess/ValueVector.java" , o);
2623 +
2624 +}
2625 +
2626 +/**
2627 + Checks whether the given file exists in the list of existing files
2628 + */
2629 +public boolean exists(String filename){
2630 +
2631 +//   System.out.println( "*** "+filename+" = "+containsKey(filename) );
2632 +  return containsKey(filename);
2633 +
2634 +}
2635 +}
2636 diff -Nu mpegaudio1/setup.sh mpegaudio/setup.sh
2637 --- mpegaudio1/setup.sh Thu Jan  1 01:00:00 1970
2638 +++ mpegaudio/setup.sh  Sat Nov 30 18:06:34 2002
2639 @@ -0,0 +1,3 @@
2640 +mkdir -p spec/benchmarks/_222_mpegaudio
2641 +mv *.class spec/benchmarks/_222_mpegaudio
2642 +ln -s /tmp/output.wav .
2643 diff -Nu mpegaudio1/PrintStream.java mpegaudio/PrintStream.java
2644 --- mpegaudio1/PrintStream.java Thu Jan  1 01:00:00 1970
2645 +++ mpegaudio/PrintStream.java  Sat Nov 30 18:13:49 2002
2646 @@ -0,0 +1,65 @@
2647 +/*
2648 + * %W% %G%
2649 + *
2650 + * Copyright (c) 1998 Standard Performance Evaluation Corporation (SPEC)
2651 + *               All rights reserved.
2652 + * Copyright (c) 1997,1998 Sun Microsystems, Inc. All rights reserved.
2653 + *
2654 + * This source code is provided as is, without any express or implied warranty.
2655 + */
2656 +
2657 +package spec.io;
2658 +
2659 +/**
2660 + * This class implements a special form of PrintStream that is used by
2661 + * the benchmarks. The class vaieable spec.harness.Context.out is made
2662 + * to point to an instance of this class. The purpuse of the class is to
2663 + * record validity check information with the recorded output. This is done
2664 + * using one of nine integer values (0-8). 0 means the default validity checking
2665 + * is to be used and is what a Context.out.println() would employ. The numbers
2666 + * 1 through 8 are used to set various valitity cheching rules. This class
2667 + * implements a set of println() type methods that allow the text output to be
2668 + * does so within the context of a certain validity cheching value.
2669 + *
2670 + * These routines will output the valitity check value to the associated
2671 + * OutputStream unchanged. This will cause them to be output as the character
2672 + * values \u0000 to \u0008 these values are not normally used (the next one
2673 + * \u0009 is) so this should not cause a problem. However this is checked for
2674 + * in ValidityCheckOutputStream.
2675 + *
2676 + * @see ConsoleOutputStream
2677 + * @see ValidityCheckOutputStream
2678 + */
2679 +public
2680 +class PrintStream extends java.io.PrintStream {
2681 +    /**
2682 +     * The actual output stream. This is the same as 'out' in our superclass but
2683 +     * kept here as well to avoid a lot of runtime casting.
2684 +     */
2685 +
2686 +    /**
2687 +     * Creates a new PrintStream.
2688 +     * @param out the output stream
2689 +     */
2690 +    public PrintStream(java.io.OutputStream out) {
2691 +       super(out, false);
2692 +    }
2693 +
2694 +    /**
2695 +     * Print a string in a validity context
2696 +     * @param v the validity context value.
2697 +     * @param s the data to be printed.
2698 +     */
2699 +    synchronized public void print(char v, String s) {
2700 +       super.print(s);
2701 +    }
2702 +
2703 +    /**
2704 +     * Print a string in a validity context
2705 +     * @param v the validity context value.
2706 +     * @param s the data to be printed.
2707 +     */
2708 +    synchronized public void println(char v, String s) {
2709 +       super.println(s);
2710 +    }
2711 +}
2712 --- mpegaudio2/Main.java        Mon Dec  9 12:36:17 2002
2713 +++ mpegaudio/Main.java Mon Dec  9 12:34:26 2002
2714 @@ -7,15 +7,15 @@
2715   * This source code is provided as is, without any express or implied warranty.
2716   */
2717
2718 -package spec.benchmarks._222_mpegaudio;
2719 -import spec.harness.*;
2720 +import spec.benchmarks._222_mpegaudio.*;
2721 +//import spec.harness.*;
2722
2723
2724 -public class Main implements SpecBenchmark {
2725 +public class Main {
2726
2727      static long runBenchmark( String[] args ) {
2728
2729 -       int speed = spec.harness.Context.getSpeed();
2730 +       int speed = 100;
2731         int iter  = 1;
2732         String name = "track16.mp3";
2733
2734 @@ -34,11 +34,11 @@
2735             args[0] = "input/"+name;
2736         }
2737
2738 -       spec.harness.Context.out.println( "MPEG Audio - Decoding " + args[0] + " " + iter + " time" + (iter > 1 ? "s" : "") );
2739 +       System.out.println( "MPEG Audio - Decoding " + args[0] + " " + iter + " time" + (iter > 1 ? "s" : "") );
2740         long startTime = System.currentTimeMillis();
2741
2742         for( int i = 0 ; i < iter ; i++ ) {
2743 -           BenchDec.main( args );
2744 +           JavaDec.main( args );
2745         }
2746
2747         return System.currentTimeMillis() - startTime;
2748 diff -Nu mpegaudio2/postoutput.sh mpegaudio/postoutput.sh
2749 --- mpegaudio2/postoutput.sh    Thu Jan  1 01:00:00 1970
2750 +++ mpegaudio/postoutput.sh     Mon Dec  9 15:11:24 2002
2751 @@ -0,0 +1 @@
2752 +brik -Gb output.wav > mpegaudio.output