public synchronized void fail() throws Fail {
int err = GetLastError();
Memory buffer = new Memory(2048);
int res =
FormatMessageW(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
null,
err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
buffer,
(int) buffer.size(),
null);
log =
log
&& log(
1,
"fail() %s, Windows GetLastError()= %d, %s\n",
lineno(1),
err,
buffer.getString(0, true));
// FIXME here convert from Windows error code to 'posix' error code
Fail f = new Fail();
throw f;
}
RandomConfig(String[] args) {
Limits fireBrigades = new Limits(10, 15, "fireBrigades", "fire brigades");
Limits policeForces = new Limits(10, 15, "policeForces", "police forces");
Limits ambulanceTeams = new Limits(5, 8, "ambulanceTeams", "ambulance teams");
Limits fireStations = new Limits(1, 1, "fireStations", "fire stations");
Limits policeStations = new Limits(1, 1, "policeStations", "police stations");
Limits ambulanceCenters = new Limits(1, 1, "ambulanceCenters", "ambulance centers");
Limits civilians = new Limits(70, 90, "civilians", "civilians");
Limits refuges = new Limits(1, 5, "refuges", "refuges");
Limits fires = new Limits(2, 8, "fires", "fires");
Limits fireRadius = new Limits(0, 20000, "fireradius", "fire radius");
Limits[] allLimits =
new Limits[] {
fireBrigades,
policeForces,
ambulanceTeams,
fireStations,
policeStations,
ambulanceCenters,
civilians,
refuges,
fires,
fireRadius
};
boolean allowTrappedAgents = false;
boolean bigFires = false;
boolean trappedCivilians = true;
String dir = "";
for (int i = 0; i < args.length; ++i) {
if (args[i].startsWith("-min-")) {
for (int j = 0; j < allLimits.length; ++j) {
if (args[i].equalsIgnoreCase("-min-" + allLimits[j].prefix))
allLimits[j].min = Integer.parseInt(args[++i]);
}
} else if (args[i].startsWith("-max-")) {
for (int j = 0; j < allLimits.length; ++j) {
if (args[i].equalsIgnoreCase("-max-" + allLimits[j].prefix))
allLimits[j].max = Integer.parseInt(args[++i]);
}
} else if (args[i].startsWith("-no-")) {
for (int j = 0; j < allLimits.length; ++j) {
if (args[i].equalsIgnoreCase("-no-" + allLimits[j].prefix)) {
allLimits[j].min = 0;
allLimits[j].max = 0;
}
}
} else if (args[i].startsWith("-set-")) {
int num = Integer.parseInt(args[i + 1]);
for (int j = 0; j < allLimits.length; ++j) {
if (args[i].equalsIgnoreCase("-set-" + allLimits[j].prefix)) {
allLimits[j].min = num;
allLimits[j].max = num;
}
}
++i;
} else if (args[i].equalsIgnoreCase("-t")
|| args[i].equalsIgnoreCase("--allow-trapped-agents")) {
allowTrappedAgents = true;
} else if (args[i].equalsIgnoreCase("-c")
|| args[i].equalsIgnoreCase("--allow-untrapped-civilians")) {
trappedCivilians = false;
} else if (args[i].equalsIgnoreCase("-b") || args[i].equalsIgnoreCase("--big-fires")) {
bigFires = true;
} else if (args[i].equalsIgnoreCase("-d") || args[i].equalsIgnoreCase("--dir")) {
dir = args[i + 1];
} else if (args[i].equalsIgnoreCase("-h") || args[i].equalsIgnoreCase("--help")) {
System.out.println("Usage: RandomConfig [options]");
System.out.println(
"This program will read from \"road.bin\", \"node.bin\" and \"building.bin\" and produce a randomised \"gisini.txt\"");
System.out.println("Options");
System.out.println("=======");
for (int j = 0; j < allLimits.length; ++j) {
System.out.println(
"-min-"
+ allLimits[j].prefix
+ "\tSet the minimum number of "
+ allLimits[j].name
+ " (currently "
+ allLimits[j].min
+ ")");
System.out.println(
"-max-"
+ allLimits[j].prefix
+ "\tSet the maximum number of "
+ allLimits[j].name
+ " (currently "
+ allLimits[j].max
+ ")");
System.out.println(
"-no-"
+ allLimits[j].prefix
+ "\tSet the minimum and maximum of "
+ allLimits[j].name
+ " to zero");
}
System.out.println(
"-t\t--allow-trapped-agents\tAllow rescue agents (fire brigades, police forces and ambulance teams) to be placed inside buildings (default OFF)");
System.out.println(
"-c\t--allow-untrapped-civilians\tAllow civilians to be placed outside buildings (default OFF)");
System.out.println("-b\t--big-fires\tAllow big fires");
System.out.println("-d\t--dir\tSet output directory (use full path)");
System.out.println("-h\t--help\tPrint this message");
return;
}
}
try {
File parentDir = new File(dir);
File gisini = new File(parentDir, "gisini.txt");
// Open the output
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(gisini)));
// Build the city data
allNodes = MapFiles.loadNodes(parentDir);
allRoads = MapFiles.loadRoads(parentDir);
allBuildings = MapFiles.loadBuildings(parentDir);
Memory memory = new HashMemory();
for (int i = 0; i < allNodes.length; ++i) memory.add(allNodes[i], 0);
for (int i = 0; i < allRoads.length; ++i) memory.add(allRoads[i], 0);
for (int i = 0; i < allBuildings.length; ++i) memory.add(allBuildings[i], 0);
// Place items
int numFireBrigades = fireBrigades.getNumber();
int numPoliceForces = policeForces.getNumber();
int numAmbulanceTeams = ambulanceTeams.getNumber();
int numFireStations = fireStations.getNumber();
int numPoliceStations = policeStations.getNumber();
int numAmbulanceCenters = ambulanceCenters.getNumber();
int numRefuges = refuges.getNumber();
int numCivilians = civilians.getNumber();
int numFires = fires.getNumber();
FireStation[] fireStationBuildings = new FireStation[numFireStations];
PoliceOffice[] policeOfficeBuildings = new PoliceOffice[numPoliceStations];
AmbulanceCenter[] ambulanceCenterBuildings = new AmbulanceCenter[numAmbulanceCenters];
Refuge[] refugeBuildings = new Refuge[numRefuges];
Building[] normalBuildings =
placeMotionlessObjects(
fireStationBuildings,
policeOfficeBuildings,
ambulanceCenterBuildings,
refugeBuildings,
allBuildings);
MapFiles.writeGISMotionlessObjects(
out,
fireStationBuildings,
policeOfficeBuildings,
ambulanceCenterBuildings,
refugeBuildings);
FireBrigade[] fireBrigadeObjects = new FireBrigade[numFireBrigades];
PoliceForce[] policeForceObjects = new PoliceForce[numPoliceForces];
AmbulanceTeam[] ambulanceTeamObjects = new AmbulanceTeam[numAmbulanceTeams];
Civilian[] civilianObjects = new Civilian[numCivilians];
//
// placeMovingObjects(fireBrigadeObjects,policeForceObjects,ambulanceTeamObjects,civilianObjects,allBuildings,allRoads,allNodes,allowTrappedAgents,trappedCivilians);
placeMovingObjects(
fireBrigadeObjects,
policeForceObjects,
ambulanceTeamObjects,
civilianObjects,
allBuildings,
new Road[0],
allNodes,
allowTrappedAgents,
trappedCivilians);
MapFiles.writeGISMovingObjects(
out,
fireBrigadeObjects,
policeForceObjects,
ambulanceTeamObjects,
civilianObjects,
memory);
Building[] fireBuildings;
if (bigFires) fireBuildings = placeBigFires(numFires, normalBuildings, fireRadius);
else fireBuildings = placeNormalFires(numFires, normalBuildings);
MapFiles.writeGISFires(out, fireBuildings);
out.flush();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Abstract class: it provides all methods and attributes for each instruction type
*
* @author Trubia Massimo, Russo Daniele
*/
public abstract class Instruction {
protected BitSet32 repr;
protected List<Integer> params;
protected int paramCount;
protected String syntax;
protected String name;
protected String comment;
protected static Memory memory = Memory.getInstance();
protected Register[] TR; // is not static because each instruction has got its own registers
protected String fullname;
protected static boolean enableForwarding = (Boolean) Config.get("forwarding");
protected String label;
protected static final Logger logger = Logger.getLogger(Instruction.class.getName());
/** Creates a new instance of Instruction */
public Instruction() {
params = new LinkedList<Integer>();
TR = new Register[5];
repr = new BitSet32();
repr.reset(false);
syntax = new String();
// initialization of temporary registers
for (int i = 0; i < TR.length; i++) {
TR[i] = new Register();
}
}
/** <pre>
* Returns a BitSet32 holding the binary representation of the Instruction
* @return the Bitset32 representing the instruction
* </pre>
* */
public BitSet32 getRepr() {
return repr;
}
/**
* Creates a new instance of an Instruction's subclass
*
* @param name string value to pass in order to instanciate an instruction object
* @return the instruction object
*/
public static Instruction buildInstruction(String name) {
Instruction returnedObject = null;
for (InstructionEnumerator op : InstructionEnumerator.values()) {
if (op.name().equals(name) == true) {
returnedObject = op.getObject();
return returnedObject;
}
}
return returnedObject;
}
public enum InstructionEnumerator {
// ALU R-Type 32-bits
ADD {
Instruction getObject() {
ADD newObject = new ADD();
return newObject;
}
},
ADDU {
Instruction getObject() {
ADDU newObject = new ADDU();
return newObject;
}
},
SUB {
Instruction getObject() {
SUB newObject = new SUB();
return newObject;
}
},
SUBU {
Instruction getObject() {
SUBU newObject = new SUBU();
return newObject;
}
},
DIV {
Instruction getObject() {
DIV newObject = new DIV();
return newObject;
}
},
DIVU {
Instruction getObject() {
DIVU newObject = new DIVU();
return newObject;
}
},
MULT {
Instruction getObject() {
MULT newObject = new MULT();
return newObject;
}
},
MULTU {
Instruction getObject() {
MULTU newObject = new MULTU();
return newObject;
}
},
// ALU I-Type 32-bits
ADDI {
Instruction getObject() {
ADDI newObject = new ADDI();
return newObject;
}
},
ADDIU {
Instruction getObject() {
ADDIU newObject = new ADDIU();
return newObject;
}
},
// ALU Shifting 32-bits
SLL {
Instruction getObject() {
SLL newObject = new SLL();
return newObject;
}
},
SLLV {
Instruction getObject() {
SLLV newObject = new SLLV();
return newObject;
}
},
SRA {
Instruction getObject() {
SRA newObject = new SRA();
return newObject;
}
},
SRAV {
Instruction getObject() {
SRAV newObject = new SRAV();
return newObject;
}
},
SRL {
Instruction getObject() {
SRL newObject = new SRL();
return newObject;
}
},
SRLV {
Instruction getObject() {
SRLV newObject = new SRLV();
return newObject;
}
},
// ALU R-Type
AND {
Instruction getObject() {
AND newObject = new AND();
return newObject;
}
},
DADD {
Instruction getObject() {
DADD newObject = new DADD();
return newObject;
}
},
DADDU {
Instruction getObject() {
DADDU newObject = new DADDU();
return newObject;
}
},
DSUB {
Instruction getObject() {
DSUB newObject = new DSUB();
return newObject;
}
},
DSUBU {
Instruction getObject() {
DSUBU newObject = new DSUBU();
return newObject;
}
},
OR {
Instruction getObject() {
OR newObject = new OR();
return newObject;
}
},
SLT {
Instruction getObject() {
SLT newObject = new SLT();
return newObject;
}
},
SLTU {
Instruction getObject() {
SLTU newObject = new SLTU();
return newObject;
}
},
XOR {
Instruction getObject() {
XOR newObject = new XOR();
return newObject;
}
},
MOVN {
Instruction getObject() {
MOVN newObject = new MOVN();
return newObject;
}
},
MOVZ {
Instruction getObject() {
MOVZ newObject = new MOVZ();
return newObject;
}
},
DDIV {
Instruction getObject() {
DDIV newObject = new DDIV();
return newObject;
}
},
DDIVU {
Instruction getObject() {
DDIVU newObject = new DDIVU();
return newObject;
}
},
DMULT {
Instruction getObject() {
DMULT newObject = new DMULT();
return newObject;
}
},
DMULTU {
Instruction getObject() {
DMULTU newObject = new DMULTU();
return newObject;
}
},
MFLO {
Instruction getObject() {
MFLO newObject = new MFLO();
return newObject;
}
},
MFHI {
Instruction getObject() {
MFHI newObject = new MFHI();
return newObject;
}
},
// ALU I-Type
ANDI {
Instruction getObject() {
ANDI newObject = new ANDI();
return newObject;
}
},
DADDI {
Instruction getObject() {
DADDI newObject = new DADDI();
return newObject;
}
},
DADDUI {
Instruction getObject() {
DADDUI newObject = new DADDUI();
return newObject;
}
},
DADDIU {
Instruction getObject() {
DADDIU newObject = new DADDIU();
return newObject;
}
},
LUI {
Instruction getObject() {
LUI newObject = new LUI();
return newObject;
}
},
ORI {
Instruction getObject() {
ORI newObject = new ORI();
return newObject;
}
},
SLTI {
Instruction getObject() {
SLTI newObject = new SLTI();
return newObject;
}
},
SLTIU {
Instruction getObject() {
SLTIU newObject = new SLTIU();
return newObject;
}
},
XORI {
Instruction getObject() {
XORI newObject = new XORI();
return newObject;
}
},
// ALU Shifting
DSLL {
Instruction getObject() {
DSLL newObject = new DSLL();
return newObject;
}
},
DSLLV {
Instruction getObject() {
DSLLV newObject = new DSLLV();
return newObject;
}
},
DSRA {
Instruction getObject() {
DSRA newObject = new DSRA();
return newObject;
}
},
DSRAV {
Instruction getObject() {
DSRAV newObject = new DSRAV();
return newObject;
}
},
DSRL {
Instruction getObject() {
DSRL newObject = new DSRL();
return newObject;
}
},
DSRLV {
Instruction getObject() {
DSRLV newObject = new DSRLV();
return newObject;
}
},
// Load-Signed
LB {
Instruction getObject() {
LB newObject = new LB();
return newObject;
}
},
LH {
Instruction getObject() {
LH newObject = new LH();
return newObject;
}
},
LW {
Instruction getObject() {
LW newObject = new LW();
return newObject;
}
},
LD {
Instruction getObject() {
LD newObject = new LD();
return newObject;
}
},
// Load-Unsigned
LBU {
Instruction getObject() {
LBU newObject = new LBU();
return newObject;
}
},
LHU {
Instruction getObject() {
LHU newObject = new LHU();
return newObject;
}
},
LWU {
Instruction getObject() {
LWU newObject = new LWU();
return newObject;
}
},
// Store
SB {
Instruction getObject() {
SB newObject = new SB();
return newObject;
}
},
SH {
Instruction getObject() {
SH newObject = new SH();
return newObject;
}
},
SW {
Instruction getObject() {
SW newObject = new SW();
return newObject;
}
},
SD {
Instruction getObject() {
SD newObject = new SD();
return newObject;
}
},
// Unconditional branches
J {
Instruction getObject() {
J newObject = new J();
return newObject;
}
},
JAL {
Instruction getObject() {
JAL newObject = new JAL();
return newObject;
}
},
JALR {
Instruction getObject() {
JALR newObject = new JALR();
return newObject;
}
},
JR {
Instruction getObject() {
JR newObject = new JR();
return newObject;
}
},
BNE {
Instruction getObject() {
BNE newObject = new BNE();
return newObject;
}
},
B {
Instruction getObject() {
B newObject = new B();
return newObject;
}
},
// Conditional branches
BEQ {
Instruction getObject() {
BEQ newObject = new BEQ();
return newObject;
}
},
BNEZ {
Instruction getObject() {
BNEZ newObject = new BNEZ();
return newObject;
}
},
BEQZ {
Instruction getObject() {
BEQZ newObject = new BEQZ();
return newObject;
}
},
BGEZ {
Instruction getObject() {
BGEZ newObject = new BGEZ();
return newObject;
}
},
// Special instructions
NOP {
Instruction getObject() {
NOP newObject = new NOP();
return newObject;
}
},
BUBBLE {
Instruction getObject() {
BUBBLE newObject = new BUBBLE();
return newObject;
}
},
HALT {
Instruction getObject() {
HALT newObject = new HALT();
return newObject;
}
},
TRAP {
Instruction getObject() {
TRAP newObject = new TRAP();
return newObject;
}
},
SYSCALL {
Instruction getObject() {
SYSCALL newObject = new SYSCALL();
return newObject;
}
},
BREAK {
Instruction getObject() {
BREAK newObject = new BREAK();
return newObject;
}
};
abstract Instruction getObject();
}
/**
*
*
* <pre>
* Instruction fetch.
* Now it is used in order to generate the Dinero trace-file
* </pre>
*/
public void IF() throws BreakException {}
/**
*
*
* <pre>
* Decode stage of the Pipeline
* In this method all instructions that modify GPRs lock the involved register
* </pre>
*/
public abstract void ID()
throws RAWException, IrregularWriteOperationException, IrregularStringOfBitsException,
TwosComplementSumException, HaltException, JumpException, BreakException;
/**
*
*
* <pre>
* Execute stage of the Pipeline
* In this stage all Alu Instructions perform their computations and save results in temporary registers
* </pre>
*/
public abstract void EX()
throws HaltException, IrregularStringOfBitsException, IntegerOverflowException,
TwosComplementSumException, IrregularWriteOperationException,
IrregularWriteOperationException, DivisionByZeroException;
/**
*
*
* <pre>
* Memory stage of the Pipeline
* In this stage all Load and Store instructions access memory for getting or putting data
* </pre>
*/
public abstract void MEM()
throws HaltException, IrregularStringOfBitsException, MemoryElementNotFoundException,
AddressErrorException, IrregularWriteOperationException;
/**
*
*
* <pre>
* Write Back stage of the Pipeline
* In this stage all instructions that modify registers write and unlock them
* </pre>
*/
public abstract void WB() throws HaltException, IrregularStringOfBitsException;
/**
*
*
* <pre>
* Builds the binary encoding of instructions.
* Every instruction is represented by a 32 bit field
* </pre>
*/
public abstract void pack() throws IrregularStringOfBitsException;
/**
* Gets the number of params to pass at the instruction object
*
* @return number of params
*/
public int getNParams() {
return paramCount;
};
/**
*
*
* <pre>
* Gets the syntax of any instruction as string composed by the following simbols
* %R Register
* %I Immediate
* %U Unsigned Immediate
* %L Memory Label
* %E Program Label used for Jump Instructions
* %B Program Label used for Brench Instructions
*
* examples:
* Instruction -----> Syntax
* DADD R1,R2,R3 | %R,%R,%R
* DADDI R1,R2,-3 | %R,%R,%I
* DSLL R1,R2,15 | %R,%R,%U
* LD R1,vet(R0) | %R,%L(%R)
* J loop | %E
* BNE R1,R2,loop | %R,%R,%B
* </pre>
*/
public String getSyntax() {
return syntax;
}
/**
* Returns the name of the instruction as string.
*
* @return the instruction name(e.g. "DADD")
*/
public String getName() {
return name;
}
/**
*
*
* <pre>
* Returns a list with the instruction parameters
* e.g. DADD R1,R2,R3 --> params= { 1, 2, 3}
* LD R1, var(R0)--> params= { 1, address memory corresponding with var, 0}
* </pre>
*
* @return the list of parameters
*/
public List<Integer> getParams() {
return params;
}
/**
*<pre>
* Sets the instruction with a list of parameters
* Passed list | Instruction to set
* e.g. list= { 1, 2, 3} | DADD R1,R2,R3
* list= { 1, address memory corresponding with var, 0} | LD R1, var(R0)
*@param params The list of parameters
**/
public void setParams(List<Integer> params) {
this.params = params;
}
/**
* Sets the full name of the instruction as string
*
* @param value full name of the instruction (e.g. "DADD R1,R2,R3")
*/
public void setFullName(String value) {
fullname = value;
}
/**
* Sets the comment of the instruction as string. The comment is the text after every semicolon in
* the file .s
*
* @params value the full name of the instruction (e.g. "DADD R1,R2,R3")
*/
public void setComment(String comment) {
this.comment = comment;
}
/**
* Gets the comment of the instruction as string.The comment is the text after every semicolon in
* the file .s
*
* @return the comment
*/
public String getComment() {
return comment;
}
/**
* Gets the comment of the instruction as string. The comment is the text after every semicolon in
* the file .s
*
* @return the full name of the instruction (e.g. "DADD R1,R2,R3")
*/
public String getFullName() {
return fullname;
}
public String toString() {
return fullname;
}
/**
* Enable forwarding mode
*
* @param value This variable enable the forwarding modality if it is true
*/
public static void setEnableForwarding(boolean value) {
enableForwarding = value;
}
/**
* Gets the state of EnableForwarding. This modality anticipates writing on registers at EX stage
* for Alu instructions or at MEM stage for Load-Store instructions
*
* @return The forwarding state
*/
public static boolean getEnableForwarding() {
return enableForwarding;
}
/**
*
*
* <pre>
* Gets the label of the instruction. Labels may be assigned to instructions
* when they are inserted in the symbol table
* </pre>
*
* @return label of the instruction
*/
public String getLabel() {
return label;
}
/**
*
*
* <pre>
* Sets the label of the instruction. Labels may be assigned to instructions
* when they are inserted in the symbol table
* </pre>
*
* @value label of the instruction
*/
public void setLabel(String value) {
label = value;
}
}
