docs: public Lock acquirePutFromLoadLock(Object session, Object key, long txTimestamp) {
  		if (trace) {
  			log.tracef("acquirePutFromLoadLock(%s#%s, %d)", cache.getName(), key, txTimestamp);
  		}
  		boolean locked = false;
  
  		PendingPutMap pending = pendingPuts.get( key );
  		for (;;) {
  			try {
  				if (pending != null) {
  					locked = pending.acquireLock(100, TimeUnit.MILLISECONDS);
  					if (locked) {
  						boolean valid = false;
  						try {
  							if (pending.isRemoved()) {
  								// this deals with a race between retrieving the map from cache vs. removing that
  								// and locking the map
  								pending.releaseLock();
  								locked = false;
  								pending = null;
  								if (trace) {
  									log.tracef("Record removed when waiting for the lock.");
  								}
  								continue;
  							}
  							final PendingPut toCancel = pending.remove(session);
  							if (toCancel != null) {
  								valid = !toCancel.completed;
  								toCancel.completed = true;
  							}
  							else {
  								// this is a naked put
  								if (pending.hasInvalidator()) {
  									valid = false;
  								}
  								// we need this check since registerPendingPut (creating new pp) can get between invalidation
  								// and naked put caused by the invalidation
  								else if (pending.lastInvalidationEnd != Long.MIN_VALUE) {
  									// if this transaction started after last invalidation we can continue
  									valid = txTimestamp > pending.lastInvalidationEnd;
  								}
  								else {
  									valid = txTimestamp > regionInvalidationTimestamp;
  								}
  							}
  							return valid ? pending : null;
  						}
  						finally {
  							if (!valid && pending != null) {
  								pending.releaseLock();
  								locked = false;
  							}
  							if (trace) {
  								log.tracef("acquirePutFromLoadLock(%s#%s, %d) ended with %s, valid: %s", cache.getName(), key, txTimestamp, pending, valid);
  							}
  						}
  					}
  					else {
  						if (trace) {
  							log.tracef("acquirePutFromLoadLock(%s#%s, %d) failed to lock", cache.getName(), key, txTimestamp);
  						}
  						// oops, we have leaked record for this owner, but we don't want to wait here
  						return null;
  					}
  				}
  				else {
  					long regionInvalidationTimestamp = this.regionInvalidationTimestamp;
  					if (txTimestamp <= regionInvalidationTimestamp) {
  						if (trace) {
  							log.tracef("acquirePutFromLoadLock(%s#%s, %d) failed due to region invalidated at %d", cache.getName(), key, txTimestamp, regionInvalidationTimestamp);
  						}
  						return null;
  					}
  					else {
  						if (trace) {
  							log.tracef("Region invalidated at %d, this transaction started at %d", regionInvalidationTimestamp, txTimestamp);
  						}
  					}
  
  					PendingPut pendingPut = new PendingPut(session);
  					pending = new PendingPutMap(pendingPut);
  					PendingPutMap existing = pendingPuts.putIfAbsent(key, pending);
  					if (existing != null) {
  						pending = existing;
  					}
  					// continue in next loop with lock acquisition
  				}
  			}
  			catch (Throwable t) {
  				if (locked) {
  					pending.releaseLock();
  				}
  
  				if (t instanceof RuntimeException) {
  					throw (RuntimeException) t;
  				}
  				else if (t instanceof Error) {
  					throw (Error) t;
  				}
  				else {
  					throw new RuntimeException(t);
  				}
  			}
  		}
  	}