openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/statistics/ofpspecific/EventsTimeCounter.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.openflowplugin.impl.statistics.ofpspecific;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.concurrent.TimeUnit;
  16 import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.EventIdentifier;
  17
  18 /**
  19  * Created by Martin Bobak &lt;mbobak@cisco.com&gt; on 28.5.2015.
  20  */
  21 public final class EventsTimeCounter {
  22
  23     private static Map<String, Map<String, EventTimeCounter>> devicesEvents = new HashMap<>();
  24
  25     public static void markStart(final EventIdentifier eventIdentifier) {
  26         Map<String, EventTimeCounter> deviceEvents = getOrCreateCountersForDevice(eventIdentifier.getDeviceId());
  27         EventTimeCounter eventTimeCounter = getOrCreateEventOfType(eventIdentifier.getEventName(), deviceEvents);
  28         eventTimeCounter.markStart();
  29     }
  30
  31     public static void markEnd(final EventIdentifier eventIdentifier) {
  32         Map<String, EventTimeCounter> deviceEvents = getOrCreateCountersForDevice(eventIdentifier.getDeviceId());
  33         EventTimeCounter eventTimeCounter = getOrCreateEventOfType(eventIdentifier.getEventName(), deviceEvents);
  34         eventTimeCounter.markEnd();
  35     }
  36
  37     private static EventTimeCounter getOrCreateEventOfType(final String event, final Map<String, EventTimeCounter> deviceEvents) {
  38         EventTimeCounter lookup = deviceEvents.get(event);
  39         if (null == lookup) {
  40             lookup = new EventTimeCounter();
  41             deviceEvents.put(event, lookup);
  42         }
  43         return lookup;
  44     }
  45
  46     private static Map<String, EventTimeCounter> getOrCreateCountersForDevice(final String deviceId) {
  47         Map<String, EventTimeCounter> lookup = devicesEvents.get(deviceId);
  48         if (null == lookup) {
  49             lookup = new HashMap<String, EventTimeCounter>();
  50             devicesEvents.put(deviceId, lookup);
  51         }
  52
  53         return lookup;
  54     }
  55
  56     public static List<String> provideTimes() {
  57         List<String> dump = new ArrayList<>();
  58         for (Map.Entry<String, Map<String, EventTimeCounter>> deviceEntry : devicesEvents.entrySet()) {
  59             Map<String, EventTimeCounter> eventsMap = deviceEntry.getValue();
  60             dump.add("================================================");
  61             dump.add(String.format("DEVICE : %s", deviceEntry.getKey()));
  62             for (Map.Entry<String, EventTimeCounter> eventEntry : eventsMap.entrySet()) {
  63                 final String eventName = eventEntry.getKey();
  64                 final EventTimeCounter eventTimeCounter = eventEntry.getValue();
  65                 dump.add(String.format("%s", eventName));
  66                 dump.add(String.format("    MIN TIME (ms):  %d",
  67                         TimeUnit.MILLISECONDS.convert(eventTimeCounter.getMinimum(), TimeUnit.NANOSECONDS)));
  68                 dump.add(String.format("    MAX TIME (ms):  %d",
  69                         TimeUnit.MILLISECONDS.convert(eventTimeCounter.getMaximum(), TimeUnit.NANOSECONDS)));
  70                 dump.add(String.format("    AVG TIME (ms):  %d",
  71                         TimeUnit.MILLISECONDS.convert(eventTimeCounter.getAverage(), TimeUnit.NANOSECONDS)));
  72
  73             }
  74         }
  75         return dump;
  76     }
  77
  78     public static void resetAllCounters() {
  79         devicesEvents = new HashMap<>();
  80     }
  81
  82
  83     private static final class EventTimeCounter {
  84
  85         private volatile long delta = 0;
  86         private volatile long average = 0;
  87         private volatile long minimum = 0;
  88         private volatile long maximum = 0;
  89         private volatile long summary = 0;
  90         private volatile int counter = 0;
  91
  92         public synchronized void markStart() {
  93             delta = System.nanoTime();
  94         }
  95
  96         public synchronized void markEnd() {
  97             if (0 == delta) {
  98                 return;
  99             }
 100             counter++;
 101             delta = System.nanoTime() - delta;
 102
 103             if (delta < minimum || minimum == 0) {
 104                 minimum = delta;
 105             }
 106             if (delta > maximum) {
 107                 maximum = delta;
 108             }
 109             if (average > 0 && delta > (average * 1.8)) {
 110                 summary += average;
 111             } else {
 112                 summary += delta;
 113             }
 114             average = summary / counter;
 115         }
 116
 117         public synchronized void resetCounters() {
 118             delta = 0;
 119             average = 0;
 120             minimum = 0;
 121             maximum = 0;
 122             summary = 0;
 123             counter = 0;
 124
 125         }
 126
 127         public synchronized long getAverage() {
 128             return average;
 129         }
 130
 131         public synchronized long getMinimum() {
 132             return minimum;
 133         }
 134
 135         public synchronized long getMaximum() {
 136             return maximum;
 137         }
 138
 139     }
 140
 141
 142 }