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

package simulator.factory;

import simulator.RandomNumbers;
import simulator.hostspec.CpuCount;
import simulator.hostspec.CpuLoad;
import simulator.hostspec.CpuSpeed;
import simulator.hostspec.DiskFree;
import simulator.hostspec.DiskTotal;
import simulator.hostspec.MemoryFree;
import simulator.hostspec.MemoryTotal;
import simulator.hostspec.ResourcesConfiguration;
import simulator.hostspec.SwapFree;
import simulator.hostspec.SwapTotal;
import simulator.hostspec.RandParams;

/**
 * 
 * @author Marcin Krystek
 *
 */
public class ResourcesRandomNumbersFactory {

        public RandomNumbers initRandomNumbers(ResourcesConfiguration resConfig){
                RandomNumbers randNumbers = new RandomNumbers();
                
                simulator.hostspec.SingleResource singleRes = resConfig.getSingleResource();
                if(singleRes != null) {
                CpuCount cpuCount = singleRes.getCpuCount();
                addRandomNumbers(randNumbers, cpuCount, SingleResourceFactory.CPU_COUNT);
                
                CpuSpeed cpuSpeed = singleRes.getCpuSpeed();
                addRandomNumbers(randNumbers, cpuSpeed, SingleResourceFactory.CPU_SPEED);
                
                CpuLoad cpuLoad = singleRes.getCpuLoad();
                addRandomNumbers(randNumbers, cpuLoad, SingleResourceFactory.CPU_LOAD);
                
                MemoryTotal memoryTotal = singleRes.getMemoryTotal();
                addRandomNumbers(randNumbers, memoryTotal, SingleResourceFactory.MEMORY_TOTAL);
                
                MemoryFree memoryFree = singleRes.getMemoryFree();
                addRandomNumbers(randNumbers, memoryFree, SingleResourceFactory.MEMORY_FREE);
                
                SwapTotal swapTotal = singleRes.getSwapTotal();
                addRandomNumbers(randNumbers, swapTotal, SingleResourceFactory.SWAP_TOTAL);
                
                SwapFree swapFree = singleRes.getSwapFree();
                addRandomNumbers(randNumbers, swapFree, SingleResourceFactory.SWAP_FREE);
                
                DiskTotal diskTotal = singleRes.getDiskTotal();
                addRandomNumbers(randNumbers, diskTotal, SingleResourceFactory.DISK_TOTAL);
                
                DiskFree diskFree = singleRes.getDiskFree();
                addRandomNumbers(randNumbers, diskFree, SingleResourceFactory.DISK_FREE);
                }
                
                simulator.hostspec.QueueingSystem queueSystem = resConfig.getQueueingSystem();

                if(queueSystem != null){
                simulator.hostspec.QueuesGroup queueGroup = queueSystem.getQueuesGroup();
                
                randNumbers.addRandomGenerator(
                                queueGroup.getDistribution().getType(),
                                queueGroup.hasAvg(),
                                queueGroup.getAvg(), 
                                queueGroup.getStdev(), 
                                queueGroup.hasMin(),
                                queueGroup.getMin(),
                                queueGroup.hasMax(),
                                queueGroup.getMax(), 
                                queueGroup.hasSeed(), 
                                queueGroup.getSeed(), 
                                QueueingSystemFactory.QUEUE_GROUP);
                        
                simulator.hostspec.Queue queue = queueGroup.getQueue();
                        randNumbers.addRandomGenerator(
                                queue.getDistribution().getType(),
                                queue.hasAvg(),
                                queue.getAvg(), 
                                queue.getStdev(), 
                                queue.hasMin(),
                                queue.getMin(),
                                queue.hasMax(),
                                queue.getMax(), 
                                queue.hasSeed(), 
                                queue.getSeed(), 
                                QueueingSystemFactory.QUEUE);
        
                simulator.hostspec.Priority priority = queue.getPriority();
                addRandomNumbers(randNumbers, priority, QueueingSystemFactory.PRIORITY);
                        
                simulator.hostspec.MaxJobs maxJobs = queue.getMaxJobs();
                addRandomNumbers(randNumbers, maxJobs, QueueingSystemFactory.MAX_JOBS);
                        
                simulator.hostspec.MaxRunning maxRunning = queue.getMaxRunning();
                addRandomNumbers(randNumbers, maxRunning, QueueingSystemFactory.MAX_RUNNING);
                        
                simulator.hostspec.MaxPending maxPending = queue.getMaxPending();
                addRandomNumbers(randNumbers, maxPending, QueueingSystemFactory.MAX_PENDING);
                
                simulator.hostspec.QueueResourcesCollective resCollective = queueGroup.getQueueResourcesCollective();
                simulator.hostspec.NodeTotalMemory totalMemory =  resCollective.getNodeTotalMemory();
                addRandomNumbers(randNumbers, totalMemory, QueueingSystemFactory.NODE_TOTAL_MEMORY);
                        
                simulator.hostspec.TotalCpus totalCpus =  resCollective.getTotalCpus();
                addRandomNumbers(randNumbers, totalCpus, QueueingSystemFactory.TOTAL_CPUS);
                }
                
                return randNumbers;
        }
        
        public static void addRandomNumbers(RandomNumbers rn, RandParams rp, String name) {
                rn.addRandomGenerator(rp.getDistribution().getType(), rp.hasAvg(), rp.getAvg(), rp.getStdev(), rp.hasMin(), rp.getMin(), rp.hasMax(), rp.getMax(), rp.hasSeed(), rp.getSeed(), name);
        }
}