private ClassNode sourceCNode;
private ClassNode targetCNode;
- private int probability;
+ private double probability;
private int transTime;
private int listExeTime;
if(ScheduleEdge.NEWEDGE == this.type) {
completeLabel += ":" + Integer.toString(this.newRate);
}
- completeLabel += ":(" + Integer.toString(this.probability) + "%)" + ":[" + Integer.toString(this.transTime) + "]";
+ completeLabel += ":(" + Double.toString(this.probability) + "%)" + ":[" + Integer.toString(this.transTime) + "]";
return completeLabel;
}
return this.targetFState;
}
- public int getProbability() {
+ public double getProbability() {
return this.probability;
}
public int hashCode() {
int hashcode = gid^uid^label.hashCode()^target.hashCode()^source.hashCode()^fstate.hashCode()^
- sourceCNode.hashCode()^targetCNode.hashCode()^newRate^probability^
+ sourceCNode.hashCode()^targetCNode.hashCode()^newRate^(int)probability^
type^transTime^listExeTime;
if(targetFState != null) {
hashcode ^= targetFState.hashCode();
return hashcode;
}
- public void setProbability(int prob) {
+ public void setProbability(double prob) {
this.probability = prob;
}
this.cores.add(new CoreSimulator(FIFORSchedule.getFIFORSchedule(), i));
}
}
+ if(this.checkpoints != null) {
+ this.checkpoints.clear();
+ }
applyScheduling();
}
if(this.checkpoints == null) {
this.checkpoints = new Vector<CheckPoint>();
- } else {
+ } /*else {
this.checkpoints.clear();
- }
+ }*/
this.processTime = 0;
for(int j = 0; j < this.cores.size(); j++) {
System.out.println("\t\tcore" + j + ": " + getUtility(j) + "%");
}
+
+ this.checkpoints.clear();
+ this.checkpoints = null;
return this.processTime;
}
private int invokeNum;
private int expInvokeNum;
private boolean m_isbackedge;
+ private int m_taskexitindex;
public class NewObjInfo {
int newRate;
- int probability;
+ double probability;
FlagState root;
int invokeNum;
invokeNum = 0;
}
- public NewObjInfo(int newRate, int probability) {
+ public NewObjInfo(int newRate, double probability) {
this.newRate = newRate;
this.probability = probability;
}
this.newRate = newRate;
}
- public int getProbability() {
+ public double getProbability() {
return this.probability;
}
- public void setProbability(int probability) {
+ public void setProbability(double probability) {
this.probability = probability;
}
this.invokeNum = 0;
this.expInvokeNum = 0;
this.m_isbackedge = false;
+ this.m_taskexitindex = 0;
+ }
+
+ public int getTaskExitIndex() {
+ return m_taskexitindex;
+ }
+
+ public void setTaskExitIndex(int taskexitindex) {
+ this.m_taskexitindex = taskexitindex;
}
public double getProbability() {
return this.newObjInfos.get(cd);
}
- public void addNewObjInfo(ClassDescriptor cd, int newRate, int probability) {
+ public void addNewObjInfo(ClassDescriptor cd, int newRate, double probability) {
if(this.newObjInfos == null) {
this.newObjInfos = new Hashtable<ClassDescriptor, NewObjInfo>();
}
//seen this node already
fs_taskexit=canonicalizeFlagState(sourcenodes,fs_taskexit);
FEdge newedge=new FEdge(fs_taskexit,taskname, td, parameterindex);
+ newedge.setTaskExitIndex(ffan.getTaskExitIndex());
((Vector<FEdge>)tdToFEdges.get(td)).add(newedge);
fs.addEdge(newedge);
outclassdefs.println(" int isolate;"); // indicate if this object is shared or not
outclassdefs.println(" int version;");
outclassdefs.println(" struct ___Object___ * original;");
+ outclassdefs.println(" int numlocks;"); // array for locks
+ outclassdefs.println(" int * locks;");
}
if(state.OPTIONAL) {
outclassdefs.println(" int numfses;");
classdefout.println(" int isolate;"); // indicate if this object is shared or not
classdefout.println(" int version;");
classdefout.println(" struct ___Object___ * original;");
+ classdefout.println(" int numlocks;"); // array for locks
+ classdefout.println(" int * locks;");
}
if (state.OPTIONAL) {
classdefout.println(" int numfses;");
output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";");
}
- private void generateFlatNew(FlatMethod fm, LocalityBinding lb, FlatNew fn, PrintWriter output) {
+ protected void generateFlatNew(FlatMethod fm, LocalityBinding lb, FlatNew fn, PrintWriter output) {
if (state.DSM && locality.getAtomic(lb).get(fn).intValue()>0&&!fn.isGlobal()) {
//Stash pointer in case of GC
String revertptr=generateTemp(fm, reverttable.get(lb),lb);
", " + qinfo.length + ");");
output.println("}");
}
+ if(ffan.getTaskType()==FlatFlagActionNode.TASKEXIT) {
+ // generate codes for profiling, recording which task exit it is
+ output.println("#ifdef RAWPROFILE");
+ output.println("setTaskExitIndex(" + ffan.getTaskExitIndex() + ");");
+ output.println("#endif");
+ }
}
}
protected void outputTransCode(PrintWriter output) {
output.println("while(0 == isEmpty(totransobjqueue)) {");
- output.println(" struct QueueItem * totransitem = getTail(totransobjqueue);");
-
- output.println(" transferObject((struct transObjInfo *)(totransitem->objectptr));");
- output.println(" RUNFREE(((struct transObjInfo *)(totransitem->objectptr))->queues);");
- output.println(" RUNFREE(totransitem->objectptr);");
- output.println(" removeItem(totransobjqueue, totransitem);");
+ //output.println(" struct QueueItem * totransitem = getTail(totransobjqueue);");
+ //output.println(" transferObject((struct transObjInfo *)(totransitem->objectptr));");
+ //output.println(" RUNFREE(((struct transObjInfo *)(totransitem->objectptr))->queues);");
+ //output.println(" RUNFREE(totransitem->objectptr);");
+ //output.println(" removeItem(totransobjqueue, totransitem);");
+ output.println(" struct transObjInfo * totransobj = (struct transObjInfo *)(getItem(totransobjqueue));");
+ output.println(" transferObject(totransobj);");
+ output.println(" RUNFREE(totransobj->queues);");
+ output.println(" RUNFREE(totransobj);");
output.println("}");
output.println("freeQueue(totransobjqueue);");
}
output.println("addAliasLock(" + super.generateTemp(fm, fn.getDst(), lb) + ", aliaslocks[" + tmpv.elementAt(i).intValue() + "]);");
}
}
+ // generate codes for profiling, recording how many new objects are created
+ if((fn.getType().getClassDesc() != null) && (fn.getType().getClassDesc().hasFlags())) {
+ output.println("#ifdef RAWPROFILE");
+ output.println("addNewObjInfo(\"" + fn.getType().getClassDesc().getSymbol() + "\");");
+ output.println("#endif");
+ }
}
class TranObjInfo {
private NodePair flattenTaskExitNode(TaskExitNode ten) {
FlatFlagActionNode ffan=new FlatFlagActionNode(FlatFlagActionNode.TASKEXIT);
+ ffan.setTaskExitIndex(ten.getTaskExitIndex());
updateFlagActionNode(ffan, ten.getFlagEffects());
NodePair fcn=flattenConstraintCheck(ten.getChecks());
ffan.addNext(fcn.getBegin());
Hashtable<ClassDescriptor, Vector<FlagState>> cd2fs4new;
Hashtable<FlagState, Vector<FlagState>> fs2fs;
+ int m_taskexitindex;
public FlatFlagActionNode(int taskexit) {
tempflagpairs=new Hashtable<TempFlagPair, Boolean>();
this.cd2initfs = null;
this.cd2fs4new = null;
this.fs2fs = null;
+ this.m_taskexitindex = 0;
+ }
+
+ public int getTaskExitIndex() {
+ return m_taskexitindex;
+ }
+
+ public void setTaskExitIndex(int taskexitindex) {
+ this.m_taskexitindex = taskexitindex;
}
public int getTaskType() {
public class BuildIR {
State state;
+
+ private int m_taskexitnum;
+
public BuildIR(State state) {
this.state=state;
+ this.m_taskexitnum = 0;
}
+
public void buildtree() {
for(Iterator it=state.parsetrees.iterator(); it.hasNext();) {
ParseNode pn=(ParseNode)it.next();
}
public BlockNode parseBlock(ParseNode pn) {
+ this.m_taskexitnum = 0;
if (pn==null||isEmpty(pn.getTerminal()))
return new BlockNode();
ParseNode bsn=pn.getChild("block_statement_list");
if (pn.getChild("cons_checks")!=null)
ccs=parseChecks(pn.getChild("cons_checks"));
- blockstatements.add(new TaskExitNode(vfe, ccs));
+ blockstatements.add(new TaskExitNode(vfe, ccs, this.m_taskexitnum++));
} else if (isNode(pn,"atomic")) {
BlockNode bn=parseBlockHelper(pn);
blockstatements.add(new AtomicNode(bn));
public class TaskExitNode extends BlockStatementNode {
Vector vfe;
Vector ccs;
- public TaskExitNode(Vector vfe, Vector ccs) {
+ int m_taskexitindex;
+
+ public TaskExitNode(Vector vfe, Vector ccs, int taskexitindex) {
this.vfe=vfe;
this.ccs=ccs;
+ this.m_taskexitindex = taskexitindex;
}
public String printNode(int indent) {
public int kind() {
return Kind.TaskExitNode;
}
+
+ public int getTaskExitIndex() {
+ return m_taskexitindex;
+ }
}
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileInputStream;
+import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;
}
}
}
+ fss = null;
}
}
System.exit(-1);
}
String profiledata = new String(b, 0, length);
- java.util.Hashtable<String, Integer> taskinfo = new java.util.Hashtable<String, Integer>();
+ java.util.Hashtable<String, TaskInfo> taskinfos = new java.util.Hashtable<String, TaskInfo>();
+ // profile data format:
+ // taskname, numoftaskexits(; exetime, probability, numofnewobjtypes(, newobj type, num of objs)+)+
int inindex = profiledata.indexOf('\n');
while((inindex != -1) ) {
String inline = profiledata.substring(0, inindex);
while(inint.startsWith(" ")) {
inint = inint.substring(1);
}
- int duration = Integer.parseInt(inint);
- taskinfo.put(inname, duration);
+ tmpinindex = inint.indexOf(';');
+ int numofexits = Integer.parseInt(inint.substring(0, tmpinindex));
+ TaskInfo tinfo = new TaskInfo(numofexits);
+ inint = inint.substring(tmpinindex + 1);
+ while(inint.startsWith(" ")) {
+ inint = inint.substring(1);
+ }
+ for(int i = 0; i < numofexits; i++) {
+ String tmpinfo = null;
+ if(i < numofexits - 1) {
+ tmpinindex = inint.indexOf(';');
+ tmpinfo = inint.substring(0, tmpinindex);
+ inint = inint.substring(tmpinindex + 1);
+ while(inint.startsWith(" ")) {
+ inint = inint.substring(1);
+ }
+ } else {
+ tmpinfo = inint;
+ }
+
+ tmpinindex = tmpinfo.indexOf(',');
+ tinfo.m_exetime[i] = Integer.parseInt(tmpinfo.substring(0, tmpinindex));
+ tmpinfo = tmpinfo.substring(tmpinindex + 1);
+ while(tmpinfo.startsWith(" ")) {
+ tmpinfo = tmpinfo.substring(1);
+ }
+ tmpinindex = tmpinfo.indexOf(',');
+ tinfo.m_probability[i] = Double.parseDouble(tmpinfo.substring(0, tmpinindex));
+ tmpinfo = tmpinfo.substring(tmpinindex + 1);
+ while(tmpinfo.startsWith(" ")) {
+ tmpinfo = tmpinfo.substring(1);
+ }
+ tmpinindex = tmpinfo.indexOf(',');
+ int numofnobjs = 0;
+ if(tmpinindex == -1) {
+ numofnobjs = Integer.parseInt(tmpinfo);
+ if(numofnobjs != 0) {
+ System.err.println("Error profile data format!");
+ System.exit(-1);
+ }
+ } else {
+ tinfo.m_newobjinfo.setElementAt(new Hashtable<String,Integer>(), i);
+ numofnobjs = Integer.parseInt(tmpinfo.substring(0, tmpinindex));
+ tmpinfo = tmpinfo.substring(tmpinindex + 1);
+ while(tmpinfo.startsWith(" ")) {
+ tmpinfo = tmpinfo.substring(1);
+ }
+ for(int j = 0; j < numofnobjs; j++) {
+ tmpinindex = tmpinfo.indexOf(',');
+ String nobjtype = tmpinfo.substring(0, tmpinindex);
+ tmpinfo = tmpinfo.substring(tmpinindex + 1);
+ while(tmpinfo.startsWith(" ")) {
+ tmpinfo = tmpinfo.substring(1);
+ }
+ int objnum = 0;
+ if(j < numofnobjs - 1) {
+ tmpinindex = tmpinfo.indexOf(',');
+ objnum = Integer.parseInt(tmpinfo.substring(0, tmpinindex));
+ tmpinfo = tmpinfo.substring(tmpinindex + 1);
+ while(tmpinfo.startsWith(" ")) {
+ tmpinfo = tmpinfo.substring(1);
+ }
+ } else {
+ objnum = Integer.parseInt(tmpinfo);
+ }
+ tinfo.m_newobjinfo.elementAt(i).put(nobjtype, objnum);
+ }
+ }
+ }
+ taskinfos.put(inname, tinfo);
inindex = profiledata.indexOf('\n');
}
int total = 100;
for(int j = 0; j < numEdges; j++) {
FEdge pfe = fev.elementAt(j);
- if(numEdges - j == 1) {
- pfe.setProbability(total);
- } else {
- if((total != 0) && (total != 1)) {
- do {
- tint = r.nextInt()%total;
- } while(tint <= 0);
- }
- pfe.setProbability(tint);
- total -= tint;
+ tint = taskinfos.get(td.getSymbol()).m_exetime[pfe.getTaskExitIndex()];
+ pfe.setExeTime(tint);
+ double idouble = taskinfos.get(td.getSymbol()).m_probability[pfe.getTaskExitIndex()];
+ pfe.setProbability(idouble);
+ int newRate = 0;
+ if((taskinfos.get(td.getSymbol()).m_newobjinfo.elementAt(pfe.getTaskExitIndex()) != null)
+ && (taskinfos.get(td.getSymbol()).m_newobjinfo.elementAt(pfe.getTaskExitIndex()).containsKey(cd.getSymbol()))) {
+ newRate = taskinfos.get(td.getSymbol()).m_newobjinfo.elementAt(pfe.getTaskExitIndex()).get(cd.getSymbol());
}
- //do {
- // tint = r.nextInt()%10;
- // } while(tint <= 0);
- //int newRate = tint;
- //int newRate = (j+1)%2+1;
- int newRate = 1;
- String cdname = cd.getSymbol();
- if((cdname.equals("SeriesRunner")) ||
- (cdname.equals("MDRunner")) ||
- (cdname.equals("Stage")) ||
- (cdname.equals("AppDemoRunner")) ||
- (cdname.equals("FilterBankAtom"))) {
- newRate = 16;
- } else if(cdname.equals("SentenceParser")) {
- newRate = 4;
- }
- //do {
- // tint = r.nextInt()%100;
- // } while(tint <= 0);
- // int probability = tint;
- int probability = 100;
- pfe.addNewObjInfo(cd, newRate, probability);
+ pfe.addNewObjInfo(cd, newRate, idouble);
}
+ fev = null;
}
}
}
Iterator it_edges = fs.edges();
int total = 100;
while(it_edges.hasNext()) {
- //do {
- // tint = r.nextInt()%10;
- // } while(tint <= 0);
FEdge edge = (FEdge)it_edges.next();
- tint = taskinfo.get(edge.getTask().getSymbol()).intValue();
+ tint = taskinfos.get(edge.getTask().getSymbol()).m_exetime[edge.getTaskExitIndex()];
edge.setExeTime(tint);
- if((fs.getClassDescriptor().getSymbol().equals("MD")) && (edge.getTask().getSymbol().equals("t6"))) {
- if(edge.isbackedge()) {
- if(edge.getTarget().equals(edge.getSource())) {
- edge.setProbability(93.75);
- } else {
- edge.setProbability(3.125);
- }
- } else {
- edge.setProbability(3.125);
- }
- continue;
- }
- if(!it_edges.hasNext()) {
- edge.setProbability(total);
- } else {
- if((total != 0) && (total != 1)) {
- do {
- tint = r.nextInt()%total;
- } while(tint <= 0);
- }
- edge.setProbability(tint);
- total -= tint;
- }
+ double idouble = taskinfos.get(edge.getTask().getSymbol()).m_probability[edge.getTaskExitIndex()];
+ edge.setProbability(idouble);
}
}
}
}
+ taskinfos = null;
} else {
// for test
// Randomly set the newRate and probability of FEdges
int probability = 100;
pfe.addNewObjInfo(cd, newRate, probability);
}
+ fev = null;
}
}
}
} else if(tmpTime == processTime) {
selectedScheduling.add(index);
}
+ scheduling = null;
index++;
}
System.out.print("Selected schedulings with least exectution time " + processTime + ": \n\t");
BuildCodeMultiCore bcm=new BuildCodeMultiCore(state, bf.getMap(), tu, sa, scheduling, scheduleAnalysis.getCoreNum(), pa);
bcm.setOwnershipAnalysis(oa);
bcm.buildCode();
+ scheduling = null;
}
+ selectedScheduling = null;
}
}
System.exit(l.numErrors());
}
}
+
+ static class TaskInfo {
+ public int m_numofexits;
+ public int[] m_exetime;
+ public double[] m_probability;
+ public Vector<Hashtable<String, Integer>> m_newobjinfo;
+
+ public TaskInfo(int numofexits) {
+ this.m_numofexits = numofexits;
+ this.m_exetime = new int[this.m_numofexits];
+ this.m_probability = new double[this.m_numofexits];
+ this.m_newobjinfo = new Vector<Hashtable<String, Integer>>();
+ for(int i = 0; i < this.m_numofexits; i++) {
+ this.m_newobjinfo.add(null);
+ }
+ }
+ }
}
char* taskName;
int startTime;
int endTime;
+ int exitIndex;
+ struct Queue * newObjs;
} TaskInfo;
/*typedef struct interrupt_info {
taskInfo->taskName = "objqueue checking";
taskInfo->startTime = raw_get_cycle();
taskInfo->endTime = -1;
+ taskInfo->exitIndex = -1;
+ taskInfo->newObjs = NULL;
}
isChecking = true;
}
if((fp = fopen(fn, "w+")) == NULL) {
fprintf(stderr, "fopen error\n");
- return -1;
+ return;
}
- fprintf(fp, "Task Name, Start Time, End Time, Duration\n");
+ fprintf(fp, "Task Name, Start Time, End Time, Duration, Exit Index(, NewObj Name, Num)+\n");
// output task related info
for(i = 0; i < taskInfoIndex; i++) {
TaskInfo* tmpTInfo = taskInfoArray[i];
int duration = tmpTInfo->endTime - tmpTInfo->startTime;
- fprintf(fp, "%s, %d, %d, %d\n", tmpTInfo->taskName, tmpTInfo->startTime, tmpTInfo->endTime, duration);
+ fprintf(fp, "%s, %d, %d, %d, %d", tmpTInfo->taskName, tmpTInfo->startTime, tmpTInfo->endTime, duration, tmpTInfo->exitIndex);
+ // summarize new obj info
+ if(tmpTInfo->newObjs != NULL) {
+ struct RuntimeHash * nobjtbl = allocateRuntimeHash(5);
+ struct RuntimeIterator * iter = NULL;
+ while(0 == isEmpty(tmpTInfo->newObjs)) {
+ char * objtype = (char *)(getItem(tmpTInfo->newObjs));
+ if(RuntimeHashcontainskey(nobjtbl, (int)(objtype))) {
+ int num = 0;
+ RuntimeHashget(nobjtbl, (int)objtype, &num);
+ RuntimeHashremovekey(nobjtbl, (int)objtype);
+ num++;
+ RuntimeHashadd(nobjtbl, (int)objtype, num);
+ } else {
+ RuntimeHashadd(nobjtbl, (int)objtype, 1);
+ }
+ //fprintf(stderr, "new obj!\n");
+ }
+
+ // output all new obj info
+ iter = RuntimeHashcreateiterator(nobjtbl);
+ while(RunhasNext(iter)) {
+ char * objtype = (char *)Runkey(iter);
+ int num = Runnext(iter);
+ fprintf(fp, ", %s, %d", objtype, num);
+ }
+ }
+ fprintf(fp, "\n");
if(strcmp(tmpTInfo->taskName, "tpd checking") == 0) {
preprocessingtime += duration;
} else if(strcmp(tmpTInfo->taskName, "post task execution") == 0) {
raw_test_pass(0xdddb);
raw_test_pass_reg(tmpTInfo->startTime);
raw_test_pass_reg(tmpTInfo->endTime);
+ raw_test_pass_reg(tmpTInfo->exitIndex);
+ if(tmpTInfo->newObjs != NULL) {
+ struct RuntimeHash * nobjtbl = allocateRuntimeHash(5);
+ struct RuntimeIterator * iter = NULL;
+ while(0 == isEmpty(tmpTInfo->newObjs)) {
+ char * objtype = (char *)(getItem(tmpTInfo->newObjs));
+ if(RuntimeHashcontainskey(nobjtbl, (int)(objtype))) {
+ int num = 0;
+ RuntimeHashget(nobjtbl, (int)objtype, &num);
+ RuntimeHashremovekey(nobjtbl, (int)objtype);
+ num++;
+ RuntimeHashadd(nobjtbl, (int)objtype, num);
+ } else {
+ RuntimeHashadd(nobjtbl, (int)objtype, 1);
+ }
+ }
+
+ // ouput all new obj info
+ iter = RuntimeHashcreateiterator(nobjtbl);
+ while(RunhasNext(iter)) {
+ char * objtype = (char *)Runkey(iter);
+ int num = Runnext(iter);
+ int nameLen = strlen(objtype);
+ raw_test_pass(0xddda);
+ for(j = 0; j < nameLen; j++) {
+ raw_test_pass_reg(objtype[j]);
+ }
+ raw_test_pass(0xdddb);
+ raw_test_pass_reg(num);
+ }
+ }
raw_test_pass(0xdddc);
}
raw_test_pass(0xeeee);
#endif
}
+
+inline void setTaskExitIndex(int index) {
+ taskInfoArray[taskInfoIndex]->exitIndex = index;
+}
+
+inline void addNewObjInfo(void * nobj) {
+ if(taskInfoArray[taskInfoIndex]->newObjs == NULL) {
+ taskInfoArray[taskInfoIndex]->newObjs = createQueue();
+ }
+ addNewItem(taskInfoArray[taskInfoIndex]->newObjs, nobj);
+}
#endif
// receive object transferred from other cores
checkTaskInfo->taskName = "tpd checking";
checkTaskInfo->startTime = raw_get_cycle();
checkTaskInfo->endTime = -1;
+ checkTaskInfo->exitIndex = -1;
+ checkTaskInfo->newObjs = NULL;
}
#endif
currtpd=(struct taskparamdescriptor *) getfirstkey(activetasks);
taskInfo->taskName = currtpd->task->name;
taskInfo->startTime = raw_get_cycle();
taskInfo->endTime = -1;
+ taskInfo->exitIndex = -1;
+ taskInfo->newObjs = NULL;
}
#endif
postTaskInfo->taskName = "post task execution";
postTaskInfo->startTime = raw_get_cycle();
postTaskInfo->endTime = -1;
+ postTaskInfo->exitIndex = -1;
+ postTaskInfo->newObjs = NULL;
}
#endif
#ifdef RAWDEBUG
void enqueueObject(void * ptr, struct parameterwrapper ** queues, int length);
#ifdef RAW
void enqueueObject_I(void * ptr, struct parameterwrapper ** queues, int length);
+#ifdef RAWPROFILE
+inline void setTaskExitIndex(int index);
+inline void addNewObjInfo(void * nobj);
+#endif
#endif
void addAliasLock(void * ptr, int lock);
#else
if $MULTICOREFLAG
then
-if ! java $JAVAFORWARDOPTS -classpath $ROBUSTROOT/../cup/:$ROBUSTROOT Main.Main -classlibrary \
+if ! java -Xms50m -Xmx600m $JAVAFORWARDOPTS -classpath $ROBUSTROOT/../cup/:$ROBUSTROOT Main.Main -classlibrary \
$ROBUSTROOT/ClassLibrary/ -dir $BUILDDIR \
$JAVAOPTS $SRCFILES
then exit $?
projects / IRC.git / commitdiff