opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/DeadlockMonitor.java

   1 /*
   2  * Copyright (c) 2014, 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.controller.config.manager.impl;
  10
  11 import java.util.Deque;
  12 import java.util.LinkedList;
  13 import java.util.concurrent.TimeUnit;
  14 import javax.annotation.Nullable;
  15 import javax.annotation.concurrent.GuardedBy;
  16 import org.opendaylight.controller.config.api.ModuleIdentifier;
  17 import org.slf4j.Logger;
  18 import org.slf4j.LoggerFactory;
  19
  20 public class DeadlockMonitor implements AutoCloseable {
  21     private static final Logger LOG = LoggerFactory.getLogger(DeadlockMonitor.class);
  22
  23     private static final long WARN_AFTER_MILLIS = 5000;
  24
  25     private final TransactionIdentifier transactionIdentifier;
  26     private final DeadlockMonitorRunnable thread;
  27     @GuardedBy("this")
  28     private final Deque<ModuleIdentifierWithNanos> moduleIdentifierWithNanosStack = new LinkedList<>();
  29     @GuardedBy("this")
  30     private ModuleIdentifierWithNanos top = ModuleIdentifierWithNanos.EMPTY;
  31
  32     public DeadlockMonitor(TransactionIdentifier transactionIdentifier) {
  33         this.transactionIdentifier = transactionIdentifier;
  34         thread = new DeadlockMonitorRunnable();
  35         thread.start();
  36     }
  37
  38     public synchronized void setCurrentlyInstantiatedModule(ModuleIdentifier currentlyInstantiatedModule) {
  39
  40         boolean popping = currentlyInstantiatedModule == null;
  41         if (popping) {
  42             moduleIdentifierWithNanosStack.pop();
  43             if (moduleIdentifierWithNanosStack.isEmpty()) {
  44                 top = ModuleIdentifierWithNanos.EMPTY;
  45             } else {
  46                 top = moduleIdentifierWithNanosStack.peekLast();
  47             }
  48         } else {
  49             ModuleIdentifierWithNanos current = new ModuleIdentifierWithNanos(currentlyInstantiatedModule);
  50             moduleIdentifierWithNanosStack.push(current);
  51             top = current;
  52         }
  53         LOG.trace("setCurrentlyInstantiatedModule {}, top {}", currentlyInstantiatedModule, top);
  54     }
  55
  56     public boolean isAlive() {
  57         return thread.isAlive();
  58     }
  59
  60     @Override
  61     public void close() {
  62         thread.interrupt();
  63     }
  64
  65     @Override
  66     public String toString() {
  67         return "DeadlockMonitor{" + transactionIdentifier + '}';
  68     }
  69
  70     private class DeadlockMonitorRunnable extends Thread {
  71
  72         private DeadlockMonitorRunnable() {
  73             super(DeadlockMonitor.this.toString());
  74         }
  75
  76         @Override
  77         public void run() {
  78             ModuleIdentifierWithNanos old = new ModuleIdentifierWithNanos(); // null moduleId
  79             while (this.isInterrupted() == false) {
  80                 ModuleIdentifierWithNanos copy = new ModuleIdentifierWithNanos(DeadlockMonitor.this.top);
  81                 if (old.moduleIdentifier == null || old.equals(copy) == false) {
  82                     // started
  83                     old = copy;
  84                 } else {
  85                     // is the getInstance() running longer than WARN_AFTER_MILLIS ?
  86                     long runningTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - copy.nanoTime);
  87                     if (runningTime > WARN_AFTER_MILLIS) {
  88                         LOG.warn("{} did not finish after {} ms", copy.moduleIdentifier, runningTime);
  89                     }
  90                 }
  91                 try {
  92                     sleep(1000);
  93                 } catch (InterruptedException e) {
  94                     interrupt();
  95                 }
  96             }
  97             LOG.trace("Exiting {}", this);
  98         }
  99
 100         @Override
 101         public String toString() {
 102             return "DeadLockMonitorRunnable{" + transactionIdentifier + "}";
 103         }
 104     }
 105
 106
 107
 108
 109     private static class ModuleIdentifierWithNanos {
 110         private static ModuleIdentifierWithNanos EMPTY = new ModuleIdentifierWithNanos();
 111         @Nullable
 112         private final ModuleIdentifier moduleIdentifier;
 113
 114         private final long nanoTime;
 115
 116         private ModuleIdentifierWithNanos() {
 117             this((ModuleIdentifier)null);
 118         }
 119
 120         private ModuleIdentifierWithNanos(ModuleIdentifier moduleIdentifier) {
 121             this.moduleIdentifier = moduleIdentifier;
 122             nanoTime = System.nanoTime();
 123         }
 124
 125         private ModuleIdentifierWithNanos(ModuleIdentifierWithNanos copy) {
 126             moduleIdentifier = copy.moduleIdentifier;
 127             nanoTime = copy.nanoTime;
 128         }
 129
 130         @Override
 131         public boolean equals(Object o) {
 132             if (this == o) {
 133                 return true;
 134             }
 135             if (o == null || getClass() != o.getClass()) {
 136                 return false;
 137             }
 138
 139             ModuleIdentifierWithNanos that = (ModuleIdentifierWithNanos) o;
 140
 141             if (nanoTime != that.nanoTime) {
 142                 return false;
 143             }
 144             if (moduleIdentifier != null ? !moduleIdentifier.equals(that.moduleIdentifier) : that.moduleIdentifier != null) {
 145                 return false;
 146             }
 147
 148             return true;
 149         }
 150
 151         @Override
 152         public int hashCode() {
 153             int result = moduleIdentifier != null ? moduleIdentifier.hashCode() : 0;
 154             result = 31 * result + (int) (nanoTime ^ (nanoTime >>> 32));
 155             return result;
 156         }
 157
 158         @Override
 159         public String toString() {
 160             return "ModuleIdentifierWithNanos{" +
 161                     moduleIdentifier +
 162                     '}';
 163         }
 164     }
 165 }