docs: protected void performWarmStart()
                      throws ObjectManagerException
      {
          final String methodName = "performWarmStart";
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.entry(this,
                          cclass,
                          methodName);
  
          FileLogInput logInput = new FileLogInput(logFile,
                                                   this);
          // Access a dummy log for output written during recovery.
          logOutput = new DummyLogOutput();
          // Transfer the log file size to logOutput so we can assume the same size file
          // during recovery. This also allows the ObjectStores to calculate their file
          // space requirements based on the ultimate size of the log.
          logOutput.setLogFileSize(logInput.getLogFileSize());
  
          // TODO  For emergency restart where the Log is lost.
          // Re-establish the anchor for the permanent state of the object manager,
          // which is Token number 1 in the default object store.
  
          // During restart we set currentMaximumActiveTransactions large in case it has been reduced below what we need.
          currentMaximumActiveTransactions = Integer.MAX_VALUE;
  
          performRecovery(logInput); // Read the log records.
          // Can't close logInput because it closes the logFile.
          // logInput.close(); // Finished with the log input.
          logOutput.close(); // Finished with the dummy log output.
  
          // Switch to a real logOutput.
          // Make the log files available for forward processing.
          // The LogInput position is now pointed at the page after the valid part of what
          // we have just read, this is the first invalid page after the last completely
          // written page. Make this the first page to be written by LogOutput.
          logOutput = new FileLogOutput(logFile,
                                        logOutput.getLogSequenceNumber(),
                                        logInput.getCurrentPage(),
                                        this);
  
          // Should not be needed as we are single threaded during recovery.
          synchronized (registeredInternalTransactions) {
              if (Tracing.isAnyTracingEnabled() && trace.isDebugEnabled())
                  trace.debug(this
                              , cclass
                              , methodName
                              , "Inform registered transactions that recovery is completed:620");
              // Reserve the space the active transactions need in the log.
              // Inform the transactions that we have completed recovery.
              for (java.util.Iterator registeredTransactionIterator = registeredInternalTransactions.values()
                              .iterator(); registeredTransactionIterator.hasNext();) {
                  InternalTransaction registeredTransaction = (InternalTransaction) registeredTransactionIterator.next();
                  // Do not use getExternalTransaction because this would make a weak reference, which would cause
                  // the transaction to be backed out as soon as we drop our reference to it.
                  Transaction transaction = new Transaction(registeredTransaction);
                  logOutput.reserve(registeredTransaction.getLogSpaceReserved());
                  transaction.recoveryCompleted();
              } // for registeredInternalTransactions.
  
              if (Tracing.isAnyTracingEnabled() && trace.isDebugEnabled())
                  trace.debug(this, cclass, methodName, "Complete transactions:634");
  
              for (java.util.Iterator registeredTransactionIterator = registeredInternalTransactions.values()
                              .iterator(); registeredTransactionIterator.hasNext();) {
                  InternalTransaction registeredTransaction = (InternalTransaction) registeredTransactionIterator.next();
                  Transaction transaction;
  
                  switch (registeredTransaction.state) {
                      case (Transaction.statePrePreparedPersistent):
                          transaction = new Transaction(registeredTransaction);
                          transaction.prepare();
                          if (logFileType == ObjectManager.LOG_FILE_TYPE_CLEAR)
                              transaction.backout(false);
                          break;
  
                      case (Transaction.stateCommitingPersistent):
                          transaction = new Transaction(registeredTransaction);
                          transaction.commit(false); // Do not reuse this transaction.
                          break;
  
                      case (Transaction.stateActivePersistent):
                          // Back out all transactions that are not in prepared state.
                      case (Transaction.stateBackingOutPersistent):
                          transaction = new Transaction(registeredTransaction);
                          transaction.backout(false); // Do not reuse this transaction.
                          break;
  
                  } // switch (registeredTransaction.state).
              } // for registeredInternalTransactions.
          } // synchronized (registeredInternalTransactions).
  
          Transaction transaction = getTransaction();
          if (logFileType == ObjectManager.LOG_FILE_TYPE_CLEAR) {
              // We will ake new namedObjects Trees, later.
              namedObjects = null;
  
              for (java.util.Iterator objectStoreIterator = objectStores.values().iterator(); objectStoreIterator.hasNext();) {
                  ObjectStore objectStore = (ObjectStore) objectStoreIterator.next();
                  objectStore.clear();
              } // for objectStores...
          } // if (logFileType == ObjectManager.LOG_FILE_TYPE_CLEAR).
  
          // If an objectStore is SAVE_ONLY_ON_SHUTDOWN and we fail before shutdown then the
          // restart data will not be saved, this may cause problems because the named Object tree is
          // not there after restart because the store is empty but is assumed to contain the tree.
          // It is good practice to shutdown and restart after creating a SAVE__ONLY_ON_SHUTOWN ObjectStore.
          // Force the namedObjectTree to exist in all ObjectStores that contain restart data.
          for (java.util.Iterator objectStoreIterator = objectStores.values().iterator(); objectStoreIterator.hasNext();) {
              ObjectStore objectStore = (ObjectStore) objectStoreIterator.next();
  
              // Make new namedObjects Trees, but don't bother with
              // ObjectStores that can't be used for recovery.
              if (objectStore.getContainsRestartData()) {
                  TreeMap namedObjectsTree = getNamedObjects(objectStore, transaction);
                  if (namedObjects == null)
                      namedObjects = namedObjectsTree.getToken();
              } // if (objectStore.getContainsRestartData()).
  
          } // for objectstores...
  
          transaction.commit(false);
  
          trace.debug(cclass, methodName, "ObjectManager using logFile " + logFileName + " was warm started logFileType=" + ObjectManager.logFileTypeNames[logFileType]);
  
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.exit(this,
                         cclass,
                         methodName,
                         new Object[] { coldStartLogFileName, new java.util.Date(coldStartTime) });
      }