source: DCWoRMS/trunk/src/simulator/RandomNumbers.java @ 477

package simulator;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import simulator.stats.random.MinMaxDistribution;
import simulator.workload.generator.configuration.Dist;
import simulator.workload.generator.configuration.PeriodicValidValues;
import simulator.workload.generator.configuration.types.ParameterAttributesDistributionType;
import cern.jet.random.AbstractDistribution;
import cern.jet.random.Exponential;
import cern.jet.random.Gamma;
import cern.jet.random.Normal;
import cern.jet.random.Poisson;
import cern.jet.random.Uniform;
import cern.jet.random.engine.MersenneTwister64;
import cern.jet.random.engine.RandomEngine;
import eduni.simjava.distributions.AbstractSpecificGenerator;
import eduni.simjava.distributions.DetailDistGenerator;
import eduni.simjava.distributions.GeneralGenerator;
import eduni.simjava.distributions.PeriodicGenerator;

/**
 * A class that stores random number generator for given metrics. Its functionality is basically similar to a hash table
 * where a key is a metric name and a value stored at that key is a previously set random number generator with proper distribution
 * @author Stanislaw Szczepanowski
 *
 */
public class RandomNumbers {

        /**
         * a hash table that stores the random number generators on the basis of the given key
         * the key is the name of the parameter (metric name, String object), for which a random generator should be retrieved
         */
        protected Map<String, List<AbstractSpecificGenerator>> rndGenerators;  

        /**
         * holds mapping between node id and internal random numbers generator name.
         */
        protected HashMap<String, String> idMap;
        
        /**
         * A field indicating, that if no seed is given to a value, this global seed is to be used. 
         * If this value is <code>null</code>, then a random number is to be picked (e.g. System.nanoTime()).
         * Such functionality is used for example for test purposes.
         */
        protected static Long baseSeed;
        
        /**
         * Default constructor
         */
        public RandomNumbers() {
                rndGenerators = new HashMap<String, List<AbstractSpecificGenerator>>(); 
                idMap = new HashMap<String, String>();
                init();
        }
        
        /**
         * Constructor with initial capacity
         * @param initialCapacity the initial capacity of this hash map
         */
        public RandomNumbers(int initialCapacity) {
                rndGenerators = new HashMap<String, List<AbstractSpecificGenerator>>(initialCapacity);
                idMap = new HashMap<String, String>(initialCapacity);
                init();
        }
        
        /** A common initialization method used in constructors */
        protected void init() {
        }
        
        /**
         * Adds a random number generator at given key (name) 
         * @param parameterName the name of the generator
         * @param generator the generator to be stored
         */
        public void addRandomGenerator(String parameterName, PeriodicGenerator generator) {
                List<AbstractSpecificGenerator> list;
                
                if(rndGenerators.containsKey(parameterName)){
                        list = rndGenerators.get(parameterName);
                        list.add(generator);
                } else {
                        list = new ArrayList<AbstractSpecificGenerator>(1);
                        list.add(generator);
                        rndGenerators.put(parameterName, list);
                }
        }
        
        public void addRandomGenerator(String parameterName, DetailDistGenerator generator){
                ArrayList <AbstractSpecificGenerator>list;
                int idx = -1;
                if(rndGenerators.containsKey(parameterName)){
                        list = (ArrayList<AbstractSpecificGenerator>) rndGenerators.get(parameterName);
                        list.ensureCapacity(list.size() + 1);

                        // this should guarantee, that elements on the list are ordered.
                        while(++idx < list.size() && generator.compareTo(list.get(idx)) > 0);
                        list.add(idx, generator);
                        
                } else {
                        list = new ArrayList<AbstractSpecificGenerator>(1);
                        list.add(generator);
                        rndGenerators.put(parameterName, list);
                }
        }
        
        public boolean addRandomGenerator(String parameterName, Dist detailDist){
                Double percnt = Double.valueOf(detailDist.getContent());
                
                AbstractDistribution generator = createRandomGenerator(
                                detailDist.getDistribution().getType(), detailDist.hasAvg(), detailDist.getAvg(),
                                detailDist.getStdev(), detailDist.hasMin(), detailDist.getMin(),
                                detailDist.hasMax(), detailDist.getMax(), detailDist.hasSeed(), detailDist.getSeed(), parameterName);
                
                if(generator == null)
                        return false;
                
                DetailDistGenerator ddg = new DetailDistGenerator(generator, percnt);
                addRandomGenerator(parameterName, ddg);
                
                return true;
        }
        
        public boolean addRandomGenerator(String parameterName,  PeriodicValidValues values){
                AbstractDistribution generator = createRandomGenerator(
                                        values.getDistribution().getType(), values.hasAvg(), values.getAvg(),
                                        values.getStdev(), values.hasMin(), values.getMin(), 
                                        values.hasMax(), values.getMax(), values.hasSeed(), values.getSeed(), parameterName);
                
                if(generator == null)
                        return false;
                
                PeriodicGenerator pg = new PeriodicGenerator(generator, values.getBeginValidTime(), values.getEndValidTime());
                addRandomGenerator(parameterName, pg);
                
                return true;
        }

        
        /**
         * Creates and stores a random numbers generator
         * @param distribution the distribution of this generator descried as in {@link ParameterAttributesDistributionType}
         * @param avg the average value
         * @param stdev the standard deviation value 
         * @param min minimal value
         * @param max maximal value
         * @param useSeed true, if the given seed is to be used
         * @param seed the seed for random number generator
         * @param name the name of the random numbers generator
         */
        public boolean addRandomGenerator(int distribution, boolean useAvg, double avg, double stdev, boolean useMin, double min, boolean useMax, double max, boolean useSeed, long seed, String name) {
                AbstractDistribution generator = createRandomGenerator(distribution, useAvg, avg, stdev, useMin, min, useMax, max, useSeed, seed, name);
                if(generator == null)
                        return false;
                
                GeneralGenerator gg = new GeneralGenerator(generator);
                List<AbstractSpecificGenerator> list;
                
                if(rndGenerators.containsKey(name)){
                        list = rndGenerators.get(name);
                        list.add(gg);
                } else {
                        list = new ArrayList<AbstractSpecificGenerator>(1);
                        list.add(gg);
                        rndGenerators.put(name, list);
                }
                
                return true;
        }
        
        
        
        /**
         * Retrieves the next random value from the given random numbers generator.
         * Generator is valid for whole simulation time.
         * @param parameterName the random numbers generator name
         * @return the next random value (according to the setting of the random numbers generator)
         * @throws IllegalAccessException
         */
        public double getRandomValue(String parameterName) throws IllegalAccessException{
                List<AbstractSpecificGenerator> list = rndGenerators.get(parameterName);
                AbstractSpecificGenerator asg;
                AbstractDistribution generator = null;
                double ret;
                
                if(list == null || list.size() == 0){
                        throw new IllegalAccessException("No random generator for given metric " + parameterName);
                }
                
                // generator on index 0 should be valid for whole simulation period, if PeriodicGenerator is used or
                // should cover 100% of tasks if DetailDistGenerator is used
                asg = list.get(0);
                
                generator = asg.getGenerator();
                
                ret = generator.nextDouble();
                asg.setLastGeneratedValue(ret);
                
                return ret;
        }
        
        public double getLastGeneratedRandomValue(String parameterName) throws IllegalAccessException{
                List<AbstractSpecificGenerator> list = rndGenerators.get(parameterName);
                AbstractSpecificGenerator asg = list.get(0);
                return asg.getLastGeneratedValue();
        }
        
        
        /**
         * Retrieves the next random value from the given random numbers generator.
         * Generator is valid only for some period of simulation time.
         * @param parameterName the random numbers generator name
         * @param time current simulation time
         * @return the next random value (according to the setting of the random numbers generator)
         * @throws IllegalAccessException
         */
        public double getRandomValue(String parameterName, long time) throws IllegalAccessException {
                List<AbstractSpecificGenerator> list = rndGenerators.get(parameterName);
                AbstractSpecificGenerator asg = null;
                PeriodicGenerator pGen = null;
                AbstractDistribution generator = null;
                double ret;
                
                if(list == null || list.size() == 0) {
                        throw new IllegalAccessException("No random generator for given metric " + parameterName);
                }
                
                for(int i = 1; i < list.size(); i++){
                        asg = list.get(i);
                        if(asg instanceof PeriodicGenerator)
                                pGen = (PeriodicGenerator) asg;
                        else
                                throw new RuntimeException("Wrong specific generator type. PeriodicGenerator was expected.");
                        
                        if(pGen.isValid(time)){
                                generator = pGen.getGenerator();
                                break;
                        }
                }
                
                // generator on index = 0 should be valid for whole simulation period
                if(generator == null) {
                        pGen = (PeriodicGenerator)list.get(0);
                        if(pGen.isValid(time)){
                                generator = pGen.getGenerator();
                        }
                }
                
                if(generator == null)
                        throw new IllegalAccessException("No valid "+parameterName+" generator for given time " + time);
                ret = generator.nextDouble();
                
                return ret;
        }
        
        /**
         * Retrieves the next random value from the given random numbers generator.
         * Generator is valid for specified percent of generated tasks.
         * @param parameterName
         * @param prcnt
         * @return
         * @throws IllegalAccessError
         */
        public double getRandomValue(String parameterName, double prcnt) throws IllegalAccessError {
                int idx = 0;
                double prcntSum = 0.0;
                DetailDistGenerator ddg = null;
                
                if(!rndGenerators.containsKey(parameterName))
                        throw new IllegalAccessError("No generators for "+parameterName+" available.");
                
                List <AbstractSpecificGenerator> list = rndGenerators.get(parameterName);

                if(list.size() == 0)
                        throw new IllegalAccessError("No generator for "+parameterName + " available.");
                
                if(list.get(0) instanceof DetailDistGenerator){
                        /* 
                         * Looking for appropriate generator.
                         * List of elements is ordered from min to max. For loop is checking to which interval requested 
                         * percent belongs to.
                         */
                        for(idx = 0; idx < list.size(); idx++){
                                ddg = (DetailDistGenerator)list.get(idx);
                                prcntSum = prcntSum + ddg.getPrcnt();
                                // this is to handle double numbers representation precision
                                if((prcntSum - prcnt) > 0.000000001)
                                        break;
                        }
                        
                        if(idx >= list.size())
                                throw new IllegalAccessError("Value "+prcnt +" doeas not belong to any interval defined by DetailDistGenerators");

                        return ddg.getGenerator().nextDouble();

                } else {
                        throw new IllegalAccessError(list.get(0).getClass().getName() +
                                        " generator can not be used for evaluating values for multidistribution element definition.\n" +
                                        "Use " + DetailDistGenerator.class.getName() + " instead.");
                }
        }
        
        /**
         * Retrieves a snapshot of all random numbers generators next random values
         * @return a result hash map has structure of pairs as: &lt;String random_numbers_generator_name, Double random_value&gt;
         */
        public Map<String, Double> getMappedRandomValues() {
                Map<String, Double> resultHashMap = new HashMap<String, Double>(rndGenerators.size());
                
                Set<String> keys = rndGenerators.keySet();
                for (Iterator<String> i = keys.iterator(); i.hasNext(); ) {
                        String name = i.next();
                        Double value = null;
                        try {
                                value = new Double(getRandomValue(name));
                        } catch (IllegalAccessException e) {
                                e.printStackTrace();
                        }
                        resultHashMap.put(name, value);
                }
                
                return resultHashMap;
        }

        /**
         * Constructs a new random numbers generator.
         * 
         * @param distribution the distribution of this generator descried as in {@link ParameterAttributesDistributionType}
         * @param useAvg <code>true</code>, if the given average value is to be used; <code>false</code> otherwise
         * @param avg the average value
         * @param stdev the standard deviation value 
         * @param useMin <code>true</code>, if the given minimal value is to be used; <code>false</code> otherwise
         * @param min minimal value
         * @param useMax <code>true</code>, if the given maximal value is to be used; <code>false</code> otherwise
         * @param max maximal value
         * @param useSeed <code>true</code>, if the given seed is to be used; <code>false</code> otherwise
         * @param seed the seed for random number generator
         * @param name the name of the random numbers generator
         * @return the constructed random numbers generator
         */
        public AbstractDistribution createRandomGenerator(int distribution, boolean useAvg, double avg, double stdev, boolean useMin, double min, boolean useMax, double max, boolean useSeed, long seed, String name) {
                AbstractDistribution resultGenerator = null;
                
                if(useAvg == false && useMax == false && useMin == false)
                        return null;
                
                int validSeed = -1;
                if (isBaseSeedSet()) { //use the base seed (has the highest priority)
                        validSeed = baseSeed.intValue();
                } else if (useSeed) {
                        validSeed = (int) seed;
                } else { //don't use seed
                        validSeed = (int) System.nanoTime();
                }
                
                RandomEngine randomEngine = new MersenneTwister64(validSeed);
                
                switch (distribution) {
                case ParameterAttributesDistributionType.CONSTANT_TYPE:
                        //this will result in a generator of constant values equal to avg
                        resultGenerator = new Normal(avg, 0.0, randomEngine); 
                        break;

                case ParameterAttributesDistributionType.NORMAL_TYPE:
                        resultGenerator = new Normal(avg, stdev, randomEngine);
                        break;

                case ParameterAttributesDistributionType.POISSON_TYPE:
                        resultGenerator = new Poisson(avg, randomEngine);
                        break;

                case ParameterAttributesDistributionType.UNIFORM_TYPE:
                        resultGenerator = new Uniform(min, max, randomEngine);
                        break;
                        
                case ParameterAttributesDistributionType.EXPONENTIAL_TYPE:
                        resultGenerator = new Exponential(avg, randomEngine);
                        break;
                        
                case ParameterAttributesDistributionType.GAMMA_TYPE:
                        resultGenerator = new Gamma(avg, stdev, randomEngine);
                        break;

                case ParameterAttributesDistributionType.HARMONIC_TYPE:
                        resultGenerator = null; //TODO finish implementation
                        break;
                }
                Double minValue = null;
                Double maxValue = null;
                boolean wrap = false; //indicates, whether the wrapper should be used
                if (useMin) {
                        minValue = min;
                        wrap = true;
                }
                if (useMax) {
                        maxValue = max;
                        wrap = true;
                }
                if (wrap) //wrap the generator, only if necessary
                        resultGenerator = new MinMaxDistribution(resultGenerator, minValue, maxValue);
                return resultGenerator;
        }
        
        public void addIdGeneratorNameMapping(String id, String generatorName){
                idMap.put(id, generatorName);
        }
        
        public boolean containsElement(String id){
                return idMap.containsKey(id);
        }
        
        public String getGeneratorName(String id){
                return idMap.get(id);
        }
        
        public List<AbstractSpecificGenerator> getGenList(String arg){
                return rndGenerators.get(arg);
        }
        
        /**
         * Sets a new value of the base seed for this class. If a <code>null</code> value
         * is given, then the base seed is disabled.
         * @param baseSeed the new value of the base seed, or <code>null</code> if the base seed is to be disabled
         */
        public static void setBaseSeed(Long baseSeed) {
                RandomNumbers.baseSeed = baseSeed;
        }
        
        public static boolean isBaseSeedSet() {
                return (baseSeed != null);
        }
        
        public static long getBaseSeed() {
                return baseSeed;
        }
        
        public static void clearBaseSeed() {
                baseSeed = null;
        }
}