Ticket #31: Results.java

package planet.simulate;

import java.util.*;

import planet.commonapi.Id;

/**
 * @author Ruben Mondejar
 * @author Marc Sánchez <msa.ei@estudiants.urv.es>
 *  Node stress
 *  Link stress
 *  Average messages/queues (IN/OUT)
 *  Average total messages / time unit (t)
 *  Average hops/message (specific)
 *  Total number of messages
 */
public class Results {
    
    private static Hashtable results = new Hashtable();
    private static Hashtable lookups = new Hashtable();
    private static Hashtable inserts = new Hashtable();
        private static Hashtable hops = new Hashtable();
    private static int ringSize = 0;
    private static int stabRate = 0;
    private static int traffic = 0;     
 
      
    public static void incStabRate() {
      stabRate++;
    }
    
        public static void clearStabRate() {
          stabRate=0;
        }
        
        public static int getStabRate() {
                return stabRate;
        }
    
        public static void incTraffic() {
      traffic++;
        }
    
        public static void decTraffic() {
          traffic--;
        }
        
        public static void incTrafficBy(int inc) {
                traffic = traffic + inc;
        }
        
        public static int getTraffic() {
          return traffic;
        }    
        
        
        
    //type --> in/out    
    public static void numMessagesTime(Id id, int step, int num, String type) {
      updateNodeStress(id,num,type);
          addMaxMessages(id,step,num,type);     
    }
    
        private static void updateNodeStress(Id id, int num, String type){
      
          Hashtable node_info;
          Integer stress;
      
          if (results.containsKey(id)) {
                node_info = (Hashtable) results.get(id);      
                if (node_info.containsKey("Stress "+type)) {
                  stress = (Integer) node_info.get("Stress "+type);
                  int value = stress.intValue();
                  value+=num;                    
                  node_info.put("Stress "+type,new Integer(value));
                  results.put(id,node_info);                                      
                }
                else {                                   
                  node_info.put("Stress "+type,new Integer(num));                 
                  results.put(id,node_info);            
                }                                               
          }
          else {                
                node_info = new Hashtable();     
                node_info.put("Stress "+type,new Integer(num));
                results.put(id,node_info);              
          }       
        }
                        
        private static void addMaxMessages(Id id, int step, int num ,String type){
      
          Hashtable node_info;
          Vector max;
      
          if (results.containsKey(id)) {
                node_info = (Hashtable) results.get(id);      
                if (node_info.containsKey("Num max "+type)) {
                  max = (Vector) node_info.get("Num max "+type);
                  int value = ((Integer) max.get(1)).intValue();
                  if (num>value) {               
                    max.clear();
                        max.add(new Integer(step));
                        max.add(new Integer(num));       
                        node_info.put("Num max "+type,max);
                        results.put(id,node_info);
                  }                       
                }
                else {
                  max = new Vector();
                  max.add(new Integer(step));
                  max.add(new Integer(num));     
                  node_info.put("Num max "+type,max);
                  results.put(id,node_info);            
                }                                               
          }
          else {                
                max = new Vector();
                max.add(new Integer(step));
                max.add(new Integer(num));
                
                node_info = new Hashtable();     
                node_info.put("Num max "+type,max);
                results.put(id,node_info);              
          }       
        }
        
        public static void updateHopsMsg(Id source, String key_msg){      
          
      String identif = source+" "+key_msg;
      
          if (hops.containsKey(identif)) {
            int num = ((Integer) hops.get(identif)).intValue() + 1;
                hops.put(identif,new Integer(num));                                                       
          }
          else {                                         
            hops.put(identif,new Integer(1));
          }                       
        }
        
        public static void addInsert(String key,String dest) {
                inserts.put(key,dest);
        }
        
        public static String getInsert(String key) {
                return (String) inserts.get(key);
        }

        public static void resetInserts() {
                inserts.clear();
        }
        
        public static Hashtable getAllInserts() {
                return (Hashtable) inserts.clone();
        }
        
        public static void addLookup(Id key, Id own) {
          lookups.put(key,own);
    }
        
        public static Id getLookup(Id key) {      
          return ((Id) lookups.get(key));
    }
    
    public static void resetLookups(){
      lookups.clear();
    }
    
    public static Hashtable getAllLookups() {
      return (Hashtable) lookups.clone();
    }
    
        public static void print () {
          long total_in_msg = 0;
          long total_out_msg = 0;
         
          Logger.log("************************",Logger.PRINT_LOG);
          Logger.log(" **   Node Results    **",Logger.PRINT_LOG);
          Logger.log("************************",Logger.PRINT_LOG);
      Collection c = results.keySet();
      ringSize = c.size();
      Iterator it = c.iterator();
      while (it.hasNext()) {
        Id id = (Id) it.next();
        Logger.log(" *** Results of node "+id,Logger.PRINT_LOG);
                Hashtable node_info = (Hashtable) results.get(id);
                int link_stress = ((Integer) node_info.get("Stress in")).intValue();
                Logger.log(" * Link stress :"+link_stress,Logger.PRINT_LOG);            
                
                int node_stress = link_stress + ((Integer) node_info.get("Stress out")).intValue();             
                Logger.log(" * Node stress :"+node_stress,Logger.PRINT_LOG);            
                
                Vector max_in = (Vector) node_info.get("Num max in");
                Logger.log(" * Max number in messages :"+max_in.get(1)+" at step "+max_in.get(0),Logger.PRINT_LOG);                 
                
                Vector max_out = (Vector) node_info.get("Num max out");
                Logger.log(" * Max number out messages :"+max_out.get(1)+" at step "+max_out.get(0),Logger.PRINT_LOG);          
                            
                total_in_msg+=link_stress;
                total_out_msg+=node_stress-link_stress;
      }
      
      long total_n_msg = total_in_msg + total_out_msg;
      int steps = Logger.getStep();     
          Logger.log("***********************",Logger.PRINT_LOG);
          Logger.log(" ** Globals Results  **",Logger.PRINT_LOG);
          Logger.log("***********************",Logger.PRINT_LOG);
          Logger.log(" * Ring size "+ringSize,Logger.PRINT_LOG);
          Logger.log(" * Total number of message     "+total_n_msg,Logger.PRINT_LOG);
          if (ringSize>0) {       
                Logger.log(" * Average messages/in queues  "+total_in_msg/ringSize,Logger.PRINT_LOG); 
            Logger.log(" * Average messages/out queues "+total_out_msg/ringSize,Logger.PRINT_LOG);      
            Logger.log(" * Average messages/nodes      "+total_n_msg/ringSize,Logger.PRINT_LOG);
          }
          if (steps>0) Logger.log(" * Average messages/steps      "+total_n_msg/steps,Logger.PRINT_LOG);
          Logger.log(" * Stabilize Global Rate "+stabRate,Logger.PRINT_LOG);
    }
        
        private static int lookup_number = 0;
        /**
         * print total and average hops
         */
        public static void printhops() {
                Collection keys = hops.keySet();
                Iterator  it = keys.iterator();
                long total_hops = 0;
                int lookup_number_temp = 0;
                while (it.hasNext()) {
                        lookup_number_temp++;
                        String id_and_source =(String)it.next();
                        total_hops += ((Integer)(hops.get(id_and_source))).longValue();
                        // System.out.println(id_and_source + " " +
                        // hops.get(id_and_source));

                }
                
                lookup_number = lookup_number_temp;
                Logger.log("************************", Logger.PRINT_LOG);
                Logger.log("*****Hops Results*******", Logger.PRINT_LOG);
                Logger.log("************************", Logger.PRINT_LOG);
                if (lookup_number_temp == 0) {
                        Logger.log("There are no lookup operation", Logger.PRINT_LOG);
                } else {
                        Logger.log("The total hops in the test is : [" + total_hops
                                        + "] in [" + lookup_number_temp + "] lookup operations",
                                        Logger.PRINT_LOG);
                        Logger.log("The average hops in the test is : "
                                        + (double) ((double) total_hops / (double) lookup_number_temp),
                                        Logger.PRINT_LOG);
                }
                

        }

        public static int getLookup_number() {
                return lookup_number;
        }

}