convert-parv.pl

目前最精确的磁盘模拟器的第3版

       for($d = 0; $d < $devswithspec; $d++) {
	   $num = $c + $d;
	   push(@devices, "$devtype$num");
	   $devtypes[$num] = $devtype;
	   print STDERR "DEV $devtype$num\n";
       }



    if($devtype eq "disk") {

	$line = shift(@lines); $linenum = shift(@linenums);
	if($line =~ /Disk brand name: (.*)/)
	{
	    print("# $1\n");
	    
	    if($devswithspec > 1) {
		$maxdrv = $c + $numSDs - 1;
		$instances{"disk$c .. disk$maxdrv"} = "$1";
	    }
	    else {
		$instances{"disk$c"} = "$1";
	    }
	    
	}
	else {
	    print STDERR "*** error on line $linenum: $line.\n";
	    exit(1);
	}


	$line = shift(@lines); $linenum = shift(@linenums);
	if($line =~ /Disk specification file: ([^\s]+)/)
	{
	    print("source $1\n\n");
	}
	else {
	    print STDERR "*** error on line $linenum: $line.\n";
	    exit(1);
	}

	
    }
    elsif ($devtype eq "mems2") {
	for($d = 0; $d < $devswithspec; $d++) {
	    $num = $c + $d;
	    push(@devices, "mems$num");
	}

	$line = shift(@lines); $linenum = shift(@linenums);	
	if($line =~ /Device type: (.*)/) {
	    $memstype = $1;
	}
	else { 
	    print STDERR "*** error on line $linenum: $line.\n";
	    exit(1);
	}

	if($devswithspec > 1) {
	    $maxdrv = $c + $numSDs - 1;
	    $instances{"mems2$c .. mems2$maxdrv"} = "$memstype";
	}
	else {
	    $instances{"mems2$c"} = "$memstype";
	}


	$line = shift(@lines); $linenum = shift(@linenums);	
	if($line =~ /Device specification file: (.*)/) {
	    print "# source the mems2 dev spec file\n";
	    print "source $1\n\n";
	}
	else {
	    print "mems2 $memstype {\n";
	    for($d = 0; $d < 40; $d++) {
		$line = shift(@lines); $linenum = shift(@linenums);
		$line =~ s/:/ = /;
		print("     $line\n");
	    }
	    print "}  # end of $memstype spec\n\n";
	}
    }
    elsif ($devtype eq "sd") {
	print "simpledisk SD$c {\n";
	for $c (0 .. 7) {
	    if($c) { print ",\n"; }
	    $line = shift(@lines); $linenum = shift(@linenums);
	    $line =~ s/:/ = /;
	    $line =~ s/\(.*\)//;

	    $line =~ s/Number of blocks/Block count/;
	    $line =~ s/Access time (in msecs)/Constant access time/;
	    $line =~ s/Max queue length at simpledisk/Max queue length/;

	    print("   $line");
	}
	# deal with the ioqueue
	for $d (0 .. 12) {
	    # for prev. param
	    if($d) { print ",\n"; }
	    
	    $line = shift(@lines); $linenum = shift(@linenums);
	    if(!$d && !($line =~ /Scheduling policy.*/)) { 
		unshift(@lines, $line); 
		unshift(@linenums, $linenum);
		last;
	    }
	    elsif(!$d) {
		print ",\n";
		print "   Scheduler = ioqueue {\n";
	    }
	    $line =~ s/:/ =/;
	    print("      $line");
	    if($d == 12) { print "\n    # end of ioqueue spec\n  }"; }
	    }
	print "   # end of SD$c spec\n}\n\n";
	
	if($devswithspec > 1) {
	    $maxdrv = $c + $numSDs - 1;
	    $instances{"sd$c .. $sd$maxdrv"} = "SD$c";
	}
	else {
	    $instances{"sd$c"} = "SD$c";
	}
    }
    else {
	print STDERR "*** error: unknown device type $devtype\n";
	exit(1);
    }

    if($devswithspec > 1) { $numdevs -= ($devswithspec + 1); }
}





##
## Component Instantiation
##

print("# component instantiation\n");

print "instantiate [ statfoo ] as Stats\n";
foreach $inst (keys(%instances)) {
    print("instantiate [ $inst ] as $instances{$inst}\n");
    $c++;
}   

print("# end of component instantiation\n\n");

print "$iomaps";



#
# PHYSICAL ORGANIZATION
#
print "# system topology\n";
print "topology disksim_iodriver driver0 [\n";

# read and ignore driver

$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /PHYSICAL ORGANIZATION/)
{
}
else {
    print STDERR "*** error on line $linenum: $line.\n";
    exit(1);
}

$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /Driver #1/) { }
else {
    print STDERR "*** error on line $linenum: $line.\n";
    exit(1);
}

$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /# of connected buses.*/) { }
else {
    print STDERR "*** error on line $linenum: $line.\n";
    exit(1);
}

$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /Connected buses: ([0-9]+)/)
{
#    print "bus bus$1 [ \n";
    $num = $1 - 1;
    $topbus = "bus$num";
}
else {
    print STDERR "*** error on line $linenum: $line.\n";
    exit(1);
}

#
# TOPO: controllers
#
@ctlrtopo = ();
for($c = 0; $c < $numctlrs; $c++) {
    @children = ();
    $line = shift(@lines); $linenum = shift(@linenums);
    if($line =~ /Controller #([0-9]+)(-([0-9]+))?/)
       {
#	   print("$1 $2 $3\n");
	   if($2 ne undef) { $busrange = 1; $lastbus = $3; }
	   else { $busrange = 0; $lastbus = $1; }
	   $firstbus = $1;
	   # v2 counts some things from 1 instead of 0
	   $firstbus--; $lastbus--;
	   if($busrange) {
	       $c += ($lastbus - $firstbus);
	   }
       }
       else {
	   print STDERR "foo *** error on line $linenum: $line.\n";
	   exit(1);
       }

       $line = shift(@lines); $linenum = shift(@linenums);
       if($line =~ /# of connected buses: ([0-9]+)/) {
	  $ctlrbuses = $1;
       }
       else {
	 print STDERR "*** error on line $linenum: $line.\n";
	 exit(1);
       }

       for($d = 0; $d < $ctlrbuses; $d++) {
	   $line = shift(@lines); $linenum = shift(@linenums);	  
	   if($line =~ /Connected buses: (.*)/)
	   {
	       $busspec = $1;
	       if($busspec =~ /#([+-][0-9]+)/) {
		  for($e = $firstbus; $e <= $lastbus; $e++) {
		      $targetbus = $e + $1;
		      print STDERR "ctlr$e has bus$targetbus\n";
		      push(@{$ctlrtopo[$e]}, "bus$targetbus");
		  }
		  

	      } 
	       elsif($busspec =~ /([0-9]+)/) {
		   if($busrange) {
		       # error
		       print STDERR "*** error: must give relative bus number for bus range\n";
		       exit(1);
		   }
		   else {
		       $targetbus = $1 - 1;
		       print STDERR "ctlr$c has bus$targetbus\n";
		       push(@{$ctlrtopo[$c]}, "bus$targetbus");
		   }
	       }
	       else {
		   print STDERR "*** error on line $linenum: $line.\n";
		   exit(1);
	       }
	   }
	   else {
	       print STDERR "*** error on line $linenum: $line.\n";
	       exit(1);
	   }
       }

} # done with controllers


#
# TOPO: buses
#
@bustopo = ();
for($c = 0; $c < $numbuses; $c++) {
    # build up a list of children as we go
    @children = ();

    $line = shift(@lines); $linenum = shift(@linenums);
    if($line =~ /Bus #([0-9]+)(-([0-9]+))?/)
       {
#          print("$1 $2 $3\n");
	   if($2 ne undef) { $busrange = 1; $lastbus = $3; }
	   else { $busrange = 0; $lastbus = $1; }
 	   $firstbus = $1;
	   $firstbus--;
	   $lastbus--;
	   if($busrange) { $c += ($lastbus - $firstbus); }

       }
       else {
	   print STDERR "*** error on line $linenum: $line.\n";
	   exit(1);
       }

	$line = shift(@lines); $linenum = shift(@linenums);
	if($line =~ /# of utilized slots: ([0-9]+)/) {
	   $busslots = $1;
        }
	else {
	    print STDERR "*** error on line $linenum: $line.\n";
	    exit(1);
	}

        # loop over slots in bus
	for($d = 0; $d < $busslots; $d++) {
	    $line = shift(@lines); $linenum = shift(@linenums);
#	   print("bus $c slot $d\n");
	    
	    if($line =~ /Slots: (Controllers|Devices) (.*)/)
	    {
		if($1 eq "Controllers") { 
		    $devtype = "ctlr"; 
		}
		else { $devtype = ""; }
		
		$devspec = $2;
		print STDERR "DEVSPEC: $devspec\n";
		if($devspec =~ /^([0-9]+)$/) {
		    if($busrange) {
			print STDERR "*** error: must use #-notation for bus ranges.\n";
			    exit(1);
		    } 
		    
		    $devnum = $1 - 1;

		    if($devtype ne "ctlr") {
			$devices[$devnum] =~ /(mems2|sd|disk)(.*)/;
			$devtype = $1;
			print STDERR "DEVTYPE: $devtype\n";
		    }

		    print STDERR "bus$c has $devtype$devnum\n";
		    
		    push(@{$bustopo[$c]}, "$devtype$devnum");
		    
		}
		elsif($devspec =~ /([0-9]+) ?- ?([0-9]+)/) {
		    if($busrange) {
			print STDERR "*** error: must use #-notation for bus ranges.\n";
 		        exit(1);
		    }
		    
		    $first = $1 - 1;
		    $last = $2 - 1;
		    if($devtype ne "ctlr") {
			$devices[$first] =~ /(mems2|sd|disk)(.*)/;
			$devtype = $1;
		    }
		    for($e = $first; $e <= $last; $e++) {

			push(@{$bustopo[$c]}, "$devtype$e");
			print STDERR "bus$c has $devtype$e\n";
		    }

		 
		    $d += ($last - $first);
		}
		elsif($devspec =~ /#([+-][0-9]+)/) {
		      for($bus = $firstbus; $bus <= $lastbus; $bus++) {
			  $devnum = $1 + $bus;
			  if($devtype ne "ctlr") {
			      $devices[$devnum] =~ /(mems2|sd|disk)(.*)/;
			      $devtype = $1;
			  }
			  push(@{$bustopo[$bus]}, "$devtype$devnum");


			  print STDERR "bus$bus has $devtype$devnum\n";

		      }
		}
		else {
		    print STDERR "*** error on line $linenum: $line.\n";
		    exit(1);
		}
	    }
	    elsif($line =~ /Bus #/) {
		  unshift(@lines, $line);
		  unshift(@linenums, $linenum);
		  next;
	    }
	    else {
		print STDERR "*** error on line $linenum: $line.\n";
		exit(1);
	    }
	}

}


outputBusTopo(\@bustopo, \@ctlrtopo, $topbus, [$topbus], 5);


print "\n     # end of system topology\n]\n\n";
  

#
# SYNCHRONIZATION 
#
$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /SYNCHRONIZATION/) {

} else { error("bad syncset spec"); }

$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /Number of synchronized sets: ([0-9]+)/) {
  $numsyncsets = $1;
} else { error("bad syncset spec"); }
if(! $numsyncsets) {
   print("# no syncsets\n\n");
}
else {
    for $c (0 .. ($numsyncsets - 1)) {
	$line = shift(@lines); $linenum = shift(@linenums);
	if($line =~ /Number of devices.*:\s*([0-9]+)/) {
	    # this parameter seems to serve no purpose ...
	    $line = shift(@lines); $linenum = shift(@linenums);
	    if($line =~ /Synchronized devices: ([0-9]+) ?- ?([0-9]+)/) {
		$d1 = $1;
		$d2 = $2;
		$d1--; $d2--;
		$devices[$d1] =~ /(mems2|sd|disk)(.*)/;
		$devtype = $1;
		print("syncset sync$c { devices = [ $devtype$d1 .. $devtype$d2 ] }\n");
	    } 
	    else { error("bad syncset spec #$c"); }
	    }
    }
}


#
# LOGICAL ORGANIZATION
#

$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /LOGICAL ORGANIZATION/) {} 
else { error("bad logorg spec: $line"); }

$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /# of system-level organizations:\s*([0-9]+)/) {
   $numlogorgs = $1;	
} else { error("bad logorg spec: $line"); }

for $c (0 .. ($numlogorgs - 1)) {
   print("disksim_logorg org$c {\n");
   $line = shift(@lines); $linenum = shift(@linenums);
   if($line =~ /Organization #[0-9]+:\s*(.*)/) {
      @flags = split(/\s+/, $1);
      $numflags = @flags;
      if($numflags != 4) { error("need 4 logorg flags: \"$flags[0]\""); }
      print("   Addressing mode = $flags[0],\n");
      print("   Distribution scheme = $flags[1],\n");
      print("   Redundancy scheme = $flags[2],\n");
#      print("  Addressing mode = $flags[3],\n");
   }

   for $d (0 .. 13) {
      $line = shift(@lines); $linenum = shift(@linenums);
      if($line =~ /Devices:\s*(.*)/) {
         if($1 =~ /([0-9]+)\s*-([0-9]+)\s*/) {
	     $d1 = $1; $d2 = $2;
	     $d1--; $d2--;
	    if($d1 != $d2) { print("   devices = [ $devtypes[$d1]$d1 .. $devtypes[$d2]$d2 ]"); }
	    else { print "   devices = [ $devtypes[$d1]$d1 ]"; }
         } else { error("need a range of devices in logorg spec, not $line"); }
      }
      elsif($line =~ /Number of devices.*/) { }
      elsif($line =~ /High-level device number.*/) { }
      else {
         print ",";
         $line =~ s/:/ = /;
         $line =~ s/\(.*\)//;
	 print("\n   $line");
      }
   }
   print("\n} # end of logorg org$c spec\n\n");
}

# eat ctlr level spec number (unused)
shift(@lines);

#
# Process-Flow Input Parameters
# -----------------------------
#

$line = shift(@lines); $linenum = shift(@linenums);	
if($line =~ /Process-Flow.*/) { } else { error("bad procflow spec"); }
$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /-+/) { } else { error("bad procflow spec"); }





#
# PRINTED PROCESS-FLOW STATISTICS
#

# move this to stats block

# eat these 5 lines -- we already looked at them
for $c (1..5) { shift(@lines); }

#
# GENERAL PROCESS-FLOW PARAMETERS
#
$line = shift(@lines); $linenum = shift(@linenums);	
if($line =~ /GENERAL PROCESS-FLOW PARAMETERS/) 
{
} else { error("bad procflow params"); }
print "disksim_pf Proc {\n";
for $c (1..2) {
  $line = shift(@lines); $linenum = shift(@linenums);
  $line =~ s/:/ = /;
  print("   $line");
  if($c == 1) { print ","; }
  print("\n");
}
print("} # end of process flow spec\n\n");

#
# SYNTHETIC I/O TRACE PARAMETERS
#

print("synthio Synthio {\n");
$line = shift(@lines); $linenum = shift(@linenums);
if($line =~ /SYNTHETIC I\/O TRACE PARAMETERS/) {

} else { error("bad synthio spec"); }

for $c (1 .. 6) {
  $line = shift(@lines); $linenum = shift(@linenums);
  if($line =~ /Number of generators:\s*([0-9]+)/) {
    $numgens = $1;
  }
  else {
    $line =~ s/:/ = /;
    $line =~ s/\(.*\)//;
    print("   $line,\n");
  }
}
print("   Generators = [\n");
for $c (0 .. ($numgens - 1)) {

  $line = shift(@lines); $linenum = shift(@linenums);
  if($line =~ /Generator description.*/) {
  } 
  elsif($line eq undef) { last; }
  else { error("bad generator description line $linenum: $line"); }

  print("     disksim_synthgen { # generator $c \n");

  $line = shift(@lines); $linenum = shift(@linenums);
  if($line =~ /Generators with description:\s*([0-9]+)/) {
     $descgens = $1;
     $numgens -= $descgens; 
     $numgens++;
  }  else { error("bad generator spec line $linenum: $line"); }

  for $d (1 .. 9) {
     $line = shift(@lines); $linenum = shift(@linenums);
     if($line =~ /Number of storage devices:\s*([0-9]+)/) {
        $numdevs = $1;
     }
     elsif($line =~ /First storage device:?\s*([0-9]+)/) {
        $firstdev = $1;
        if($numdevs > 1) {
           $lastdev = $firstdev + $numdevs - 1;
           print("       devices = [ $devtypes[$firstdev]$firstdev .. $devtypes[$lastdev]$lastdev ],\n");
        }
        else {
           print("       devices = [ $devtypes[$firstdev]$firstdev ], \n");
        }
     }
     else {     
        $line =~ s/\(.*\)//;
        $line =~ s/:/ = /;
        print("       $line,\n");
     }
   }

   # distribution parameters
   for $d (1 .. 6) {
      $_ = shift(@lines); $linenum = shift(@linenums);
      s/\(.*\)//; 
#      $foo = $_;
      print("       $_ = [ ");

      $_ = shift(@lines); $linenum = shift(@linenums);
      s/Type of distribution:\s*//;
      if(/normal/) {
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_ ";
      }
      elsif(/exponential/) {
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_ ";
      } 
      elsif(/poisson/) {
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_ ";

      }
      elsif(/twovalue/) {
         $_ = shift(@lines); $linenum = shift(@linenums);
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_ ";

      }
      elsif(/uniform/) {
         $_ = shift(@lines); $linenum = shift(@linenums);
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_, ";
         $_ = shift(@lines); $linenum = shift(@linenums);
	 s/.*:\s*//;
         print "$_ ";
      }
      else { error("no such distribution $_"); }




      print " ]"; if($d != 6) { print(","); } print "\n";
      
   }

  
  
  print("     }");
  if($c != ($numgens - 1)) { print(","); }
  print(" # end of generator $c \n");
}

print("   ] # end of generator list \n");
print("} # end of synthetic workload spec\n");


print("\n\n");