Revert "HBASE-21376 Add some verbose log to MasterProcedureScheduler"

This reverts commit 71224ee530.

hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureEnv.java

@@ -82,9 +82,7 @@ public class MasterProcedureEnv implements ConfigurationObserver {
   public MasterProcedureEnv(final MasterServices master,
       final RSProcedureDispatcher remoteDispatcher) {
     this.master = master;
-    boolean verbose = master.getConfiguration()
+    this.procSched = new MasterProcedureScheduler();
-        .getBoolean("hbase.master.procedure.scheduler.verbose", false);
-    this.procSched = new MasterProcedureScheduler(verbose);
     this.remoteDispatcher = remoteDispatcher;
   }
 

hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureScheduler.java

@@ -116,16 +116,6 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
 
   private final SchemaLocking locking = new SchemaLocking();
 
-  private boolean verbose = false;
-
-  public MasterProcedureScheduler() {
-
-  }
-
-  public MasterProcedureScheduler(boolean verbose) {
-    this.verbose = verbose;
-  }
-
   @Override
   public void yield(final Procedure proc) {
     push(proc, isTableProcedure(proc), true);
@@ -157,11 +147,11 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
     if (!queue.getLockStatus().hasExclusiveLock()) {
       // if the queue was not remove for an xlock execution,put the queue back into execution
       queue.add(proc, addFront);
-      addToRunQueue(fairq, queue, proc, "queue doesn't have exclusivelock");
+      addToRunQueue(fairq, queue);
     } else if (queue.getLockStatus().hasLockAccess(proc)) {
       // always add it to front as the have the lock access.
       queue.add(proc, true);
-      addToRunQueue(fairq, queue, proc, "procedure has lock access");
+      addToRunQueue(fairq, queue);
     } else {
       queue.add(proc, addFront);
     }
@@ -195,9 +185,6 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
   private <T extends Comparable<T>> Procedure<?> doPoll(final FairQueue<T> fairq) {
     final Queue<T> rq = fairq.poll();
     if (rq == null || !rq.isAvailable()) {
-      if (verbose && rq != null) {
-        LOG.debug("polled from {} but it is not available", rq);
-      }
       return null;
     }
 
@@ -208,30 +195,20 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
     final boolean xlockReq = rq.requireExclusiveLock(pollResult);
     if (xlockReq && rq.getLockStatus().isLocked() && !rq.getLockStatus().hasLockAccess(pollResult)) {
       // someone is already holding the lock (e.g. shared lock). avoid a yield
-      removeFromRunQueue(fairq, rq, pollResult,
+      removeFromRunQueue(fairq, rq);
-          "exclusive lock not acquired: " + rq.getLockStatus());
       return null;
     }
 
     rq.poll();
     if (rq.isEmpty() || xlockReq) {
-      String why = "";
+      removeFromRunQueue(fairq, rq);
-      if (rq.isEmpty()) {
-        why += "runqueue is empty ";
-      }
-      if (xlockReq) {
-        why += "xlock is required for next procedure";
-      }
-      removeFromRunQueue(fairq, rq, pollResult, why);
     } else if (rq.getLockStatus().hasParentLock(pollResult)) {
       // if the rq is in the fairq because of runnable child
       // check if the next procedure is still a child.
       // if not, remove the rq from the fairq and go back to the xlock state
       Procedure<?> nextProc = rq.peek();
       if (nextProc != null && !Procedure.haveSameParent(nextProc, pollResult)) {
-        removeFromRunQueue(fairq, rq, pollResult,
+        removeFromRunQueue(fairq, rq);
-            " parent holds the lock and the next one is not the child of the parent, next procid="
-                + nextProc.getProcId());
       }
     }
 
@@ -292,9 +269,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
     while (treeMap != null) {
       Queue<T> node = AvlTree.getFirst(treeMap);
       treeMap = AvlTree.remove(treeMap, node.getKey(), comparator);
-      if (fairq != null) {
+      if (fairq != null) removeFromRunQueue(fairq, node);
-        removeFromRunQueue(fairq, node, null, "clear is called");
-      }
     }
   }
 
@@ -351,25 +326,16 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
     }
   }
 
-  private <T extends Comparable<T>> void addToRunQueue(
+  private static <T extends Comparable<T>> void addToRunQueue(FairQueue<T> fairq, Queue<T> queue) {
-      FairQueue<T> fairq, Queue<T> queue, final Procedure proc, String why) {
     if (!AvlIterableList.isLinked(queue) && !queue.isEmpty()) {
       fairq.add(queue);
-      if (verbose) {
-        LOG.debug("Adding {} to runqueue, triggered by {}, since {}",
-            queue.getKey(), proc, why);
-      }
     }
   }
 
-  private <T extends Comparable<T>> void removeFromRunQueue(
+  private static <T extends Comparable<T>> void removeFromRunQueue(
-      FairQueue<T> fairq, Queue<T> queue, final Procedure proc, String why) {
+      FairQueue<T> fairq, Queue<T> queue) {
     if (AvlIterableList.isLinked(queue)) {
       fairq.remove(queue);
-      if (verbose) {
-        LOG.debug("Remove {} from runqueue, triggered by {}, since {}",
-            queue.getKey(), proc, why);
-      }
     }
   }
 
@@ -437,7 +403,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
 
       LockAndQueue lock = locking.getServerLock(serverName);
       if (node.isEmpty() && lock.tryExclusiveLock(proc)) {
-        removeFromRunQueue(serverRunQueue, node, proc, "tryCleanupServerQueue is called");
+        removeFromRunQueue(serverRunQueue, node);
         removeServerQueue(serverName);
       }
     } finally {
@@ -565,8 +531,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
         logLockedResource(LockedResourceType.TABLE, table.getNameAsString());
         return true;
       }
-      removeFromRunQueue(tableRunQueue, getTableQueue(table), procedure,
+      removeFromRunQueue(tableRunQueue, getTableQueue(table));
-          "need to wait TableExclusiveLock, lockstatus=" + tableLock);
       return false;
     } finally {
       schedUnlock();
@@ -590,8 +555,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
       if (namespaceLock.releaseSharedLock()) {
         waitingCount += wakeWaitingProcedures(namespaceLock);
       }
-      addToRunQueue(tableRunQueue, getTableQueue(table), procedure,
+      addToRunQueue(tableRunQueue, getTableQueue(table));
-          "table's exclusive lock is available");
       wakePollIfNeeded(waitingCount);
     } finally {
       schedUnlock();
@@ -643,8 +607,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
       final LockAndQueue tableLock = locking.getTableLock(table);
       int waitingCount = 0;
       if (tableLock.releaseSharedLock()) {
-        addToRunQueue(tableRunQueue, getTableQueue(table), procedure,
+        addToRunQueue(tableRunQueue, getTableQueue(table));
-            "table's shard lock is available");
         waitingCount += wakeWaitingProcedures(tableLock);
       }
       if (namespaceLock.releaseSharedLock()) {
@@ -852,8 +815,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
         waitingCount += wakeWaitingProcedures(namespaceLock);
       }
       if (systemNamespaceTableLock.releaseSharedLock()) {
-        addToRunQueue(tableRunQueue, getTableQueue(TableName.NAMESPACE_TABLE_NAME), procedure,
+        addToRunQueue(tableRunQueue, getTableQueue(TableName.NAMESPACE_TABLE_NAME));
-            "namespace exclusive lock is available");
         waitingCount += wakeWaitingProcedures(systemNamespaceTableLock);
       }
       wakePollIfNeeded(waitingCount);
@@ -883,9 +845,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
         removeFromRunQueue(serverRunQueue,
           getServerQueue(serverName,
             procedure instanceof ServerProcedureInterface ? (ServerProcedureInterface) procedure
-              : null), procedure,
+              : null));
-            "need to wait ServerExclusiveLock, ownerid=" + lock
-                .getExclusiveLockProcIdOwner());
         return false;
       }
       waitProcedure(lock, procedure);
@@ -913,7 +873,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
       addToRunQueue(serverRunQueue,
         getServerQueue(serverName,
           procedure instanceof ServerProcedureInterface ? (ServerProcedureInterface) procedure
-            : null), procedure, "Server's exclusive lock is available");
+            : null));
       int waitingCount = wakeWaitingProcedures(lock);
       wakePollIfNeeded(waitingCount);
     } finally {
@@ -988,8 +948,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
     try {
       final LockAndQueue lock = locking.getMetaLock();
       if (lock.tryExclusiveLock(procedure)) {
-        removeFromRunQueue(metaRunQueue, getMetaQueue(), procedure,
+        removeFromRunQueue(metaRunQueue, getMetaQueue());
-            "need to wait MetaExclusiveLock, lockStatus=" + lock);
         return false;
       }
       waitProcedure(lock, procedure);
@@ -1013,8 +972,7 @@ public class MasterProcedureScheduler extends AbstractProcedureScheduler {
     try {
       final LockAndQueue lock = locking.getMetaLock();
       lock.releaseExclusiveLock(procedure);
-      addToRunQueue(metaRunQueue, getMetaQueue(), procedure,
+      addToRunQueue(metaRunQueue, getMetaQueue());
-          "meta's exclusive lock is available");
       int waitingCount = wakeWaitingProcedures(lock);
       wakePollIfNeeded(waitingCount);
     } finally {

hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/Queue.java

@@ -118,10 +118,9 @@ abstract class Queue<TKey extends Comparable<TKey>> extends AvlLinkedNode<Queue<
 
   @Override
   public String toString() {
-    return String.format("%s(%s, xlock=%s sharedLock=%s size=%s peek=%s)",
+    return String.format("%s(%s, xlock=%s sharedLock=%s size=%s)", getClass().getSimpleName(), key,
-        getClass().getSimpleName(), key, lockStatus.hasExclusiveLock() ?
+      lockStatus.hasExclusiveLock() ? "true (" + lockStatus.getExclusiveLockProcIdOwner() + ")"
-            "true (" + lockStatus.getExclusiveLockProcIdOwner() + ")" :
+          : "false",
-            "false", lockStatus.getSharedLockCount(), size(),
+      lockStatus.getSharedLockCount(), size());
-        (size() > 0 ? peek() : "null"));
   }
 }