First check-in for debug counters

src/main/java/net/floodlightcontroller/core/FloodlightProvider.java

@@ -27,6 +27,7 @@ import net.floodlightcontroller.core.module.FloodlightModuleException;
 import net.floodlightcontroller.core.module.IFloodlightModule;
 import net.floodlightcontroller.core.module.IFloodlightService;
 import net.floodlightcontroller.counter.ICounterStoreService;
+import net.floodlightcontroller.debugcounter.IDebugCounterService;
 import net.floodlightcontroller.flowcache.IFlowCacheService;
 import net.floodlightcontroller.perfmon.IPktInProcessingTimeService;
 import net.floodlightcontroller.restserver.IRestApiService;
@@ -35,7 +36,7 @@ import net.floodlightcontroller.threadpool.IThreadPoolService;
 
 public class FloodlightProvider implements IFloodlightModule {
     Controller controller;
-    
+
     @Override
     public Collection<Class<? extends IFloodlightService>> getModuleServices() {
         Collection<Class<? extends IFloodlightService>> services =
@@ -48,9 +49,9 @@ public class FloodlightProvider implements IFloodlightModule {
     public Map<Class<? extends IFloodlightService>,
                IFloodlightService> getServiceImpls() {
         controller = new Controller();
-        
+
         Map<Class<? extends IFloodlightService>,
-            IFloodlightService> m = 
+            IFloodlightService> m =
                 new HashMap<Class<? extends IFloodlightService>,
                             IFloodlightService>();
         m.put(IFloodlightProviderService.class, controller);
@@ -78,6 +79,8 @@ public class FloodlightProvider implements IFloodlightModule {
            context.getServiceImpl(IPktInProcessingTimeService.class));
        controller.setCounterStore(
            context.getServiceImpl(ICounterStoreService.class));
+       controller.setDebugCounter(
+           context.getServiceImpl(IDebugCounterService.class));
        controller.setFlowCacheMgr(
            context.getServiceImpl(IFlowCacheService.class));
        controller.setRestApiService(

src/main/java/net/floodlightcontroller/core/internal/Controller.java

@@ -66,6 +66,7 @@ import net.floodlightcontroller.core.util.ListenerDispatcher;
 import net.floodlightcontroller.core.util.SingletonTask;
 import net.floodlightcontroller.core.web.CoreWebRoutable;
 import net.floodlightcontroller.counter.ICounterStoreService;
+import net.floodlightcontroller.debugcounter.IDebugCounterService;
 import net.floodlightcontroller.flowcache.IFlowCacheService;
 import net.floodlightcontroller.packet.Ethernet;
 import net.floodlightcontroller.perfmon.IPktInProcessingTimeService;
@@ -172,6 +173,7 @@ public class Controller implements IFloodlightProviderService,
     // Module dependencies
     protected IRestApiService restApi;
     protected ICounterStoreService counterStore = null;
+    protected IDebugCounterService debugCounter;
     protected IFlowCacheService bigFlowCacheMgr;
     protected IStorageSourceService storageSource;
     protected IPktInProcessingTimeService pktinProcTime;
@@ -191,7 +193,7 @@ public class Controller implements IFloodlightProviderService,
     // we have sent to the listeners. On a transition to slave we first set
     // this role and then notify, on a transition to master we first notify
     // and then set the role. We then use it to make sure we don't forward
-    // OF messages while the modules are in slave role. 
+    // OF messages while the modules are in slave role.
     // The pendingRole is a role change just received, but not sent out
     // notifications yet.
     protected Role pendingRole;
@@ -302,7 +304,7 @@ public class Controller implements IFloodlightProviderService,
                           newRole, oldRole);
             }
             // Set notified role to slave before notifying listeners. This
-            // stops OF messages from being sent to listeners 
+            // stops OF messages from being sent to listeners
             if (newRole == Role.SLAVE)
                 Controller.this.notifiedRole = newRole;
             if (haListeners != null) {
@@ -310,7 +312,7 @@ public class Controller implements IFloodlightProviderService,
                         listener.roleChanged(oldRole, newRole);
                 }
             }
-            // Set notified role to master/equal after notifying listeners. 
+            // Set notified role to master/equal after notifying listeners.
             // We now forward messages again
             if (newRole != Role.SLAVE)
                 Controller.this.notifiedRole = newRole;
@@ -363,6 +365,10 @@ public class Controller implements IFloodlightProviderService,
         this.counterStore = counterStore;
     }
 
+    public void setDebugCounter(IDebugCounterService debugCounter) {
+        this.debugCounter = debugCounter;
+    }
+
     public void setFlowCacheMgr(IFlowCacheService flowCacheMgr) {
         this.bigFlowCacheMgr = flowCacheMgr;
     }
@@ -669,6 +675,7 @@ public class Controller implements IFloodlightProviderService,
                 // Flush all flow-mods/packet-out/stats generated from this "train"
                 OFSwitchBase.flush_all();
                 counterStore.updateFlush();
+                debugCounter.flushCounters();
                 bigFlowCacheMgr.updateFlush();
             }
         }
@@ -1061,7 +1068,7 @@ public class Controller implements IFloodlightProviderService,
 
                         if (sw.isConnected()) {
                             // Only dispatch message if the switch is in the
-                            // activeSwitch map and if the switches role is 
+                            // activeSwitch map and if the switches role is
                             // not slave and the modules are not in slave
                             // TODO: Should we dispatch messages that we expect to
                             // receive when we're in the slave role, e.g. port
@@ -1071,7 +1078,7 @@ public class Controller implements IFloodlightProviderService,
                             // to them. On the other hand there might be special
                             // modules that care about all of the connected switches
                             // and would like to receive port status notifications.
-                            if (sw.getHARole() == Role.SLAVE || 
+                            if (sw.getHARole() == Role.SLAVE ||
                                     notifiedRole == Role.SLAVE ||
                                     !activeSwitches.containsKey(sw.getId())) {
                                 // Don't log message if it's a port status message
@@ -1182,7 +1189,7 @@ public class Controller implements IFloodlightProviderService,
                                  FloodlightContext bContext)
             throws IOException {
         Ethernet eth = null;
-        
+
         switch (m.getType()) {
             case PACKET_IN:
                 OFPacketIn pi = (OFPacketIn)m;
@@ -1248,9 +1255,9 @@ public class Controller implements IFloodlightProviderService,
                     }
                     pktinProcTime.recordEndTimePktIn(sw, m, bc);
                 } else {
-                    if (m.getType() != OFType.BARRIER_REPLY) 
+                    if (m.getType() != OFType.BARRIER_REPLY)
                         log.warn("Unhandled OF Message: {} from {}", m, sw);
-                    else 
+                    else
                         log.debug("Received a Barrier Reply, no listeners for it");
                 }
 
@@ -1758,7 +1765,7 @@ public class Controller implements IFloodlightProviderService,
             this.workerThreads = Integer.parseInt(threads);
         }
         log.debug("Number of worker threads set to {}", this.workerThreads);
-        
+
     }
 
     private void initVendorMessages() {

src/main/java/net/floodlightcontroller/counter/CounterStore.java

@@ -15,9 +15,6 @@
  *    under the License.
  **/
 
-/**
- * Implements a very simple central store for system counters
- */
 package net.floodlightcontroller.counter;
 
 import java.util.ArrayList;
@@ -41,6 +38,17 @@ import org.openflow.protocol.OFPacketIn;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+/**
+ * Implements a central store for system counters. These counters include
+ * overall packet-in, packet-out, and flow-mod counters. Additional packet-in
+ * counters are maintained for bcast/unicast/multicast traffic, as well as counters
+ * for traffic types based on ethertype and ip-proto (maintained on a per switch
+ * and controller level). These counters are maintained without the involvement of
+ * any other module in the system. For per-module counters and other detailed
+ * debug services, consider IDebugCounterService.
+ *
+ *  @authors Kyle, Kanzhe, Mandeep and Saurav
+ */
 public class CounterStore implements IFloodlightModule, ICounterStoreService {
     protected static Logger log = LoggerFactory.getLogger(CounterStore.class);
 
@@ -134,8 +142,6 @@ public class CounterStore implements IFloodlightModule, ICounterStoreService {
     protected ConcurrentHashMap<String, CounterEntry> nameToCEIndex =
             new ConcurrentHashMap<String, CounterEntry>();
 
-
-
     /**
      * Counter Categories grouped by network layers
      * NetworkLayer -> CounterToCategories
@@ -284,23 +290,6 @@ public class CounterStore implements IFloodlightModule, ICounterStoreService {
     //   Internal Methods
     //*******************************
 
-    protected void printAllKeys() {
-
-        for (Map.Entry<String, CounterEntry> counterEntry : this.nameToCEIndex.entrySet()) {
-            log.info("concurrenthashmapkeys: {}", counterEntry.getKey());
-        }
-
-        for (CounterKeyTuple ctr : pktinCounters.keySet()) {
-            log.info("pktinglobalkeys: {}", ctr);
-        }
-
-        Map<CounterKeyTuple, MutableInt> pktin_buffer = this.pktin_local_buffer.get();
-        for (CounterKeyTuple key : pktin_buffer.keySet()) {
-            log.info("localbufferkeys: {}", key);
-        }
-        log.info("done");
-    }
-
     protected CounterKeyTuple getCountersKey(IOFSwitch sw, OFMessage m, Ethernet eth) {
         byte mtype = m.getType().getTypeValue();
         short l3type = 0;

src/main/java/net/floodlightcontroller/debugcounter/DebugCounter.java

+package net.floodlightcontroller.debugcounter;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import net.floodlightcontroller.core.module.FloodlightModuleContext;
+import net.floodlightcontroller.core.module.FloodlightModuleException;
+import net.floodlightcontroller.core.module.IFloodlightModule;
+import net.floodlightcontroller.core.module.IFloodlightService;
+
+/**
+ * This class implements a central store for all counters used for debugging the
+ * system. For counters based on traffic-type, see ICounterStoreService.
+ *
+ * @author Saurav
+ */
+public class DebugCounter implements IFloodlightModule, IDebugCounterService {
+    protected static Logger log = LoggerFactory.getLogger(DebugCounter.class);
+
+    /**
+     * The counter value
+     */
+    protected class MutableLong {
+        long value = 0;
+        public void increment() { value += 1; }
+        public long get() { return value; }
+        public void set(long val) { value = val; }
+      }
+
+    /**
+     * Global debug-counter storage across all threads. These are
+     * updated from the local per thread counters by the update FIXME method.
+     */
+    protected ConcurrentHashMap<String, AtomicLong> debugCounters =
+            new ConcurrentHashMap<String, AtomicLong>();
+
+    /**
+     * Thread local debug counters used for maintaining counters local to a thread.
+     */
+    protected final ThreadLocal<Map<String, MutableLong>> threadlocalCounters =
+            new ThreadLocal<Map<String, MutableLong>>() {
+        @Override
+        protected Map<String, MutableLong> initialValue() {
+            return new HashMap<String, MutableLong>();
+        }
+    };
+
+    /**
+     * protected class to store counter information
+     */
+    protected class CounterInfo {
+        String moduleCounterName;
+        String counterDesc;
+        CounterType ctype;
+        String moduleName;
+        String counterName;
+
+        public CounterInfo(String name, String desc, CounterType ctype) {
+            this.moduleCounterName = name;
+            String[] temp = name.split("-");
+            this.moduleName = temp[0];
+            this.counterName = temp[1];
+            this.counterDesc = desc;
+            this.ctype = ctype;
+        }
+    }
+
+    /**
+     * per module counters, indexed by the module name and storing Counter information.
+     */
+    protected ConcurrentHashMap<String, List<CounterInfo>> moduleCounters =
+            new ConcurrentHashMap<String, List<CounterInfo>>();
+
+    /**
+     * fast cache for counter names that are currently active
+     */
+    Set<String> currentCounters = Collections.newSetFromMap(
+                                      new ConcurrentHashMap<String,Boolean>());
+
+   //*******************************
+   //   IDebugCounterService
+   //*******************************
+
+   @Override
+   public boolean registerCounter(String moduleCounterName, String counterDescription,
+                               CounterType counterType) {
+       if (debugCounters.containsKey(moduleCounterName)) {
+           log.error("Cannot register counter: {}. Counter already exists",
+                     moduleCounterName);
+           return false;
+       }
+       String[] temp = moduleCounterName.split("-");
+       if (temp.length < 2) {
+           log.error("Cannot register counter: {}. Name not of type " +
+                     " <module name>-<counter name>", moduleCounterName);
+           return false;
+       }
+
+       // store counter information on a per module basis
+       String moduleName = temp[0];
+       List<CounterInfo> a;
+       if (moduleCounters.containsKey(moduleName)) {
+           a = moduleCounters.get(moduleName);
+       } else {
+           a = new ArrayList<CounterInfo>();
+           moduleCounters.put(moduleName, a);
+       }
+       a.add(new CounterInfo(moduleCounterName, counterDescription, counterType));
+
+       // create counter in global map
+       debugCounters.put(moduleCounterName, new AtomicLong());
+
+       // create counter in local thread map
+       Map<String, MutableLong> thismap =  this.threadlocalCounters.get();
+       MutableLong ml = thismap.get(moduleCounterName);
+       if (ml == null) {
+           thismap.put(moduleCounterName, new MutableLong());
+       }
+
+       // finally add to cache if it is meant to be always counted
+       if (counterType == CounterType.ALWAYS_COUNT) {
+           currentCounters.add(moduleCounterName);
+       }
+       return true;
+   }
+
+   @Override
+   public void updateCounter(String moduleCounterName) {
+       if (currentCounters.contains(moduleCounterName)) {
+           Map<String, MutableLong> thismap =  this.threadlocalCounters.get();
+           MutableLong ml = thismap.get(moduleCounterName);
+           if (ml == null) {
+               ml = new MutableLong();
+               thismap.put(moduleCounterName, ml);
+           }
+           ml.increment();
+       }
+   }
+
+   @Override
+   public void flushCounters() {
+       Map<String, MutableLong> thismap =  this.threadlocalCounters.get();
+       for (String key : thismap.keySet()) {
+           MutableLong curval = thismap.get(key);
+           long delta = curval.get();
+           if (delta > 0) {
+               debugCounters.get(key).addAndGet(delta);
+               curval.set(0);
+           }
+       }
+       printAllCounters();
+   }
+
+   @Override
+   public void resetCounter(String moduleCounterName) {
+       // TODO Auto-generated method stub
+
+   }
+
+   @Override
+   public void resetAllCounters() {
+       // TODO Auto-generated method stub
+
+   }
+
+   @Override
+   public void resetAllModuleCounters(String moduleName) {
+       // TODO Auto-generated method stub
+
+   }
+
+   @Override
+   public void enableCtrOnDemand(String moduleCounterName) {
+       // TODO Auto-generated method stub
+
+   }
+
+   @Override
+   public void disableCtrOnDemand(String moduleCounterName) {
+       // TODO Auto-generated method stub
+
+   }
+
+   @Override
+   public DebugCounterInfo getCounterValue(String moduleCounterName) {
+       // TODO Auto-generated method stub
+       return null;
+   }
+
+   @Override
+   public List<DebugCounterInfo> getAllCounterValues() {
+       // TODO Auto-generated method stub
+       return null;
+   }
+
+   @Override
+   public List<DebugCounterInfo> getModuleCounterValues() {
+       // TODO Auto-generated method stub
+       return null;
+   }
+
+
+   //*******************************
+   //   Internal Methods
+   //*******************************
+
+   private void printAllCounters() {
+       for (List<CounterInfo> cilist : moduleCounters.values()) {
+           for (CounterInfo ci : cilist) {
+               log.info("Countername {} Countervalue {}", new Object[] {
+                    ci.moduleCounterName, debugCounters.get(ci.moduleCounterName)
+               });
+           }
+       }
+   }
+
+
+    //*******************************
+    //   IFloodlightModule
+    //*******************************
+
+    @Override
+    public Collection<Class<? extends IFloodlightService>> getModuleServices() {
+        Collection<Class<? extends IFloodlightService>> l =
+                new ArrayList<Class<? extends IFloodlightService>>();
+        l.add(IDebugCounterService.class);
+        return l;
+    }
+
+    @Override
+    public Map<Class<? extends IFloodlightService>, IFloodlightService> getServiceImpls() {
+        Map<Class<? extends IFloodlightService>, IFloodlightService> m =
+                new HashMap<Class<? extends IFloodlightService>, IFloodlightService>();
+        m.put(IDebugCounterService.class, this);
+        return m;
+    }
+
+    @Override
+    public Collection<Class<? extends IFloodlightService>> getModuleDependencies() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public void init(FloodlightModuleContext context) throws FloodlightModuleException {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void startUp(FloodlightModuleContext context) {
+        // TODO Auto-generated method stub
+    }
+
+}

src/main/java/net/floodlightcontroller/debugcounter/IDebugCounterService.java

+package net.floodlightcontroller.debugcounter;
+
+import net.floodlightcontroller.core.module.IFloodlightService;
+import net.floodlightcontroller.debugcounter.DebugCounter.CounterInfo;
+import java.util.List;
+
+public interface IDebugCounterService extends IFloodlightService {
+
+    /**
+     * Different counter types.
+     */
+    public enum CounterType {
+        ALWAYS_COUNT,
+        COUNT_ON_DEMAND
+    }
+
+    public class DebugCounterInfo {
+        CounterInfo counterinfo;
+        Long counterValue;
+    }
+
+    /**
+     * All modules that wish to have the DebugCounterService count for them, must
+     * register their counters by making this call (typically from that module's
+     * 'startUp' method). The counter can then be updated, displayed, reset etc.
+     * using the registered moduleCounterName.
+     *
+     * @param moduleCounterName    the counter name which MUST be have the following
+     *                             syntax:  <module name>-<counter name>
+     *                             eg.: linkdiscovery-incoming
+     * @param counterDescription   a descriptive string that gives more information
+     *                             of what the counter is measuring. For example,
+     *                             "Measures the number of incoming packets seen by
+     *                             this module".
+     * @param counterType          One of CounterType. COUNT_ON_DEMAND counter types
+     *                             need to be explicitly enabled/disabled using other
+     *                             methods in this API -- i.e. registering them is
+     *                             not enough to start counting.
+     * @return                     false if the counter has already been registered
+     *                             or if the moduleCounterName is not as expected.
+     */
+    public boolean registerCounter(String moduleCounterName, String counterDescription,
+                                   CounterType counterType);
+
+    /**
+     * Increments the counter by 1.
+     * @param moduleCounterName   the registered counter name.
+     */
+    public void updateCounter(String moduleCounterName);
+
+    /**
+     * Update the global counter map with values from the thread local maps
+     */
+    public void flushCounters();
+
+    /**
+     *
+     * @param moduleCounterName
+     */
+    public void resetCounter(String moduleCounterName);
+
+    public void resetAllCounters();
+
+    public void resetAllModuleCounters(String moduleName);
+
+    public void enableCtrOnDemand(String moduleCounterName);
+
+    public void disableCtrOnDemand(String moduleCounterName);
+
+    public DebugCounterInfo getCounterValue(String moduleCounterName);
+
+    public  List<DebugCounterInfo> getAllCounterValues();
+
+    public  List<DebugCounterInfo> getModuleCounterValues();
+
+}

src/main/java/net/floodlightcontroller/debugcounter/NullDebugCounter.java

+package net.floodlightcontroller.debugcounter;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import net.floodlightcontroller.core.module.FloodlightModuleContext;
+import net.floodlightcontroller.core.module.FloodlightModuleException;
+import net.floodlightcontroller.core.module.IFloodlightModule;
+import net.floodlightcontroller.core.module.IFloodlightService;
+
+public class NullDebugCounter implements IFloodlightModule, IDebugCounterService {
+
+    @Override
+    public boolean registerCounter(String moduleCounterName,
+                                   String counterDescription,
+                                   CounterType counterType) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public Collection<Class<? extends IFloodlightService>>
+            getModuleServices() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Map<Class<? extends IFloodlightService>, IFloodlightService>
+            getServiceImpls() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Collection<Class<? extends IFloodlightService>>
+            getModuleDependencies() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public
+            void
+            init(FloodlightModuleContext context)
+                                                 throws FloodlightModuleException {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void startUp(FloodlightModuleContext context) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void updateCounter(String moduleCounterName) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void flushCounters() {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void resetCounter(String moduleCounterName) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void resetAllCounters() {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void resetAllModuleCounters(String moduleName) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void enableCtrOnDemand(String moduleCounterName) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void disableCtrOnDemand(String moduleCounterName) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public DebugCounterInfo getCounterValue(String moduleCounterName) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public List<DebugCounterInfo> getAllCounterValues() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public List<DebugCounterInfo> getModuleCounterValues() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+}

src/main/java/net/floodlightcontroller/devicemanager/internal/DeviceManagerImpl.java

@@ -49,6 +49,9 @@ import net.floodlightcontroller.core.module.IFloodlightModule;
 import net.floodlightcontroller.core.module.IFloodlightService;
 import net.floodlightcontroller.core.util.ListenerDispatcher;
 import net.floodlightcontroller.core.util.SingletonTask;
+import net.floodlightcontroller.debugcounter.IDebugCounterService;
+import net.floodlightcontroller.debugcounter.NullDebugCounter;
+import net.floodlightcontroller.debugcounter.IDebugCounterService.CounterType;
 import net.floodlightcontroller.devicemanager.IDevice;
 import net.floodlightcontroller.devicemanager.IDeviceService;
 import net.floodlightcontroller.devicemanager.IEntityClass;
@@ -104,6 +107,7 @@ IFlowReconcileListener, IInfoProvider, IHAListener {
     protected IRestApiService restApi;
     protected IThreadPoolService threadPool;
     protected IFlowReconcileService flowReconcileMgr;
+    protected IDebugCounterService debugCounters;
 
     /**
      * Time in milliseconds before entities will expire
@@ -593,6 +597,9 @@ IFlowReconcileListener, IInfoProvider, IHAListener {
                            FloodlightContext cntx) {
         switch (msg.getType()) {
             case PACKET_IN:
+                debugCounters.updateCounter("devicemanager-incoming");
+                logger.info("Received PI: {} on switch {}, port {} ***",
+                        new Object[] { (OFPacketIn)msg, sw.getStringId() });
                 return this.processPacketInMessage(sw,
                                                    (OFPacketIn) msg, cntx);
             default:
@@ -715,6 +722,7 @@ IFlowReconcileListener, IInfoProvider, IHAListener {
         this.threadPool = fmc.getServiceImpl(IThreadPoolService.class);
         this.flowReconcileMgr = fmc.getServiceImpl(IFlowReconcileService.class);
         this.entityClassifier = fmc.getServiceImpl(IEntityClassifierService.class);
+        this.debugCounters = fmc.getServiceImpl(IDebugCounterService.class);
     }
 
     @Override
@@ -752,6 +760,18 @@ IFlowReconcileListener, IInfoProvider, IHAListener {
         } else {
             logger.debug("Could not instantiate REST API");
         }
+
+        registerLinkDiscoveryDebugCounters();
+    }
+
+    private void registerLinkDiscoveryDebugCounters() {
+        if (debugCounters == null) {
+            logger.error("Debug Counter Service not found.");
+            debugCounters = new NullDebugCounter();
+            return;
+        }
+        debugCounters.registerCounter(getName() + "-" + "incoming",
+            "All incoming packets seen by this module", CounterType.ALWAYS_COUNT);
     }
 
     // ***************

src/main/java/net/floodlightcontroller/linkdiscovery/internal/LinkDiscoveryManager.java

@@ -57,6 +57,9 @@ import net.floodlightcontroller.core.module.FloodlightModuleException;
 import net.floodlightcontroller.core.module.IFloodlightModule;
 import net.floodlightcontroller.core.module.IFloodlightService;
 import net.floodlightcontroller.core.util.SingletonTask;
+import net.floodlightcontroller.debugcounter.IDebugCounterService;
+import net.floodlightcontroller.debugcounter.IDebugCounterService.CounterType;
+import net.floodlightcontroller.debugcounter.NullDebugCounter;
 import net.floodlightcontroller.linkdiscovery.ILinkDiscovery;
 import net.floodlightcontroller.linkdiscovery.ILinkDiscovery.LinkType;
 import net.floodlightcontroller.linkdiscovery.ILinkDiscovery.SwitchType;
@@ -142,6 +145,7 @@ public class LinkDiscoveryManager implements IOFMessageListener,
     protected IStorageSourceService storageSource;
     protected IThreadPoolService threadPool;
     protected IRestApiService restApi;
+    protected IDebugCounterService debugCounters;
 
     // LLDP and BDDP fields
     private static final byte[] LLDP_STANDARD_DST_MAC_STRING =
@@ -510,6 +514,7 @@ public class LinkDiscoveryManager implements IOFMessageListener,
                            FloodlightContext cntx) {
         switch (msg.getType()) {
             case PACKET_IN:
+                debugCounters.updateCounter("linkdiscovery-incoming");
                 return this.handlePacketIn(sw.getId(), (OFPacketIn) msg,
                                            cntx);
             case PORT_STATUS:
@@ -991,7 +996,8 @@ public class LinkDiscoveryManager implements IOFMessageListener,
         lldpClock = (lldpClock + 1) % LLDP_TO_ALL_INTERVAL;
 
         if (lldpClock == 0) {
-            log.debug("Sending LLDP out on all ports.");
+            if (log.isTraceEnabled())
+                log.trace("Sending LLDP out on all ports.");
             discoverOnAllPorts();
         }
     }
@@ -2095,6 +2101,7 @@ public class LinkDiscoveryManager implements IOFMessageListener,
         storageSource = context.getServiceImpl(IStorageSourceService.class);
         threadPool = context.getServiceImpl(IThreadPoolService.class);
         restApi = context.getServiceImpl(IRestApiService.class);
+        debugCounters = context.getServiceImpl(IDebugCounterService.class);
 
         // read our config options
         Map<String, String> configOptions = context.getConfigParams(this);
@@ -2177,6 +2184,8 @@ public class LinkDiscoveryManager implements IOFMessageListener,
                       + "switch table {}", SWITCH_CONFIG_TABLE_NAME);
         }
 
+        registerLinkDiscoveryDebugCounters();
+
         ScheduledExecutorService ses = threadPool.getScheduledExecutor();
 
         // To be started by the first switch connection
@@ -2250,6 +2259,16 @@ public class LinkDiscoveryManager implements IOFMessageListener,
         setControllerTLV();
     }
 
+    private void registerLinkDiscoveryDebugCounters() {
+        if (debugCounters == null) {
+            log.error("Debug Counter Service not found.");
+            debugCounters = new NullDebugCounter();
+            return;
+        }
+        debugCounters.registerCounter(getName() + "-" + "incoming",
+            "All incoming packets seen by this module", CounterType.ALWAYS_COUNT);
+    }
+
     // ****************************************************
     // Topology Manager's Event History members and methods
     // ****************************************************

src/main/java/net/floodlightcontroller/topology/TopologyManager.java

@@ -44,6 +44,9 @@ import net.floodlightcontroller.core.module.IFloodlightModule;
 import net.floodlightcontroller.core.module.IFloodlightService;
 import net.floodlightcontroller.core.util.SingletonTask;
 import net.floodlightcontroller.counter.ICounterStoreService;
+import net.floodlightcontroller.debugcounter.IDebugCounterService;
+import net.floodlightcontroller.debugcounter.NullDebugCounter;
+import net.floodlightcontroller.debugcounter.IDebugCounterService.CounterType;
 import net.floodlightcontroller.linkdiscovery.ILinkDiscoveryListener;
 import net.floodlightcontroller.linkdiscovery.ILinkDiscoveryService;
 import net.floodlightcontroller.packet.BSN;
@@ -111,6 +114,7 @@ public class TopologyManager implements
     protected IThreadPoolService threadPool;
     protected IFloodlightProviderService floodlightProvider;
     protected IRestApiService restApi;
+    protected IDebugCounterService debugCounters;
 
     // Modules that listen to our updates
     protected ArrayList<ITopologyListener> topologyAware;
@@ -645,6 +649,7 @@ public class TopologyManager implements
                            FloodlightContext cntx) {
         switch (msg.getType()) {
             case PACKET_IN:
+                debugCounters.updateCounter("topology-incoming");
                 return this.processPacketInMessage(sw,
                                                    (OFPacketIn) msg, cntx);
             default:
@@ -735,6 +740,7 @@ public class TopologyManager implements
         floodlightProvider =
                 context.getServiceImpl(IFloodlightProviderService.class);
         restApi = context.getServiceImpl(IRestApiService.class);
+        debugCounters = context.getServiceImpl(IDebugCounterService.class);
 
         switchPorts = new HashMap<Long,Set<Short>>();
         switchPortLinks = new HashMap<NodePortTuple, Set<Link>>();
@@ -760,6 +766,17 @@ public class TopologyManager implements
         floodlightProvider.addOFMessageListener(OFType.PACKET_IN, this);
         floodlightProvider.addHAListener(this);
         addRestletRoutable();
+        registerLinkDiscoveryDebugCounters();
+    }
+
+    private void registerLinkDiscoveryDebugCounters() {
+        if (debugCounters == null) {
+            log.error("Debug Counter Service not found.");
+            debugCounters = new NullDebugCounter();
+            return;
+        }
+        debugCounters.registerCounter(getName() + "-" + "incoming",
+            "All incoming packets seen by this module", CounterType.ALWAYS_COUNT);
     }
 
     protected void addRestletRoutable() {

src/main/resources/META-INF/services/net.floodlightcontroller.core.module.IFloodlightModule

@@ -16,6 +16,8 @@ net.floodlightcontroller.hub.Hub
 net.floodlightcontroller.jython.JythonDebugInterface
 net.floodlightcontroller.counter.CounterStore
 net.floodlightcontroller.counter.NullCounterStore
+net.floodlightcontroller.debugcounter.DebugCounter
+net.floodlightcontroller.debugcounter.NullDebugCounter
 net.floodlightcontroller.threadpool.ThreadPool
 net.floodlightcontroller.ui.web.StaticWebRoutable
 net.floodlightcontroller.virtualnetwork.VirtualNetworkFilter

src/main/resources/floodlightdefault.properties

@@ -12,6 +12,7 @@ net.floodlightcontroller.flowcache.FlowCache, \
 net.floodlightcontroller.flowcache.FlowReconcileManager, \
 net.floodlightcontroller.jython.JythonDebugInterface,\
 net.floodlightcontroller.counter.CounterStore,\
+net.floodlightcontroller.debugcounter.DebugCounter,\
 net.floodlightcontroller.perfmon.PktInProcessingTime,\
 net.floodlightcontroller.ui.web.StaticWebRoutable,\
 net.floodlightcontroller.loadbalancer.LoadBalancer