source: xssim/src/simulator/workload/writer/swf/Grms3SWFJobWriter.java @ 104

Revision 104, 5.5 KB checked in by wojtekp, 13 years ago (diff)
  • Property svn:mime-type set to text/plain
Line 
1package simulator.workload.writer.swf;
2
3import java.io.IOException;
4import java.util.Random;
5
6import org.exolab.castor.types.Duration;
7
8import simulator.workload.reader.archive.swf.SWFFields;
9
10import org.qcg.broker.schemas.exception.NoSuchParamException;
11import org.qcg.broker.schemas.jobdesc.ExecutionTimeType;
12import org.qcg.broker.schemas.jobdesc.QcgJob;
13import org.qcg.broker.schemas.jobdesc.Task;
14import org.qcg.broker.schemas.jobdesc.wrapper.TaskRequirements;
15import org.qcg.broker.schemas.jobdesc.wrapper.impl.TaskRequirementsImpl;
16
17/**
18 *
19 * @author Marcin Krystek
20 *
21 */
22public class Grms3SWFJobWriter extends AbstractSWFJobWriter<QcgJob>{
23
24        protected int intTaskId;
25        protected String workloadArray[];
26        protected Random random;
27       
28        public Grms3SWFJobWriter(String dirName, String fileName) throws IOException{
29                super(dirName, fileName);
30                this.intTaskId = 0;
31                this.workloadArray = new String[18];
32                this.random = new Random(System.currentTimeMillis());
33        }
34       
35        public boolean write(QcgJob job) throws IOException {
36                long taskLength;
37                String idMapping;
38                String taskId;
39                TaskRequirements taskReqWrapper = new TaskRequirementsImpl();
40               
41                for(int i = 0; i < job.getTaskCount(); i++){
42                        Task task = job.getTask(i);
43                        taskReqWrapper.wrap(task);
44                       
45                        // prepare swf task id
46                        if(this.useTaskMapping){
47                                taskId = String.valueOf(intTaskId);
48                                idMapping = taskId+":"+job.getAppId()+":"+task.getTaskId();
49                                intTaskId++;
50                                this.taskMapping.add(idMapping);
51                        } else {
52                                taskId = task.getTaskId();
53                        }
54                       
55                        // prepare task length value
56                        if(tasksLength.containsKey(task.getTaskId())){
57                                taskLength = tasksLength.get(task.getTaskId());
58                        } else {
59                                taskLength = 0;
60                        }
61                       
62                        double tab[] = null;
63                       
64                        // prepare requested number of processors
65                        String reqCpuCnt = IRRELEVANT;
66                        try {
67                                double min = 0;
68                                double max = Double.MAX_VALUE;
69                               
70                                if((tab = taskReqWrapper.getCpucount()).length != 0){ // try single value
71                                        reqCpuCnt = String.valueOf(Math.round(tab[0]));
72                                       
73                                } else {
74                                        double d[][] = taskReqWrapper.getRangeCpucount();
75                                        if(d.length != 0 && (tab = d[0]).length != 0){ // try range value
76                                                min = tab[0];
77                                                max = tab[1];
78                                                double r = random.nextDouble();
79                                                reqCpuCnt = String.valueOf(Math.round(min + (max - min) * r));
80                                       
81                                        } else {                                                                                // try single min and max value
82                                                boolean change = false;
83                                                if((tab = taskReqWrapper.getMinCpucount()).length != 0) {
84                                                        min = tab[0];
85                                                        change = true;
86                                                }
87                                                if((tab = taskReqWrapper.getMaxCpucount()).length != 0){
88                                                        max = tab[0];
89                                                        change = true;
90                                                }
91                                                if(change) {
92                                                        double r = random.nextDouble();
93                                                        reqCpuCnt = String.valueOf(Math.round(min + (max - min) * r));
94                                                }
95                                        }
96                                }
97                               
98                        } catch(NoSuchParamException e){
99
100                        }
101                       
102                        // prepare requested memory
103                        String reqMemCnt = IRRELEVANT;
104                        try {
105                                double min = 0;
106                                double max = Double.MAX_VALUE;
107                               
108                                if((tab = taskReqWrapper.getMemory()).length != 0){ // try single value
109                                        reqMemCnt = String.valueOf(Math.round(tab[0]));
110                                       
111                                } else {
112                                        double d[][] = taskReqWrapper.getRangeMemory();
113                                        if(d.length != 0 && (tab = d[0]).length != 0){ // try range value
114                                                min = tab[0];
115                                                max = tab[1];
116                                                double r = random.nextDouble();
117                                                reqMemCnt = String.valueOf(Math.round(min + (max - min) * r));
118                                               
119                                        } else {                                                                                // try single min and max value
120                                                boolean change = false;
121                                                if((tab = taskReqWrapper.getMinMemory()).length != 0) {
122                                                        min = tab[0];
123                                                        change = true;
124                                                }
125                                                if((tab = taskReqWrapper.getMaxMemory()).length != 0){
126                                                        max = tab[0];
127                                                        change = true;
128                                                }
129                                                if(change){
130                                                        double r = random.nextDouble();
131                                                        reqMemCnt = String.valueOf(Math.round(min + (max - min) * r));
132                                                }
133                                        }
134                                }
135                               
136                        } catch(NoSuchParamException e){
137
138                        }
139                       
140                        // prepare requested time
141                        long reqTaskLength = taskLength;
142                        ExecutionTimeType ett = task.getExecutionTime();
143                        if(ett != null){
144                                Duration duration = ett.getExecutionDuration();
145                                reqTaskLength = duration.toLong();
146                        }
147                       
148                       
149                        workloadArray[SWFFields.DATA_JOB_NUMBER] = taskId;
150                        workloadArray[SWFFields.DATA_SUBMIT_TIME] = String.valueOf(this.submitTime);
151                        workloadArray[SWFFields.DATA_WAIT_TIME] = IRRELEVANT;
152                        workloadArray[SWFFields.DATA_RUN_TIME] = String.valueOf(taskLength);
153                        workloadArray[SWFFields.DATA_NUMBER_OF_ALLOCATED_PROCESSORS] = reqCpuCnt;
154                        workloadArray[SWFFields.DATA_AVERAGE_CPU_TIME_USED] = IRRELEVANT;
155                        workloadArray[SWFFields.DATA_USED_MEMORY] = IRRELEVANT;
156                        workloadArray[SWFFields.DATA_REQUESTED_NUMBER_OF_PROCESSORS] = reqCpuCnt;
157                        workloadArray[SWFFields.DATA_REQUESTED_TIME] = String.valueOf(reqTaskLength);
158                        workloadArray[SWFFields.DATA_REQUESTED_MEMORY] = reqMemCnt;
159                        workloadArray[SWFFields.DATA_STATUS] = IRRELEVANT;
160                        workloadArray[SWFFields.DATA_USER_ID] = IRRELEVANT;
161                        workloadArray[SWFFields.DATA_GROUP_ID] = IRRELEVANT;
162                        workloadArray[SWFFields.DATA_EXECUTABLE_NUMBER]  = IRRELEVANT;
163                        workloadArray[SWFFields.DATA_QUEUE_NUMBER] = IRRELEVANT;
164                        workloadArray[SWFFields.DATA_PARTITION_NUMBER] = IRRELEVANT;
165                        workloadArray[SWFFields.DATA_PRECEDING_JOB_NUMBER] = IRRELEVANT;
166                        workloadArray[SWFFields.DATA_THINK_TIME_FROM_PRECEDING_JOB] = IRRELEVANT;
167                       
168                        writeLine(workloadArray);
169                       
170                }
171               
172                this.tasksLength.clear();
173               
174                return true;
175        }
176       
177        public void addTaskMapping(String swfJobId, String xmlJobId, String xmlTaskId){
178                if(!this.useTaskMapping)
179                        return;
180                this.taskMapping.add(swfJobId+":"+xmlJobId+":"+xmlTaskId);
181        }
182}
Note: See TracBrowser for help on using the repository browser.