source: xssim/src/simulator/factory/QueueingSystemFactory.java @ 104

package simulator.factory;

import java.util.ArrayList;
import java.util.HashMap;

import qcg.qcg_broker.types.HostParametersItem;
import qcg.qcg_broker.types.hostspec.ClusterMachines;
import qcg.qcg_broker.types.hostspec.Queue;
import qcg.qcg_broker.types.hostspec.QueueResourcesCollective;
import qcg.qcg_broker.types.hostspec.QueueingSystem;
import qcg.qcg_broker.types.hostspec.QueuesGroup;
import qcg.qcg_broker.types.hostspec.QueuesGroupChoice;
import org.qcg.broker.schemas.hostparams.HostParameters;
import simulator.RandomNumbers;
import simulator.hostspec.ForecastFinishTimePluginName;
import simulator.hostspec.LocalAllocationPolicyPluginName;
import simulator.hostspec.Plugins;


/**
 * This factory can create qcg.qcg_broker.types.hostspec.QueueingSystem
 * based on simulator.hostspec.QueueingSystem description
 * @author Marcin Krystek
 *
 */

public class QueueingSystemFactory {
        public static String QUEUE_GROUP = "queueGroup";
        public static String QUEUE = "queue";
        public static String PRIORITY = "priority";
        public static String MAX_JOBS = "maxJobs";
        public static String MAX_RUNNING = "maxRunning";
        public static String MAX_PENDING = "maxPending";
        public static String TOTAL_CPUS = "totalCpus";
        public static String NODE_TOTAL_MEMORY = "nodeTotalMemory";
        
        protected simulator.hostspec.QueueingSystem queueSystem;
        protected RandomNumbers randNumbers;
        protected HashMap <String, String>forecastFinishTimePlugin; 
        protected HashMap <String, String>localAllocationPolicyPlugin;
        
        public QueueingSystemFactory(simulator.hostspec.QueueingSystem queueSystem, RandomNumbers randNumbers){
                this.queueSystem = queueSystem;
                this.randNumbers = randNumbers;
                this.forecastFinishTimePlugin = new HashMap<String, String>();
                this.localAllocationPolicyPlugin = new HashMap<String, String>();
        }
        
        public HostParametersItem[] createQueueingSystem() throws IllegalAccessException {
                if(queueSystem == null)
                        return null;
                
                ArrayList<HostParametersItem> retList = new ArrayList<HostParametersItem>();
                
                int systemCount = queueSystem.getTotalResourceCount();
                int arSystemCount = queueSystem.getARResourceCount();
                Double value;
                String resName;
                
                Plugins plugins = queueSystem.getPlugins();
                
                int timePluginIndex = 0;
                ForecastFinishTimePluginName timePlugin;
                ForecastFinishTimePluginName timePluginName[]  = 
                                plugins.getForecastFinishTimePluginName();
                
                int allocationPluginIndex = 0;
                LocalAllocationPolicyPluginName allocationPlugin;
                LocalAllocationPolicyPluginName allocationPluginName[] = 
                                plugins.getLocalAllocationPolicyPluginName();
                
                for(int i = 0; i < systemCount; i++){
                        HostParametersItem item = new HostParametersItem();
                        QueueingSystem system = new QueueingSystem();
                        
                        value = new Double(randNumbers.getRandomValue(QueueingSystemFactory.QUEUE_GROUP));

                        if(value.intValue() <= 0) 
                                return null;
                        
                        for(int j = 0; j < value.intValue(); j++){
                                
                                QueuesGroup group = new QueuesGroup();
                                
                                group = createQues(group);
                                group = createQueuesGroupChoice(group);
                                system.addQueuesGroup(group);
                        }
                        
                        if(arSystemCount > 0)
                                system.setReservationAvailable(true);
                        else
                                system.setReservationAvailable(true);
                        arSystemCount--;
                        
                        resName = "queueingSystem_"+i;
                        system = setName(system, resName);
                        item.setQueueingSystem(system);
                        retList.add(item);
                        
                        timePlugin = timePluginName[timePluginIndex];
                        forecastFinishTimePlugin.put(resName, timePlugin.getName());
                        
                        timePlugin.setResourcesCountWithThisPlugin(
                                        timePlugin.getResourcesCountWithThisPlugin() - 1);
                        if(timePlugin.getResourcesCountWithThisPlugin() == 0)
                                timePluginIndex++;
                        
                        allocationPlugin = allocationPluginName[allocationPluginIndex];
                        localAllocationPolicyPlugin.put(resName, allocationPlugin.getName());
                        
                        allocationPlugin.setResourcesCountWithThisPlugin(
                                        allocationPlugin.getResourcesCountWithThisPlugin() - 1);
                        if(allocationPlugin.getResourcesCountWithThisPlugin() == 0)
                                allocationPluginIndex++;
                }
                HostParametersItem tab[] = new HostParametersItem[retList.size()];
                return retList.toArray(tab);
        }
        
        
        public HostParameters createQueueingSystem(HostParameters hostParameters) throws IllegalAccessException {
                HostParametersItem tab[] = null;
                tab = createQueueingSystem();
                
                if (tab == null)
                        return hostParameters;
                
                for(int i = 0; i < tab.length; i++){
                        hostParameters.addHostParametersItem(tab[i]);
                }
                
                return hostParameters;
        }
        
        
        protected QueuesGroup createQues(QueuesGroup group) throws IllegalAccessException{
                Double queueCount = randNumbers.getRandomValue(QueueingSystemFactory.QUEUE);
                Double value;
                Queue queue;
                
                if(queueCount.intValue() <= 0)
                        return group;
                
                for(int i = 0; i < queueCount.intValue(); i++){
                        queue = new Queue();
                        value = new Double(randNumbers.getRandomValue(QueueingSystemFactory.PRIORITY));
                        queue.setPriority(value.intValue());
                        
                        value = new Double(randNumbers.getRandomValue(QueueingSystemFactory.MAX_JOBS));
                        queue.setMaxJobs(value.intValue());
                        
                        value = new Double(randNumbers.getRandomValue(QueueingSystemFactory.MAX_RUNNING));
                        queue.setMaxRunning(value.intValue());
                        
                        value = new Double(randNumbers.getRandomValue(QueueingSystemFactory.MAX_PENDING));
                        queue.setMaxPending(value.intValue());
                
                        group.addQueue(queue);
                }
                return group;
        }
        
        protected QueuesGroup createQueuesGroupChoice(QueuesGroup group) throws IllegalAccessException{
                QueuesGroupChoice choice = new QueuesGroupChoice();
                QueueResourcesCollective collective = new QueueResourcesCollective();
                ClusterMachines machines = new ClusterMachines();
                Double value;
                        value = randNumbers.getRandomValue(QueueingSystemFactory.TOTAL_CPUS);
                        machines.setTotalCpus(value.intValue());
                        
                        value = randNumbers.getRandomValue(QueueingSystemFactory.NODE_TOTAL_MEMORY);
                        machines.setNodeTotalMemory(value.intValue());
                        
                collective.setClusterMachines(machines);
                choice.setQueueResourcesCollective(collective);
                group.setQueuesGroupChoice(choice);
                return group;
        }
        
        /**
         * Name of QueueingSystem is name of first Queue in first QueuesGroup
         * @param queueingSystem
         * @return
         */
        public static String getName(QueueingSystem queueingSystem){
                String ret = "";
                ret = queueingSystem.getResManContact();
                return ret;
        }

        
        public static QueueingSystem setName(QueueingSystem queueingSystem, String name){
                queueingSystem.setResManContact(name);
                return queueingSystem;
        }
        
        public HashMap<String, String> getForecastFinishTimePlugin(){
                return forecastFinishTimePlugin;
        }
        
        public HashMap<String, String> getLocalAllocationPolicyPlugin(){
                return localAllocationPolicyPlugin;
        }
}