| package com.tinkerpop.blueprints.impls.ramcloud; |
| |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Map; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| import sun.reflect.Reflection; |
| |
| |
| public final class PerfMon { |
| private static final PerfMon instance = new PerfMon(); |
| public final long measureAllTimeProp = Long.valueOf(System.getProperty("benchmark.measureAll", "0")); |
| private final static Logger log = LoggerFactory.getLogger(PerfMon.class); |
| |
| private static final int debug = 0; |
| |
| private static long read_latency_sum; |
| private static long read_latency_cnt; |
| private static int read_flag; |
| |
| private static long write_latency_sum; |
| private static long write_latency_cnt; |
| private static int write_flag; |
| |
| private static long serialize_latency_sum; |
| private static long serialize_latency_cnt; |
| private static HashMap<String, Long> ser_flag = new HashMap<String, Long>(); |
| //private static int ser_flag; |
| |
| private static long deserialize_latency_sum; |
| private static long deserialize_latency_cnt; |
| private static int deser_flag; |
| |
| private static long addsw_time; |
| private static long addport_time; |
| private static long addlink_time; |
| private static long addport_cnt; |
| private static HashMap<String, Long> ser_time = new HashMap<String, Long>(); |
| private static HashMap<String, Long> deser_time = new HashMap<String, Long>(); |
| private static HashMap<String, Long> write_time = new HashMap<String, Long>(); |
| private static HashMap<String, Long> read_time = new HashMap<String, Long>(); |
| |
| public static PerfMon getInstance() { |
| return instance; |
| } |
| private PerfMon(){ |
| } |
| |
| private void clear(){ |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| read_latency_sum=0L; |
| read_latency_cnt=0L; |
| write_latency_sum=0L; |
| write_latency_cnt=0L; |
| serialize_latency_sum=0L; |
| serialize_latency_cnt=0L; |
| deserialize_latency_sum=0L; |
| deserialize_latency_cnt=0L; |
| read_flag=write_flag=deser_flag=0; |
| for (Iterator<Map.Entry<String, Long>> it = ser_flag.entrySet().iterator(); it.hasNext(); ) { |
| Map.Entry<String, Long> entry = it.next(); |
| entry.setValue(0L); |
| } |
| //log.error("flag cleared"); |
| } |
| public void addswitch_start(){ |
| if(measureAllTimeProp==0) |
| return; |
| |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| clear(); |
| addsw_time = System.nanoTime(); |
| } |
| public void addswitch_end(){ |
| if(measureAllTimeProp==0) |
| return; |
| |
| long delta; |
| long sum; |
| |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| delta = System.nanoTime() - addsw_time; |
| sum = read_latency_sum + write_latency_sum + serialize_latency_sum + deserialize_latency_sum; |
| log.error("Performance add_switch {} read {} ({}) write {} ({}) serialize {} ({}) deserialize {} ({}) rwsd total {} other {} ({})", |
| delta, read_latency_sum, read_latency_cnt, write_latency_sum, write_latency_cnt, serialize_latency_sum, serialize_latency_cnt, deserialize_latency_sum, deserialize_latency_cnt, sum, delta-sum, ((float)(delta-sum))*100.0/((float) delta)); |
| } |
| public void addport_start(){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| clear(); |
| addport_cnt = 0; |
| addport_time = System.nanoTime(); |
| } |
| public void addport_incr(){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| clear(); |
| addport_cnt ++; |
| } |
| public void addport_end(){ |
| if(measureAllTimeProp==0) |
| return; |
| long delta; |
| long sum; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| delta = System.nanoTime() - addport_time; |
| sum = read_latency_sum + write_latency_sum + serialize_latency_sum + deserialize_latency_sum; |
| log.error("Performance add_port {} ( {} ports ) read {} ({}) write {} ({}) serialize {} ({}) deserialize {} ({}) rwsd total {} other {} ({})", |
| delta, addport_cnt, read_latency_sum, read_latency_cnt, write_latency_sum, write_latency_cnt, serialize_latency_sum, serialize_latency_cnt, deserialize_latency_sum, deserialize_latency_cnt, sum, delta-sum, ((float)(delta-sum))*100.0/((float) delta)); |
| } |
| public void addlink_start(){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| clear(); |
| addlink_time = System.nanoTime(); |
| } |
| public void addlink_end(){ |
| if(measureAllTimeProp==0) |
| return; |
| long delta; |
| long sum; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| delta = System.nanoTime() - addlink_time; |
| sum = read_latency_sum + write_latency_sum + serialize_latency_sum + deserialize_latency_sum; |
| log.error("Performance add_link {} read {} ({}) write {} ({}) serialize {} ({}) deserialize {} ({}) rwsd total {} other {} ({})", |
| delta, read_latency_sum, read_latency_cnt, write_latency_sum, write_latency_cnt, serialize_latency_sum, serialize_latency_cnt, deserialize_latency_sum, deserialize_latency_cnt, sum, delta-sum, ((float)(delta-sum))*100.0/((float) delta)); |
| } |
| |
| public void read_start(String key){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| if ( debug==1 ) |
| log.error("read start {}", key); |
| read_time.put(key, System.nanoTime()); |
| //read_time = System.nanoTime(); |
| if ( read_flag != 0){ |
| log.error("read is already started"); |
| } |
| read_flag = 1; |
| } |
| public void read_end(String key){ |
| if(measureAllTimeProp==0) |
| return; |
| long delta; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| //read_latency_sum += System.nanoTime() - read_time; |
| if ( debug==1 ) |
| log.error("read end {}", key); |
| delta = System.nanoTime() - read_time.get(key); |
| read_latency_sum += delta; |
| read_latency_cnt ++; |
| if ( read_flag != 1){ |
| log.error("read is not started"); |
| } |
| read_flag = 0; |
| } |
| public void write_start(String key){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| if ( debug==1 ) |
| log.error("write start {}", key); |
| write_time.put(key, System.nanoTime()); |
| //write_time = System.nanoTime(); |
| if ( write_flag != 0){ |
| log.error("write is already started"); |
| } |
| write_flag = 1; |
| } |
| public void write_end(String key){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| if ( debug==1 ) |
| log.error("write end {}", key); |
| write_latency_sum += (System.nanoTime() - write_time.get(key)); |
| //write_latency_sum += System.nanoTime() - write_time; |
| write_latency_cnt ++; |
| if ( write_flag != 1){ |
| log.error("write is not started"); |
| } |
| write_flag = 0; |
| } |
| public void ser_add(long time){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| serialize_latency_sum += time; |
| serialize_latency_cnt ++; |
| } |
| public void ser_start(String key){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| //ser_time = System.nanoTime(); |
| if ( debug==1 ) |
| log.error("ser start {}", key); |
| ser_time.put(key, System.nanoTime()); |
| // log.error("ser {} start at {} flag {}", key, ser_time, ser_flag); |
| if ( ser_flag.containsKey(key) ){ |
| if ( ser_flag.get(key) != 0L){ |
| log.error("ser {} sarted but has been already started", key); |
| } |
| } |
| ser_flag.put(key, 1L); |
| } |
| public void ser_end(String key){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| if ( debug==1 ) |
| log.error("ser end {}", key); |
| //serialize_latency_sum += System.nanoTime() - ser_time; |
| serialize_latency_sum += (System.nanoTime() - ser_time.get(key)); |
| serialize_latency_cnt ++; |
| // log.error("ser {} end at {} flag {}", key, ser_time, ser_flag); |
| if ( ser_flag.containsKey(key) ){ |
| if ( ser_flag.get(key) != 1L){ |
| log.error("ser {} ended but hasn't started", key); |
| } |
| } |
| ser_flag.put(key, 0L); |
| } |
| public void deser_start(String key){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| if ( debug==1 ) |
| log.error("deser start {}", key); |
| deser_time.put(key, System.nanoTime()); |
| //deser_time = System.nanoTime(); |
| if ( deser_flag != 0){ |
| log.error("deser is already started"); |
| } |
| deser_flag = 1; |
| } |
| public void deser_end(String key){ |
| if(measureAllTimeProp==0) |
| return; |
| if(! Thread.currentThread().getName().equals("main")){ |
| return; |
| } |
| if ( debug==1 ) |
| log.error("deser end {}", key); |
| //deserialize_latency_sum += System.nanoTime() - deser_time; |
| deserialize_latency_sum += System.nanoTime() - deser_time.get(key); |
| deserialize_latency_cnt ++; |
| if ( deser_flag != 1){ |
| log.error("deser is not started"); |
| } |
| deser_flag = 0; |
| } |
| } |