Context Navigation

ResourceReader.java @ 921

Revision 921, 18.0 KB checked in by wojtekp, 12 years ago (diff)

Property svn:mime-type set to `text/plain`

Rev	Line
[477]	1	package simulator.reader;
	2
	3	import gridsim.ResourceCalendar;
	4
	5	import java.io.File;
	6	import java.io.FileNotFoundException;
	7	import java.io.FileReader;
	8	import java.io.IOException;
	9	import java.util.ArrayDeque;
	10	import java.util.ArrayList;
[512]	11	import java.util.Collections;
	12	import java.util.Comparator;
[477]	13	import java.util.Deque;
	14	import java.util.HashMap;
[490]	15	import java.util.LinkedHashSet;
[477]	16	import java.util.LinkedList;
	17	import java.util.List;
	18	import java.util.Map;
[490]	19	import java.util.Set;
[477]	20
	21	import org.exolab.castor.types.AnyNode;
	22	import org.exolab.castor.xml.MarshalException;
	23	import org.exolab.castor.xml.ValidationException;
	24	import org.qcg.broker.schemas.exception.UnknownParameter;
	25
	26	import schedframe.Initializable;
	27	import schedframe.Parameter;
	28	import schedframe.Parameters;
	29	import schedframe.ResourceController;
	30	import schedframe.exceptions.ResourceException;
[512]	31	import schedframe.resources.Resource;
[477]	32	import schedframe.resources.StandardResourceType;
	33	import schedframe.resources.computing.ComputingResource;
	34	import schedframe.resources.computing.ResourceFactory;
	35	import schedframe.resources.computing.description.AbstractResourceDescription;
	36	import schedframe.resources.computing.description.ComputingResourceDescription;
	37	import schedframe.resources.units.ResourceUnit;
	38	import schedframe.resources.units.ResourceUnitName;
	39	import schedframe.scheduling.Scheduler;
	40	import schedframe.scheduling.manager.resources.ManagedResources;
	41	import schedframe.scheduling.plugin.SchedulingPlugin;
	42	import schedframe.scheduling.plugin.estimation.ExecutionTimeEstimationPlugin;
	43	import schedframe.scheduling.queue.TaskQueue;
	44	import schedframe.scheduling.queue.TaskQueueList;
	45	import schemas.Environment;
	46	import schemas.ManagedComputingResources;
	47	import schemas.StringValueWithUnit;
	48	import simulator.ConfigurationOptions;
	49	import simulator.utils.InstanceFactory;
	50
	51	public class ResourceReader {
	52
	53	protected String resDescFileName;
	54
	55	protected ResourceCalendar resourceCalendar;
[512]	56	protected List<Initializable> toInit = new ArrayList<Initializable>();
[477]	57
	58	private ExecutionTimeEstimationPlugin execTimeEstimationPlugin;
	59	private String globalSchedulingPluginName;
	60
[490]	61	private Set<String> compResLayers;
	62
[477]	63	public ResourceReader(ConfigurationOptions options) throws IOException {
	64
	65	resDescFileName = options.resdescFileName;
	66	globalSchedulingPluginName = "example.globalplugin.GridFCFSRoundRobinPlugin";
	67	prepareCalendar();
[490]	68	compResLayers = new LinkedHashSet<String>();
[477]	69	}
	70
	71	public ResourceController read() throws MarshalException, ValidationException, FileNotFoundException, Exception,
	72	UnknownParameter {
	73
	74	File file = new File(resDescFileName);
	75	Environment env = Environment.unmarshal(new FileReader(file));
	76
	77	System.out.println("started creating environment description");
	78	List<ComputingResourceDescription> mainCompResDescList = createEnvironmentDescription(env);
	79	System.out.println("finished creating environment description");
	80
	81	System.out.println("started creating resources");
	82	List<ComputingResource> computingResources = createResources(mainCompResDescList);
	83	System.out.println("finished creating resource");
	84
	85	System.out.println("started creating schedulers");
	86	Scheduler mainScheduler = createSchedulers(env.getResources().getScheduler(), computingResources);
	87	System.out.println("finished creating schedulers");
	88
	89	ResourceController rc = new ResourceController(mainScheduler, computingResources);
[512]	90	Collections.sort(toInit, new ResourceTypeComparator(new ArrayList<String>(compResLayers)));
[477]	91	rc.setInitList(toInit);
[490]	92	rc.setCompResLayers(compResLayers);
[477]	93	return rc;
	94	}
	95
	96	protected List<ComputingResourceDescription> createEnvironmentDescription(Environment environment) throws Exception {
	97
	98	List<ComputingResourceDescription> mainCompResDescList = new ArrayList<ComputingResourceDescription>();
	99
	100	LinkedList<ComputingResourceDescription> resDescStructure = new LinkedList<ComputingResourceDescription>();
	101	LinkedList<schemas.ComputingResource> toExamine = new LinkedList<schemas.ComputingResource>();
	102	EnvironmentWrapper environmentWrapper = new EnvironmentWrapper();
	103	environmentWrapper.wrap(environment);
	104
	105	String execTimeEstimationPluginClassName = null;
	106	if(environmentWrapper.getTimeEstimationPlugin() != null){
	107	execTimeEstimationPluginClassName = environmentWrapper.getTimeEstimationPlugin().getName();
	108	}
	109
	110	try{
	111	execTimeEstimationPlugin = (ExecutionTimeEstimationPlugin) InstanceFactory.createInstance(
	112	execTimeEstimationPluginClassName, ExecutionTimeEstimationPlugin.class);
	113	if(execTimeEstimationPlugin == null) {
	114	execTimeEstimationPluginClassName = "example.timeestimation.DefaultTimeEstimationPlugin";
	115	execTimeEstimationPlugin = (ExecutionTimeEstimationPlugin) InstanceFactory.createInstance(
	116	execTimeEstimationPluginClassName, ExecutionTimeEstimationPlugin.class);
	117	} else {
	118	Parameters params = EnvironmentWrapper.extractParameters(environmentWrapper.getTimeEstimationPlugin().getParameter());
	119	execTimeEstimationPlugin.init(params);
	120	}
	121	} catch (Exception e){
	122	if (execTimeEstimationPlugin == null) {
	123	throw new Exception("Can not create execution time estimation plugin instance.");
	124	}
	125	}
	126
	127	if(environmentWrapper.getComputingResources() != null) {
	128	for(int i = 0; i < environmentWrapper.getComputingResources().length; i++){
	129	schemas.ComputingResource compResDef = environmentWrapper.getComputingResources()[i];
	130	toExamine.push(compResDef);
	131
	132	ComputingResourceDescription compResDesc = new ComputingResourceDescription(compResDef);
	133	resDescStructure.push(compResDesc);
	134	mainCompResDescList.add(compResDesc);
	135	}
	136	}
	137	while (!toExamine.isEmpty()) {
	138	schemas.ComputingResource parentCompResDef = toExamine.pop();
	139	ComputingResourceDescription parentExecResDesc = resDescStructure.pop();
	140	if(parentCompResDef.getComputingResourceTypeChoiceSequence() != null)
	141	{
	142	int computingResourceCount = parentCompResDef.getComputingResourceTypeChoiceSequence().getComputingResourceCount();
	143	for (int i = 0; i < computingResourceCount; i++) {
	144
	145	schemas.ComputingResource compResDef = parentCompResDef.getComputingResourceTypeChoiceSequence().getComputingResource(i);
	146	if(compResDef == null)
	147	continue;
	148	long compResCount = compResDef.getCount() > 1 ? compResDef.getCount() : 1;
	149
	150	for(int j = 0; j < compResCount; j++){
	151	if(compResDef.getComputingResourceTypeChoiceSequence2() != null){
[921]	152	String templateId = compResDef.getComputingResourceTypeChoiceSequence2().getTemplateId();
[477]	153	schemas.ComputingResourceTemplate template = environmentWrapper.getTemplate(templateId);
	154	environmentWrapper.initWithCompResTemplate(compResDef, template);
	155	}
	156	//toExamine.insertElementAt(compResDef, 0);
	157	toExamine.addLast(compResDef);
	158	ComputingResourceDescription resDesc = new ComputingResourceDescription(compResDef);
	159	parentExecResDesc.addChildren(resDesc);
	160	//resDescStructure.insertElementAt(resDesc, 0);
	161	resDescStructure.addLast(resDesc);
	162	}
	163	}
	164	} else
	165	continue;
	166	}
	167	return mainCompResDescList;
	168	}
	169
	170	protected List<ComputingResource> createResources(List<ComputingResourceDescription> mainCompResDesList) {
	171
	172	List<ComputingResource> mainCompResourceList = new ArrayList<ComputingResource>();
	173	Deque<ComputingResourceDescription> toExamine = new ArrayDeque<ComputingResourceDescription>();
	174	Deque<ComputingResource> resStructure = new ArrayDeque<ComputingResource>();
	175
	176	for(ComputingResourceDescription mainExecResDes : mainCompResDesList){
	177	ComputingResource mainResource = ResourceFactory.createResource(mainExecResDes);
	178	toExamine.push(mainExecResDes);
	179	resStructure.push(mainResource);
	180	mainCompResourceList.add(mainResource);
	181	}
	182
	183	while (!toExamine.isEmpty()) {
	184	ComputingResourceDescription parentResDesc = toExamine.pop();
	185	ComputingResource parentResource = resStructure.pop();
	186	toInit.add(parentResource);
[490]	187	compResLayers.add(parentResource.getType().getName());
[477]	188	List<AbstractResourceDescription> childrenResDesc = parentResDesc.getChildren();
	189	if (childrenResDesc == null){
	190	continue;
	191	}
	192	int compResCount = childrenResDesc.size();
	193	for (int i = 0; i < compResCount; i++) {
	194	ComputingResourceDescription compResDesc = (ComputingResourceDescription) childrenResDesc.get(i);
	195	toExamine.push(compResDesc);
	196	ComputingResource resource = ResourceFactory.createResource(compResDesc);
	197	parentResource.addChild(resource);
	198	resStructure.push(resource);
	199	}
	200	}
	201	return mainCompResourceList;
	202	}
	203
	204	protected Scheduler createSchedulers(schemas.Scheduler[] schedulersDef, List<ComputingResource> mainCompResourceList) throws Exception{
	205
	206	List<Scheduler> mainSchedulers = new ArrayList<Scheduler>();
	207
	208	Deque<schemas.Scheduler> toExamine = new ArrayDeque<schemas.Scheduler>();
	209	Deque<Scheduler> schedulersStructure = new ArrayDeque<Scheduler>();
	210	for(int i = 0; i < schedulersDef.length; i++){
	211	schemas.Scheduler schedulerDef = schedulersDef[i];
	212	Scheduler mainScheduler = initScheduler(schedulerDef, mainCompResourceList);
	213	toExamine.push(schedulerDef);
	214	schedulersStructure.push(mainScheduler);
	215	mainSchedulers.add(mainScheduler);
	216	}
	217
	218	while (!toExamine.isEmpty()) {
	219	schemas.Scheduler parentSchedulerDef = toExamine.pop();
	220
	221	Scheduler parentScheduler = null;
	222	if(!schedulersStructure.isEmpty())
	223	parentScheduler = schedulersStructure.pop();
	224
	225	if(parentSchedulerDef.getSchedulerTypeChoice() == null)
	226	continue;
	227	int schedulerChoiceItemCount = parentSchedulerDef.getSchedulerTypeChoice().getSchedulerTypeChoiceItemCount();
	228	for (int i = 0; i < schedulerChoiceItemCount; i++) {
	229	schemas.Scheduler schedulerDef = parentSchedulerDef.getSchedulerTypeChoice().getSchedulerTypeChoiceItem(i).getScheduler();
	230	if(schedulerDef == null)
	231	continue;
	232	else
	233	{
	234	Scheduler scheduler = initScheduler(schedulerDef, mainCompResourceList);
	235	schedulersStructure.push(scheduler);
	236	parentScheduler.addChild(scheduler);
	237	toExamine.push(schedulerDef);
	238	}
	239	}
	240	//necessary if children list isn't initialized in Scheduler
	241	//parentScheduler.init();
	242	}
	243
	244	//TODO - refactor (remove - create scheduler on the basis of resource description)
	245	Scheduler mainScheduler = null;
[506]	246	if(mainSchedulers.size() == 1 /&& mainSchedulers.get(0).get_name().equals("grid")/){
[477]	247	mainScheduler = mainSchedulers.get(0);
	248	}
	249	else{
	250	SchedulingPlugin schedulingPlugin = (SchedulingPlugin) InstanceFactory.createInstance(globalSchedulingPluginName,
	251	SchedulingPlugin.class);
	252	TaskQueueList queues = new TaskQueueList(1);
	253	TaskQueue queue = new TaskQueue(false);
	254	queues.add(queue);
	255	ManagedResources managedResources = new ManagedResources(mainCompResourceList, new HashMap<ResourceUnitName, List<ResourceUnit>>());
	256	mainScheduler = ResourceFactory.createScheduler(StandardResourceType.GS, "grid", schedulingPlugin , execTimeEstimationPlugin, queues, managedResources);
[509]	257
[477]	258	for(Scheduler lr: mainSchedulers){
	259	mainScheduler.addChild(lr);
	260	}
	261	//necessary if children list isn't initialized in Scheduler
	262	//mainScheduler.init();
	263	}
	264	return mainScheduler;
	265	}
	266
	267	protected Scheduler initScheduler(schemas.Scheduler schedulerDef, List<ComputingResource> mainCompResourceList) throws Exception{
	268	Scheduler scheduler = null;
	269
	270	ManagedResources managedResources = null;
	271	//List<ComputingResource> managedCompResources = new ArrayList<ComputingResource>();
	272	TaskQueueList queues = new TaskQueueList(1);
	273
	274	if(schedulerDef.getQueues()!= null){
	275	int queueCount = schedulerDef.getQueues().getQueueCount();
	276	for(int i = 0; i < queueCount; i++){
	277	schemas.QueueType queueDef = schedulerDef.getQueues().getQueue(i);
	278	TaskQueue queue = new TaskQueue(queueDef.getReservation());
	279	queue.setName(queueDef.getName());
	280	queue.setPriority(queueDef.getPriority());
	281	queues.add(queue);
	282	}
	283	} else {
	284	TaskQueue queue = new TaskQueue(false);
	285	queues.add(queue);
	286	}
	287
	288	if(schedulerDef.getSchedulerTypeChoice() != null) {
	289	int schedulerChoiceItemCount = schedulerDef.getSchedulerTypeChoice().getSchedulerTypeChoiceItemCount();
	290	for (int i = 0; i < schedulerChoiceItemCount; i++) {
	291	ManagedComputingResources mcr = schedulerDef.getSchedulerTypeChoice().getSchedulerTypeChoiceItem(i).getManagedComputingResources();
	292	if(mcr == null)
	293	continue;
	294
	295	List<String> managedCompResourcesIds = new ArrayList<String>();
	296	int resourceNameCount = mcr.getResourceNameCount();
	297	for(int j = 0; j < resourceNameCount; j++) {
	298	managedCompResourcesIds.add(mcr.getResourceName(j));
	299	}
	300	managedResources = matchResourcesForScheduler(mainCompResourceList, managedCompResourcesIds, mcr.getInclude());
	301	//managedResources = new ManagedResources(managedCompResources, new HashMap<ResourceUnitName, List<ResourceUnit>>());
	302	}
	303	}
	304
	305	SchedulingPlugin schedulingPlugin = null;
	306	if(schedulerDef.getSchedulingPlugin() != null){
	307	String schedulingPluginName = schedulerDef.getSchedulingPlugin().getName();
	308	schedulingPlugin = (SchedulingPlugin) InstanceFactory.createInstance(schedulingPluginName,
	309	SchedulingPlugin.class);
	310	Parameters params = EnvironmentWrapper.extractParameters(schedulerDef.getSchedulingPlugin().getParameter());
	311	if(schedulerDef.getSchedulingPlugin().getFrequency() != null)
	312	{
	313	Parameter param = new Parameter("frequency");
	314	StringValueWithUnit sv = new StringValueWithUnit();
	315	sv.setContent(String.valueOf(schedulerDef.getSchedulingPlugin().getFrequency().getContent()));
	316	sv.setUnit(schedulerDef.getSchedulingPlugin().getFrequency().getUnit());
	317	param.add(sv);
	318
	319	if(params == null)
	320	params = new Parameters();
	321	params.put("frequency", param);
	322	}
	323	schedulingPlugin.init(params);
	324	}
	325
	326	//TODO - refactor (create scheduler in 1 line)
	327	if(schedulerDef.getClazz().equals("GridBroker")){
	328	scheduler = ResourceFactory.createScheduler(StandardResourceType.GS, "grid", schedulingPlugin, execTimeEstimationPlugin, queues, managedResources);
	329	} else {
	330	scheduler = ResourceFactory.createScheduler(StandardResourceType.LS, schedulerDef.getName(), schedulingPlugin, execTimeEstimationPlugin, queues, managedResources);
	331	}
	332	return scheduler;
	333	}
	334
	335	/*private List<ComputingResource> matchCompResourcesForScheduler(List<ComputingResource> mainCompResourceList, List<String> resIdList, boolean include){
	336	List<ComputingResource> compResources = new ArrayList<ComputingResource>();
	337	for(ComputingResource mainCompRes: mainCompResourceList){
	338	for(String resourceName : resIdList){
	339	ComputingResource computingResource;
	340	try {
	341	if(resourceName.equals(mainCompRes.getName()))
	342	computingResource = mainCompRes;
	343	else
	344	computingResource = mainCompRes.getDescendantByName(resourceName);
	345	} catch (ResourceException e) {
	346	computingResource = null;
	347	}
	348	if(computingResource != null)
	349	{
	350	if(include){
	351	compResources.add(computingResource);
	352	} else{
	353	compResources.addAll(computingResource.getChildren());
	354	}
	355	}
	356	}
	357	}
	358	return compResources;
	359	}*/
	360
	361	private ManagedResources matchResourcesForScheduler(List<ComputingResource> mainCompResourceList, List<String> resIdList, boolean include){
	362
	363	List<ComputingResource> compResources = new ArrayList<ComputingResource>();
	364	Map<ResourceUnitName, List<ResourceUnit>> resourceUnits = new HashMap<ResourceUnitName, List<ResourceUnit>>();
	365
	366	for(ComputingResource mainCompRes: mainCompResourceList){
	367	for(String resourceName : resIdList){
	368	ComputingResource computingResource;
	369	try {
	370	if(resourceName.equals(mainCompRes.getName()))
	371	computingResource = mainCompRes;
	372	else
	373	computingResource = mainCompRes.getDescendantByName(resourceName);
	374	} catch (ResourceException e) {
	375	continue;
	376	}
	377	if(computingResource != null)
	378	{
	379	if(include){
	380	compResources.add(computingResource);
	381	} else{
	382	compResources.addAll(computingResource.getChildren());
	383	resourceUnits = getSharedResourceUnits(computingResource);
	384	}
	385	}
	386	}
	387	}
	388	return new ManagedResources(compResources, resourceUnits);
	389	}
	390
	391
	392	private Map<ResourceUnitName, List<ResourceUnit>> getSharedResourceUnits(ComputingResource compResources){
	393	Map<ResourceUnitName, List<ResourceUnit>> resourceUnits = new HashMap<ResourceUnitName, List<ResourceUnit>>();
	394	List<ResourceUnit> list;
	395	boolean resourceNotVisited = true;
	396	ComputingResource parent = compResources;
	397	while(parent != null && resourceNotVisited){
	398	Map<ResourceUnitName, List<ResourceUnit>> resUnits = parent.getResourceCharacteristic().getResourceUnits();
	399	for(ResourceUnitName run : resUnits.keySet()){
	400	for(ResourceUnit resUnit : resUnits.get(run)){
	401	if((resourceUnits.get(run) == null)){
	402	list = new ArrayList<ResourceUnit>(1);
	403	resourceUnits.put(resUnit.getName(), list);
	404	list.add(resUnit);
	405	} else if(!resourceUnits.get(run).contains(resUnit)){
	406	list = resourceUnits.get(resUnit.getName());
	407	list.add(resUnit);
	408	} else {
	409	resourceNotVisited = false;
	410	}
	411	}
	412	}
	413	parent = parent.getParent();
	414	}
	415	return resourceUnits;
	416	}
	417
	418	private void prepareCalendar() {
	419	long seed = 11L * 13L * 17L * 19L * 23L + 1L;
	420	double timeZone = 0.0;
	421	double peakLoad = 0.0; // the resource load during peak hour
	422	double offPeakLoad = 0.0; // the resource load during off-peak hr
	423	double holidayLoad = 0.0; // the resource load during holiday
	424
	425	// incorporates weekends so the grid resource is on 7 days a week
	426	LinkedList<Integer> Weekends = new LinkedList<Integer>();
	427	Weekends.add(java.util.Calendar.SATURDAY);
	428	Weekends.add(java.util.Calendar.SUNDAY);
	429
	430	// incorporates holidays. However, no holidays are set in this example
	431	LinkedList<Integer> Holidays = new LinkedList<Integer>();
	432	resourceCalendar = new ResourceCalendar(timeZone, peakLoad, offPeakLoad, holidayLoad, Weekends, Holidays,
	433	seed);
	434	}
	435
[512]	436	class ResourceTypeComparator implements Comparator<Initializable>{
	437
	438	List<String> order;
	439	ResourceTypeComparator(List<String> order) {
	440	this.order = order;
	441	}
	442	public int compare(Initializable init1, Initializable init2) {
	443	String type1 = ((Resource)init1).getType().getName();
	444	String type2 = ((Resource)init2).getType().getName();
	445	if(order.indexOf(type1) > order.indexOf(type2))
	446	return -1;
	447	else if (order.indexOf(type1) < order.indexOf(type2))
	448	return 1;
	449	else return 0;
	450
	451	}
	452	}
	453
[477]	454	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format