docs: public void alarm(Object context)
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      	SibTr.entry(this, tc, "alarm", context);
      
      btmLockManager.lock();
      boolean btmLocked = true;
      timeoutLockManager.lockExclusive();
      boolean timeoutLocked = true;
      try
      {
        //we won't be called unless there are alarms which have timedout but check anyway
        if (!timedout.isEmpty() && !isStopped)
        {
          btmLockManager.unlock();
          btmLocked = false;
          //see defect 280069:
          //So that we can release the exclusive lock before calling processTimedoutEntries
          //(and so avoid deadlock on streamStatus monitor) we take a local copy 
          //(which therefore cannot be modified by anyone behind us) and create 
          //a new list; this replaces holding the exclusive lock for the duration of the method
          //and then clearing the list at the end. 
          
          List tempTimeoutList = timedout; //take a local copy of the list
          
          timedout = new ArrayList<BatchedTimeoutEntry>(); //the timeout entries will be dealt with
          //presently. Meantime we empty the timedout list so that subsequent timeouts
          //can be added to it without affecting processTimedoutEntries
          
          timeoutLockManager.unlockExclusive(); //we no longer care if timedout
          timeoutLocked = false;
          //changes underneath us so we can release the exclusive lock.
  
          try
          {
            //call the processor with the list of timedout BTEs, which should not be changed
            handler.processTimedoutEntries(tempTimeoutList);
            
            // We had a good batch - clear any previous failures
            batchFailed = false;
            batchCleared = false;
          }
          catch(Throwable e)
          {
            // FFDC the problem with the alarm, but don't re-throw the exception
            FFDCFilter.processException(
              e,
              "com.ibm.ws.sib.processor.utils.am.BatchedTimeoutManager.alarm",
              "1:280:1.24",
              new Object[] {this, handler, tempTimeoutList});
            
            SibTr.exception(tc, e);          
            
            // Alarms registered with the BatchedTimeoutManager are set to auto-repeat,
            // if we simply report the failure in an alarm it'll probably happen again
            // and again, forever. So we need to take steps to stop that happening, by
            // removing entries and possibly even stopping the manager (athough as a manager
            // is specific to a certain object (e.g. a specific AOStream) the damage should 
            // be contained - although still serious.
            
            // We worked the previous time so we'll give the alarms one more try before
            // bombing out
            if(!batchFailed)
              batchFailed = true;
           // If we've failed before, this was our last chance, something is wrong with
            // at least one of the entries, but we can't tell which one so we'll have to
            // remove all the entries - which will stop the error happening over and over
            // again (but not fix the reason for the error!)
            else
            {
              batchFailed = false;
              
              // Remove all the entries and see if that stops the error happening
              Iterator itr = tempTimeoutList.iterator();
              while(itr.hasNext())
              {
                BatchedTimeoutEntry bte = (BatchedTimeoutEntry)itr.next();
                removeTimeoutEntry(bte);
              }
  
              // If we've already been here and cleared the entries but something has
              // reregistered a new alarm that caused another problem (probably the same
              // one) we just give up and stop the alarm manager to prevent new alarms
              // being registered
              if(batchCleared)
              {
                // This is serious, throw another FFDC
                SIErrorException e2 =
                  new SIErrorException(
                    nls.getFormattedMessage(
                      "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                      new Object[] {
                        "com.ibm.ws.sib.processor.utils.am.BatchedTimeoutManager.alarm",
                        "1:325:1.24" },
                      null), e);
                
                FFDCFilter.processException(
                  e2,
                  "com.ibm.ws.sib.processor.utils.am.BatchedTimeoutManager.alarm",
                  "1:331:1.24",
                  this);
                
                SibTr.exception(tc, e2);
                
                // Stop the timer
                stopTimer();
              }
              // Remember that we've just cleared up after a problem
              else
                batchCleared = true;
            }
          }
          //restart the entries
          restartEntries(tempTimeoutList);      
        }
      }
      finally
      {
        if(timeoutLocked)
          timeoutLockManager.unlockExclusive();
        if(btmLocked)
          btmLockManager.unlock();
      }
          
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      	SibTr.exit(tc, "alarm");
    }