docs: public final void reserve(int deltaSize, boolean paced)
                      throws ObjectManagerException
      {
          final String methodName = "reserve";
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.entry(this,
                          cclass,
                          methodName,
                          new Object[] { new Integer(deltaSize), new Boolean(paced) });
  
          long newReservedSize = reservedSize.addAndGet(deltaSize);
  
          if (newReservedSize > reservationCheckpointThreshold) {
              numberOfReservationCheckpointsTriggered++;
              objectManagerState.requestCheckpoint(persistent);
  
              // Pacing: slow paced requests.
              // ----------------------------   
              if (paced) {
                  synchronized (reservationPacingLock) {
  
                      // TODO not during restart!
                      // TODO Need to release all waiters at shutdown.
                      while (newReservedSize > reservationCheckpointThreshold
                             && reservationPacing
                             && paced) {
                          if (Tracing.isAnyTracingEnabled() && trace.isDebugEnabled())
                              trace.debug(this, cclass, methodName, new Object[] { "wait:728",
                                                                                  new Long(newReservedSize),
                                                                                  new Long(reservationCheckpointThreshold),
                                                                                  new Long(reservationThreshold),
                                                                                  new Boolean(reservationPacing) });
                          try {
                              newReservedSize = reservedSize.addAndGet(-deltaSize);
                              reservationPacingLock.wait();
  
                          } catch (InterruptedException exception) {
                              // No FFDC Code Needed.
                              ObjectManager.ffdc.processException(this, cclass, methodName, exception, "1:739:1.57");
                              if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                                  trace.exit(this, cclass, methodName, exception);
                              throw new UnexpectedExceptionException(this, exception);
  
                          } finally {
                              newReservedSize = reservedSize.addAndGet(deltaSize);
                          } // try...
                      } // while (newReservedSize > reservationCheckpointThreshold...
  
                      // If we have a big enough backlog of reserved space in the store, 
                      // make subsequent paced requests also wait, 
                      // except during restart or shutdown.
                      if (newReservedSize > reservationCheckpointThreshold
                          && (objectManagerState.state == ObjectManagerState.stateColdStarted
                          || objectManagerState.state == ObjectManagerState.stateWarmStarted)) {
                          reservationPacing = true;
                      } else {
                          // Allow at least one more waiter to proceed.
                          reservationPacing = false;
                          reservationPacingLock.notify();
                      } // if (newReservedSize...
                  } // synchronized (reservationPacingLock).
  
              } // if (paced)..
  
              // Expand the file size if necessary.
              // ----------------------------------
  
              if (newReservedSize > reservationThreshold) {
                  synchronized (this) {
                      // Try extending the file.
                      // TODO setAllocationAllowed() will release another paced reservation.
                      setAllocationAllowed();
  
                      if (newReservedSize > (storeFileSizeAllocated - storeFileSizeUsed - directoryReservedSize)) {
                          // Suppress storeFull exceptions during recovery.
                          // Also suppress the exception if we are releasing space by using a negative delta size.
                          // During commit surplus space is released into the store. If the directory depth has
                          // increased meanwhile this may mean that there is still insufficient space in the store to allow
                          // further reservation requests, but we still allow negative requests.
                          if (objectManagerState.getObjectManagerStateState() == ObjectManagerState.stateReplayingLog
                              || deltaSize <= 0) {
                              if (Tracing.isAnyTracingEnabled() && trace.isDebugEnabled())
                                  trace.debug(this, cclass, methodName, new Object[] { "Objectstorefull exception supressed:783",
                                                                                      new Long(newReservedSize) });
                          } else {
                              // We can't make the reservation so take it back.
                              reservedSize.addAndGet(-deltaSize);
  
                              if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                                  trace.exit(this, cclass, methodName, new Object[] { new Long(newReservedSize) });
                              throw new ObjectStoreFullException(this, null); // TODO objectToStore
                          } // if (objectManagerState...
                      } // if (reservedSize > (storeFileSizeAllocated - storeFileSizeUsed)).
                  } // synchronized (this).
  
              } // if (newReservedSize > reservationThreshold).
  
          } else if (reservationPacing) {
              // We are below the limit so release any paced reservations.
              synchronized (reservationPacingLock) {
                  pacedReservationsReleased++;
                  reservationPacing = false;
                  reservationPacingLock.notify();
              } // synchronized (reservationPacingLock).
  
          } // if (newReservedSize > reservationCheckpointThreshold).
  
          if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
              trace.exit(this, cclass, methodName);
      }