passenger 4.0.60 → 5.0.0.beta1

data/ext/common/ApplicationPool2/Options.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2013 Phusion
+ *  Copyright (c) 2010-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -104,6 +104,7 @@ private:
 		result.push_back(&options.ruby);
 		result.push_back(&options.python);
 		result.push_back(&options.nodejs);
+		result.push_back(&options.environmentVariables);
 		result.push_back(&options.loggingAgentAddress);
 		result.push_back(&options.loggingAgentUsername);
 		result.push_back(&options.loggingAgentPassword);
@@ -158,7 +159,7 @@ public:
 	 * application, this is the folder that contains 'app/', 'public/', 'config/',
 	 * etc. This must be a valid directory, but the path does not have to be absolute.
 	 */
-	StaticString appRoot;
+	HashedStaticString appRoot;
 
 	/**
 	 * A name used by ApplicationPool to uniquely identify an application.
@@ -168,7 +169,7 @@ public:
 	 *
 	 * If left empty, then the app root is used as the app group name.
 	 */
-	StaticString appGroupName;
+	HashedStaticString appGroupName;
 
 	/** The application's type, used for determining the command to invoke to
 	 * spawn an application process as well as determining the startup file's
@@ -267,9 +268,12 @@ public:
 
 	/**
 	 * Environment variables which should be passed to the spawned application
-	 * process.
+	 * process. This is a base64-encoded string of key-value pairs, with each
+	 * element terminated by a NUL character. For example:
+	 *
+	 *     base64("PATH\0/usr/bin\0RUBY\0/usr/bin/ruby\0")
 	 */
-	vector< pair<StaticString, StaticString> > environmentVariables;
+	StaticString environmentVariables;
 
 	/** Whether debugger support should be enabled. */
 	bool debugger;
@@ -396,6 +400,11 @@ public:
 	 */
 	unsigned long maxRequests;
 
+	/** If the current time (in microseconds) has already been queried, set it
+	 * here. Pool will use this timestamp instead of querying it again.
+	 */
+	unsigned long long currentTime;
+
 	/** When true, Pool::get() and Pool::asyncGet() will create the necessary
 	 * SuperGroup and Group structures just as normally, and will even handle
 	 * restarting logic, but will not actually spawn any processes and will not
@@ -433,33 +442,35 @@ public:
 	 * Creates a new Options object with the default values filled in.
 	 * One must still set appRoot manually, after having used this constructor.
 	 */
-	Options() {
-		logLevel                = DEFAULT_LOG_LEVEL;
-		startTimeout            = 90 * 1000;
-		environment             = P_STATIC_STRING("production");
-		baseURI                 = P_STATIC_STRING("/");
-		spawnMethod             = P_STATIC_STRING("smart");
-		defaultUser             = P_STATIC_STRING("nobody");
-		ruby                    = P_STATIC_STRING(DEFAULT_RUBY);
-		python                  = P_STATIC_STRING(DEFAULT_PYTHON);
-		nodejs                  = P_STATIC_STRING(DEFAULT_NODEJS);
-		rights                  = DEFAULT_BACKEND_ACCOUNT_RIGHTS;
-		debugger                = false;
-		loadShellEnvvars        = true;
-		analytics               = false;
-		raiseInternalError      = false;
-
-		minProcesses            = 1;
-		maxProcesses            = 0;
-		maxPreloaderIdleTime    = -1;
-		maxOutOfBandWorkInstances = 1;
-		maxRequestQueueSize     = 100;
-
-		stickySessionId         = 0;
-		statThrottleRate        = 0;
-		maxRequests             = 0;
-		noop                    = false;
-
+	Options()
+		: logLevel(DEFAULT_LOG_LEVEL),
+		  startTimeout(90 * 1000),
+		  environment(DEFAULT_APP_ENV, sizeof(DEFAULT_APP_ENV) - 1),
+		  baseURI("/", 1),
+		  spawnMethod(DEFAULT_SPAWN_METHOD, sizeof(DEFAULT_SPAWN_METHOD) - 1),
+		  defaultUser("nobody", sizeof("nobody") - 1),
+		  ruby(DEFAULT_RUBY, sizeof(DEFAULT_RUBY) - 1),
+		  python(DEFAULT_PYTHON, sizeof(DEFAULT_PYTHON) - 1),
+		  nodejs(DEFAULT_NODEJS, sizeof(DEFAULT_NODEJS) - 1),
+		  rights(DEFAULT_BACKEND_ACCOUNT_RIGHTS),
+		  debugger(false),
+		  loadShellEnvvars(true),
+		  analytics(false),
+		  raiseInternalError(false),
+
+		  minProcesses(1),
+		  maxProcesses(0),
+		  maxPreloaderIdleTime(-1),
+		  maxOutOfBandWorkInstances(1),
+		  maxRequestQueueSize(100),
+
+		  stickySessionId(0),
+		  statThrottleRate(DEFAULT_STAT_THROTTLE_RATE),
+		  maxRequests(0),
+		  currentTime(0),
+		  noop(false)
+		  /*********************************/
+	{
 		/*********************************/
 	}
 
@@ -493,10 +504,6 @@ public:
 		for (i = 0; i < otherStrings.size(); i++) {
 			otherLen += otherStrings[i]->size() + 1;
 		}
-		for (i = 0; i < other.environmentVariables.size(); i++) {
-			otherLen += environmentVariables[i].first.size() + 1;
-			otherLen += environmentVariables[i].second.size() + 1;
-		}
 
 		shared_array<char> data(new char[otherLen]);
 		end = data.get();
@@ -518,30 +525,12 @@ public:
 			*str = StaticString(pos, end - pos - 1);
 		}
 
-		// Copy environmentVariables names and values into the internal storage area.
-		for (i = 0; i < other.environmentVariables.size(); i++) {
-			const pair<StaticString, StaticString> &p = other.environmentVariables[i];
-
-			environmentVariables[i] = make_pair(
-				StaticString(end, p.first.size()),
-				StaticString(end + p.first.size() + 1, p.second.size())
-			);
-
-			// Copy over string data.
-			memcpy(end, p.first.data(), p.first.size());
-			end += p.first.size();
-			*end = '\0';
-			end++;
-
-			// Copy over value data.
-			memcpy(end, p.second.data(), p.second.size());
-			end += p.second.size();
-			*end = '\0';
-			end++;
-		}
-
 		storage = data;
 
+		// Fix up HashedStaticStrings' hashes.
+		appRoot.setHash(other.appRoot.hash());
+		appGroupName.setHash(other.appGroupName.hash());
+
 		return *this;
 	}
 
@@ -549,6 +538,7 @@ public:
 		hostName = StaticString();
 		uri      = StaticString();
 		stickySessionId = 0;
+		currentTime     = 0;
 		noop     = false;
 		return detachFromUnionStationTransaction();
 	}
@@ -634,7 +624,7 @@ public:
 	 * Returns the app group name. If there is no explicitly set app group name
 	 * then the app root is considered to be the app group name.
 	 */
-	StaticString getAppGroupName() const {
+	const HashedStaticString &getAppGroupName() const {
 		if (appGroupName.empty()) {
 			return appRoot;
 		} else {
@@ -643,9 +633,7 @@ public:
 	}
 
 	string getStartCommand(const ResourceLocator &resourceLocator) const {
-		if (appType == P_STATIC_STRING("classic-rails")) {
-			return ruby + "\t" + resourceLocator.getHelperScriptsDir() + "/classic-rails-loader.rb";
-		} else if (appType == P_STATIC_STRING("rack")) {
+		if (appType == P_STATIC_STRING("rack")) {
 			return ruby + "\t" + resourceLocator.getHelperScriptsDir() + "/rack-loader.rb";
 		} else if (appType == P_STATIC_STRING("wsgi")) {
 			return python + "\t" + resourceLocator.getHelperScriptsDir() + "/wsgi-loader.py";

data/ext/common/ApplicationPool2/Pool.h

@@ -37,6 +37,11 @@
 #include <boost/make_shared.hpp>
 #include <boost/function.hpp>
 #include <boost/foreach.hpp>
+#include <boost/pool/object_pool.hpp>
+// We use boost::container::vector instead of std::vector, because the
+// former does not allocate memory in its default constructor. This is
+// useful for post lock action vectors which often remain empty.
+#include <boost/container/vector.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <oxt/dynamic_thread_group.hpp>
 #include <oxt/backtrace.hpp>
@@ -47,6 +52,7 @@
 #include <ApplicationPool2/Session.h>
 #include <ApplicationPool2/SpawnerFactory.h>
 #include <ApplicationPool2/Options.h>
+#include <MemoryKit/palloc.h>
 #include <Logging.h>
 #include <Exceptions.h>
 #include <Hooks.h>
@@ -68,6 +74,8 @@ using namespace oxt;
 
 class Pool: public boost::enable_shared_from_this<Pool> {
 public:
+	typedef void (*AbortLongRunningConnectionsCallback)(const ProcessPtr &process);
+
 	struct InspectOptions {
 		bool colorize;
 		bool verbose;
@@ -128,6 +136,7 @@ public:
 	mutable boost::mutex syncher;
 	unsigned int max;
 	unsigned long long maxIdleTime;
+	bool selfchecking;
 
 	boost::condition_variable garbageCollectionCond;
 
@@ -150,7 +159,10 @@ public:
 		SHUT_DOWN
 	} lifeStatus;
 
-	SuperGroupMap superGroups;
+	mutable SuperGroupMap superGroups;
+	boost::mutex sessionObjectPoolSyncher;
+	object_pool<Session> sessionObjectPool;
+	psg_pool_t *palloc;
 
 	/**
 	 * get() requests that...
@@ -193,14 +205,14 @@ public:
 	const VariantMap *agentsOptions;
 	DebugSupportPtr debugSupport;
 
-	static void runAllActions(const vector<Callback> &actions) {
-		vector<Callback>::const_iterator it, end = actions.end();
+	static void runAllActions(const boost::container::vector<Callback> &actions) {
+		boost::container::vector<Callback>::const_iterator it, end = actions.end();
 		for (it = actions.begin(); it != end; it++) {
 			(*it)();
 		}
 	}
 
-	static void runAllActionsWithCopy(vector<Callback> actions) {
+	static void runAllActionsWithCopy(boost::container::vector<Callback> actions) {
 		runAllActions(actions);
 	}
 
@@ -214,16 +226,25 @@ public:
 
 	void verifyInvariants() const {
 		// !a || b: logical equivalent of a IMPLIES b.
-		assert(!( !getWaitlist.empty() ) || ( atFullCapacity(false) ));
-		assert(!( !atFullCapacity(false) ) || ( getWaitlist.empty() ));
+		#ifndef NDEBUG
+		if (!selfchecking) {
+			return;
+		}
+		assert(!( !getWaitlist.empty() ) || ( atFullCapacityUnlocked() ));
+		assert(!( !atFullCapacityUnlocked() ) || ( getWaitlist.empty() ));
+		#endif
 	}
 
 	void verifyExpensiveInvariants() const {
 		#ifndef NDEBUG
+		if (!selfchecking) {
+			return;
+		}
 		vector<GetWaiter>::const_iterator it, end = getWaitlist.end();
 		for (it = getWaitlist.begin(); it != end; it++) {
 			const GetWaiter &waiter = *it;
-			assert(superGroups.get(waiter.options.getAppGroupName()) == NULL);
+			const SuperGroupPtr *superGroup;
+			assert(!superGroups.lookup(waiter.options.getAppGroupName(), &superGroup));
 		}
 		#endif
 	}
@@ -234,14 +255,16 @@ public:
 		UPDATE_TRACE_POINT();
 		verifyExpensiveInvariants();
 		UPDATE_TRACE_POINT();
-		StringMap<SuperGroupPtr>::const_iterator sg_it, sg_end = superGroups.end();
-		for (sg_it = superGroups.begin(); sg_it != sg_end; sg_it++) {
-			pair<StaticString, SuperGroupPtr> p = *sg_it;
-			p.second->verifyInvariants();
-			foreach (GroupPtr group, p.second->groups) {
+
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
+			superGroup->verifyInvariants();
+			foreach (GroupPtr group, superGroup->groups) {
 				group->verifyInvariants();
 				group->verifyExpensiveInvariants();
 			}
+			sg_it.next();
 		}
 	}
 
@@ -289,11 +312,11 @@ public:
 	ProcessPtr findOldestIdleProcess(const Group *exclude = NULL) const {
 		ProcessPtr oldestIdleProcess;
 
-		SuperGroupMap::const_iterator it, end = superGroups.end();
-		for (it = superGroups.begin(); it != end; it++) {
-			const SuperGroupPtr &superGroup = it->second;
-			const vector<GroupPtr> &groups = superGroup->groups;
-			vector<GroupPtr>::const_iterator g_it, g_end = groups.end();
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
+			const SuperGroup::GroupList &groups = superGroup->groups;
+			SuperGroup::GroupList::const_iterator g_it, g_end = groups.end();
 			for (g_it = groups.begin(); g_it != g_end; g_it++) {
 				const GroupPtr &group = *g_it;
 				if (group.get() == exclude) {
@@ -311,6 +334,7 @@ public:
 					}
 				}
 			}
+			sg_it.next();
 		}
 
 		return oldestIdleProcess;
@@ -319,11 +343,11 @@ public:
 	ProcessPtr findBestProcessToTrash() const {
 		ProcessPtr oldestProcess;
 
-		SuperGroupMap::const_iterator it, end = superGroups.end();
-		for (it = superGroups.begin(); it != end; it++) {
-			const SuperGroupPtr &superGroup = it->second;
-			const vector<GroupPtr> &groups = superGroup->groups;
-			vector<GroupPtr>::const_iterator g_it, g_end = groups.end();
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
+			const SuperGroup::GroupList &groups = superGroup->groups;
+			SuperGroup::GroupList::const_iterator g_it, g_end = groups.end();
 			for (g_it = groups.begin(); g_it != g_end; g_it++) {
 				const GroupPtr &group = *g_it;
 				const ProcessList &processes = group->enabledProcesses;
@@ -336,6 +360,7 @@ public:
 					}
 				}
 			}
+			sg_it.next();
 		}
 
 		return oldestProcess;
@@ -345,7 +370,7 @@ public:
 	 * This function assigns sessions to them by calling get() on the corresponding
 	 * SuperGroups, or by creating more SuperGroups, in so far the new capacity allows.
 	 */
-	void assignSessionsToGetWaiters(vector<Callback> &postLockActions) {
+	void assignSessionsToGetWaiters(boost::container::vector<Callback> &postLockActions) {
 		bool done = false;
 		vector<GetWaiter>::iterator it, end = getWaitlist.end();
 		vector<GetWaiter> newWaitlist;
@@ -358,13 +383,13 @@ public:
 				SessionPtr session = superGroup->get(waiter.options, waiter.callback,
 					postLockActions);
 				if (session != NULL) {
-					postLockActions.push_back(boost::bind(
+					postLockActions.push_back(boost::bind(GetCallback::call,
 						waiter.callback, session, ExceptionPtr()));
 				}
 				/* else: the callback has now been put in
 				 *       the group's get wait list.
 				 */
-			} else if (!atFullCapacity(false)) {
+			} else if (!atFullCapacityUnlocked()) {
 				createSuperGroupAndAsyncGetFromIt(waiter.options, waiter.callback,
 					postLockActions);
 			} else {
@@ -381,10 +406,10 @@ public:
 	template<typename Queue>
 	static void assignExceptionToGetWaiters(Queue &getWaitlist,
 		const ExceptionPtr &exception,
-		vector<Callback> &postLockActions)
+		boost::container::vector<Callback> &postLockActions)
 	{
 		while (!getWaitlist.empty()) {
-			postLockActions.push_back(boost::bind(
+			postLockActions.push_back(boost::bind(GetCallback::call,
 				getWaitlist.front().callback, SessionPtr(),
 				exception));
 			getWaitlist.pop_front();
@@ -392,36 +417,39 @@ public:
 	}
 
 	void possiblySpawnMoreProcessesForExistingGroups() {
-		StringMap<SuperGroupPtr>::const_iterator sg_it, sg_end = superGroups.end();
 		/* Looks for Groups that are waiting for capacity to become available,
 		 * and spawn processes in those groups.
 		 */
-		for (sg_it = superGroups.begin(); sg_it != sg_end; sg_it++) {
-			pair<StaticString, SuperGroupPtr> p = *sg_it;
-			foreach (GroupPtr group, p.second->groups) {
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
+			foreach (GroupPtr group, superGroup->groups) {
 				if (group->isWaitingForCapacity()) {
 					P_DEBUG("Group " << group->name << " is waiting for capacity");
 					group->spawn();
-					if (atFullCapacity(false)) {
+					if (atFullCapacityUnlocked()) {
 						return;
 					}
 				}
 			}
+			sg_it.next();
 		}
 		/* Now look for Groups that haven't maximized their allowed capacity
 		 * yet, and spawn processes in those groups.
 		 */
-		for (sg_it = superGroups.begin(); sg_it != sg_end; sg_it++) {
-			pair<StaticString, SuperGroupPtr> p = *sg_it;
-			foreach (GroupPtr group, p.second->groups) {
+		sg_it = SuperGroupMap::ConstIterator(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
+			foreach (GroupPtr group, superGroup->groups) {
 				if (group->shouldSpawn()) {
 					P_DEBUG("Group " << group->name << " requests more processes to be spawned");
 					group->spawn();
-					if (atFullCapacity(false)) {
+					if (atFullCapacityUnlocked()) {
 						return;
 					}
 				}
 			}
+			sg_it.next();
 		}
 	}
 
@@ -433,24 +461,46 @@ public:
 		}
 	}
 
+	unsigned int capacityUsedUnlocked() const {
+		if (superGroups.size() == 1) {
+			SuperGroupPtr *superGroup;
+			superGroups.lookupRandom(NULL, &superGroup);
+			return (*superGroup)->capacityUsed();
+		} else {
+			SuperGroupMap::ConstIterator sg_it(superGroups);
+			int result = 0;
+			while (*sg_it != NULL) {
+				const SuperGroupPtr &superGroup = sg_it.getValue();
+				result += superGroup->capacityUsed();
+				sg_it.next();
+			}
+			return result;
+		}
+	}
+
+	bool atFullCapacityUnlocked() const {
+		return capacityUsedUnlocked() >= max;
+	}
+
 	/**
 	 * Calls Group::detach() so be sure to fix up the invariants afterwards.
 	 * See the comments for Group::detach() and the code for detachProcessUnlocked().
 	 */
 	ProcessPtr forceFreeCapacity(const Group *exclude,
-		vector<Callback> &postLockActions)
+		boost::container::vector<Callback> &postLockActions)
 	{
 		ProcessPtr process = findOldestIdleProcess(exclude);
 		if (process != NULL) {
 			P_DEBUG("Forcefully detaching process " << process->inspect() <<
 				" in order to free capacity in the pool");
 
-			const GroupPtr group = process->getGroup();
+			Group *group = process->getGroup();
 			assert(group != NULL);
 			assert(group->getWaitlist.empty());
 
-			const SuperGroupPtr superGroup = group->getSuperGroup();
+			SuperGroup *superGroup = group->getSuperGroup();
 			assert(superGroup != NULL);
+			(void) superGroup;
 
 			group->detach(process, postLockActions);
 		}
@@ -466,24 +516,27 @@ public:
 	 * operation, so running them in a thread is advised.
 	 */
 	void forceDetachSuperGroup(const SuperGroupPtr &superGroup,
-		vector<Callback> &postLockActions,
+		boost::container::vector<Callback> &postLockActions,
 		const SuperGroup::ShutdownCallback &callback)
 	{
 		const SuperGroupPtr sp = superGroup; // Prevent premature destruction.
-		bool removed = superGroups.remove(superGroup->name);
+		bool removed = superGroups.erase(superGroup->name);
 		assert(removed);
 		(void) removed; // Shut up compiler warning.
 		superGroup->destroy(false, postLockActions, callback);
 	}
 
-	bool detachProcessUnlocked(const ProcessPtr &process, vector<Callback> &postLockActions) {
+	bool detachProcessUnlocked(const ProcessPtr &process,
+		boost::container::vector<Callback> &postLockActions)
+	{
 		if (OXT_LIKELY(process->isAlive())) {
 			verifyInvariants();
 
-			const GroupPtr group = process->getGroup();
-			const SuperGroupPtr superGroup = group->getSuperGroup();
+			Group *group = process->getGroup();
+			SuperGroup *superGroup = group->getSuperGroup();
 			assert(superGroup->state != SuperGroup::INITIALIZING);
 			assert(superGroup->getWaitlist.empty());
+			(void) superGroup;
 
 			group->detach(process, postLockActions);
 			// 'process' may now be a stale pointer so don't use it anymore.
@@ -535,9 +588,9 @@ public:
 			}
 
 			const Socket *socket;
-			if (options.verbose && (socket = process->sockets->findSocketWithName("http")) != NULL) {
+			if (options.verbose && (socket = process->sockets.findSocketWithName("http")) != NULL) {
 				result << "    URL     : http://" << replaceString(socket->address, "tcp://", "") << endl;
-				result << "    Password: " << process->connectPassword << endl;
+				result << "    Password: " << StaticString(group->secret, Group::SECRET_SIZE) << endl;
 			}
 		}
 	}
@@ -589,7 +642,10 @@ public:
 		ticket->cond.notify_one();
 	}
 
-	static void syncGetCallback(Ticket *ticket, const SessionPtr &session, const ExceptionPtr &e) {
+	static void syncGetCallback(const SessionPtr &session, const ExceptionPtr &e,
+		void *userData)
+	{
+		Ticket *ticket = static_cast<Ticket *>(userData);
 		ScopedLock lock(ticket->syncher);
 		if (OXT_LIKELY(session != NULL)) {
 			ticket->session = session;
@@ -600,13 +656,18 @@ public:
 	}
 
 	SuperGroup *findMatchingSuperGroup(const Options &options) {
-		return superGroups.get(options.getAppGroupName()).get();
+		SuperGroupPtr *superGroup;
+		if (superGroups.lookup(options.getAppGroupName(), &superGroup)) {
+			return superGroup->get();
+		} else {
+			return NULL;
+		}
 	}
 
 	struct GarbageCollectorState {
 		unsigned long long now;
 		unsigned long long nextGcRunTime;
-		vector<Callback> actions;
+		boost::container::vector<Callback> actions;
 	};
 
 	static void garbageCollect(PoolPtr self) {
@@ -638,24 +699,43 @@ public:
 		}
 	}
 
-	void maybeDetachIdleProcess(GarbageCollectorState &state, const GroupPtr &group,
-		const ProcessPtr &process, ProcessList::iterator &p_it)
+	void checkWhetherProcessCanBeGarbageCollected(GarbageCollectorState &state,
+		const GroupPtr &group, const ProcessPtr &process, ProcessList &output)
 	{
 		assert(maxIdleTime > 0);
-		unsigned long long processGcTime =
-			process->lastUsed + maxIdleTime;
+		unsigned long long processGcTime = process->lastUsed + maxIdleTime;
 		if (process->sessions == 0
 		 && state.now >= processGcTime
 		 && (unsigned long) group->getProcessCount() > group->options.minProcesses)
 		{
-			ProcessList::iterator prev = p_it;
-			prev--;
+			if (output.capacity() == 0) {
+				output.reserve(group->enabledCount);
+			}
+			output.push_back(process);
+		} else {
+			maybeUpdateNextGcRuntime(state, processGcTime);
+		}
+	}
+
+	void garbageCollectProcessesInGroup(GarbageCollectorState &state,
+		const GroupPtr &group)
+	{
+		ProcessList &processes = group->enabledProcesses;
+		ProcessList processesToGc;
+		ProcessList::iterator p_it, p_end = processes.end();
+
+		for (p_it = processes.begin(); p_it != p_end; p_it++) {
+			const ProcessPtr &process = *p_it;
+			checkWhetherProcessCanBeGarbageCollected(state, group, process,
+				processesToGc);
+		}
+
+		p_end = processesToGc.end();
+		for (p_it = processesToGc.begin(); p_it != p_end; p_it++) {
+			ProcessPtr process = *p_it;
 			P_DEBUG("Garbage collect idle process: " << process->inspect() <<
 				", group=" << group->name);
 			group->detach(process, state.actions);
-			p_it = prev;
-		} else {
-			maybeUpdateNextGcRuntime(state, processGcTime);
 		}
 	}
 
@@ -676,7 +756,7 @@ public:
 	unsigned long long realGarbageCollect() {
 		TRACE_POINT();
 		ScopedLock lock(syncher);
-		SuperGroupMap::iterator it, end = superGroups.end();
+		SuperGroupMap::ConstIterator sg_it(superGroups);
 		GarbageCollectorState state;
 		state.now = SystemTime::getUsec();
 		state.nextGcRunTime = 0;
@@ -685,10 +765,10 @@ public:
 		verifyInvariants();
 
 		// For all supergroups and groups...
-		for (it = superGroups.begin(); it != end; it++) {
-			SuperGroupPtr superGroup = it->second;
-			vector<GroupPtr> &groups = superGroup->groups;
-			vector<GroupPtr>::iterator g_it, g_end = groups.end();
+		while (*sg_it != NULL) {
+			const SuperGroupPtr superGroup = sg_it.getValue();
+			SuperGroup::GroupList &groups = superGroup->groups;
+			SuperGroup::GroupList::iterator g_it, g_end = groups.end();
 
 			superGroup->verifyInvariants();
 
@@ -696,14 +776,8 @@ public:
 				GroupPtr group = *g_it;
 
 				if (maxIdleTime > 0) {
-					ProcessList &processes = group->enabledProcesses;
-					ProcessList::iterator p_it, p_end = processes.end();
-
-					for (p_it = processes.begin(); p_it != p_end; p_it++) {
-						ProcessPtr process = *p_it;
-						// ...detach processes that have been idle for more than maxIdleTime.
-						maybeDetachIdleProcess(state, group, process, p_it);
-					}
+					// ...detach processes that have been idle for more than maxIdleTime.
+					garbageCollectProcessesInGroup(state, group);
 				}
 
 				group->verifyInvariants();
@@ -713,6 +787,7 @@ public:
 			}
 
 			superGroup->verifyInvariants();
+			sg_it.next();
 		}
 
 		verifyInvariants();
@@ -845,11 +920,11 @@ public:
 		{
 			UPDATE_TRACE_POINT();
 			LockGuard l(syncher);
-			SuperGroupMap::const_iterator sg_it, sg_end = superGroups.end();
+			SuperGroupMap::ConstIterator sg_it(superGroups);
 
-			for (sg_it = superGroups.begin(); sg_it != sg_end; sg_it++) {
-				const SuperGroupPtr &superGroup = sg_it->second;
-				vector<GroupPtr>::const_iterator g_it, g_end = superGroup->groups.end();
+			while (*sg_it != NULL) {
+				const SuperGroupPtr &superGroup = sg_it.getValue();
+				SuperGroup::GroupList::const_iterator g_it, g_end = superGroup->groups.end();
 
 				for (g_it = superGroup->groups.begin(); g_it != g_end; g_it++) {
 					const GroupPtr &group = *g_it;
@@ -857,6 +932,7 @@ public:
 					collectPids(group->disablingProcesses, pids);
 					collectPids(group->disabledProcesses, pids);
 				}
+				sg_it.next();
 			}
 		}
 
@@ -882,14 +958,14 @@ public:
 			UPDATE_TRACE_POINT();
 			vector<UnionStationLogEntry> logEntries;
 			vector<ProcessPtr> processesToDetach;
-			vector<Callback> actions;
+			boost::container::vector<Callback> actions;
 			ScopedLock l(syncher);
-			SuperGroupMap::iterator sg_it, sg_end = superGroups.end();
+			SuperGroupMap::ConstIterator sg_it(superGroups);
 
 			UPDATE_TRACE_POINT();
-			for (sg_it = superGroups.begin(); sg_it != sg_end; sg_it++) {
-				const SuperGroupPtr &superGroup = sg_it->second;
-				vector<GroupPtr>::iterator g_it, g_end = superGroup->groups.end();
+			while (*sg_it != NULL) {
+				const SuperGroupPtr &superGroup = sg_it.getValue();
+				SuperGroup::GroupList::iterator g_it, g_end = superGroup->groups.end();
 
 				for (g_it = superGroup->groups.begin(); g_it != g_end; g_it++) {
 					const GroupPtr &group = *g_it;
@@ -900,6 +976,7 @@ public:
 					prepareUnionStationProcessStateLogs(logEntries, group);
 					prepareUnionStationSystemMetricsLogs(logEntries, group);
 				}
+				sg_it.next();
 			}
 
 			UPDATE_TRACE_POINT();
@@ -945,16 +1022,16 @@ public:
 	}
 
 	SuperGroupPtr createSuperGroup(const Options &options) {
-		SuperGroupPtr superGroup = boost::make_shared<SuperGroup>(shared_from_this(),
+		SuperGroupPtr superGroup = boost::make_shared<SuperGroup>(this,
 			options);
 		superGroup->initialize();
-		superGroups.set(options.getAppGroupName(), superGroup);
+		superGroups.insert(options.getAppGroupName(), superGroup);
 		garbageCollectionCond.notify_all();
 		return superGroup;
 	}
 
 	SuperGroupPtr createSuperGroupAndAsyncGetFromIt(const Options &options,
-		const GetCallback &callback, vector<Callback> &postLockActions)
+		const GetCallback &callback, boost::container::vector<Callback> &postLockActions)
 	{
 		SuperGroupPtr superGroup = createSuperGroup(options);
 		SessionPtr session = superGroup->get(options, callback,
@@ -971,8 +1048,12 @@ public:
 	const SuperGroupPtr getSuperGroup(const char *name);
 
 public:
+	AbortLongRunningConnectionsCallback abortLongRunningConnectionsCallback;
+
 	Pool(const SpawnerFactoryPtr &spawnerFactory,
 		const VariantMap *agentsOptions = NULL)
+		: sessionObjectPool(64, 1024),
+		  abortLongRunningConnectionsCallback(NULL)
 	{
 		this->spawnerFactory = spawnerFactory;
 		this->agentsOptions = agentsOptions;
@@ -983,9 +1064,11 @@ public:
 			P_WARN("Unable to collect system metrics: " << e.what());
 		}
 
-		lifeStatus  = ALIVE;
-		max         = 6;
-		maxIdleTime = 60 * 1000000;
+		lifeStatus   = ALIVE;
+		max          = 6;
+		maxIdleTime  = 60 * 1000000;
+		selfchecking = true;
+		palloc       = psg_create_pool(PSG_DEFAULT_POOL_SIZE);
 
 		// The following code only serve to instantiate certain inline methods
 		// so that they can be invoked from gdb.
@@ -999,6 +1082,7 @@ public:
 		if (lifeStatus != SHUT_DOWN) {
 			P_BUG("You must call Pool::destroy() before actually destroying the Pool object!");
 		}
+		psg_destroy_pool(palloc);
 	}
 
 	/** Must be called right after construction. */
@@ -1021,7 +1105,7 @@ public:
 		debugSupport = boost::make_shared<DebugSupport>();
 	}
 
-	/** Should be called right after the HelperAgent has received
+	/** Should be called right after the agent has received
 	 * the message to exit gracefully. This will tell processes to
 	 * abort any long-running connections, e.g. WebSocket connections,
 	 * because the RequestHandler has to wait until all connections are
@@ -1032,11 +1116,12 @@ public:
 		ScopedLock lock(syncher);
 		assert(lifeStatus == ALIVE);
 		lifeStatus = PREPARED_FOR_SHUTDOWN;
-		vector<ProcessPtr> processes = getProcesses(false);
-		foreach (ProcessPtr process, processes) {
-			if (process->abortLongRunningConnections()) {
+		if (abortLongRunningConnectionsCallback != NULL) {
+			vector<ProcessPtr> processes = getProcesses(false);
+			foreach (ProcessPtr process, processes) {
 				// Ensure that the process is not immediately respawned.
 				process->getGroup()->options.minProcesses = 0;
+				abortLongRunningConnectionsCallback(process);
 			}
 		}
 	}
@@ -1050,7 +1135,9 @@ public:
 		lifeStatus = SHUTTING_DOWN;
 
 		while (!superGroups.empty()) {
-			string name = superGroups.begin()->second->name;
+			SuperGroupPtr *superGroup;
+			superGroups.lookupRandom(NULL, &superGroup);
+			string name = superGroup->get()->name;
 			lock.unlock();
 			detachSuperGroupByName(name);
 			lock.lock();
@@ -1077,7 +1164,7 @@ public:
 		assert(lifeStatus == ALIVE || lifeStatus == PREPARED_FOR_SHUTDOWN);
 		verifyInvariants();
 		P_TRACE(2, "asyncGet(appGroupName=" << options.getAppGroupName() << ")");
-		vector<Callback> actions;
+		boost::container::vector<Callback> actions;
 
 		SuperGroup *existingSuperGroup = findMatchingSuperGroup(options);
 		if (OXT_LIKELY(existingSuperGroup != NULL)) {
@@ -1095,7 +1182,7 @@ public:
 				callback(session, ExceptionPtr());
 			}
 
-		} else if (!atFullCapacity(false)) {
+		} else if (!atFullCapacityUnlocked()) {
 			/* The app super group isn't in the pool and we have enough free
 			 * resources to make a new one.
 			 */
@@ -1130,9 +1217,9 @@ public:
 				 */
 				P_DEBUG("Creating new SuperGroup");
 				SuperGroupPtr superGroup;
-				superGroup = boost::make_shared<SuperGroup>(shared_from_this(), options);
+				superGroup = boost::make_shared<SuperGroup>(this, options);
 				superGroup->initialize();
-				superGroups.set(options.getAppGroupName(), superGroup);
+				superGroups.insert(options.getAppGroupName(), superGroup);
 				garbageCollectionCond.notify_all();
 				SessionPtr session = superGroup->get(options, callback,
 					actions);
@@ -1146,7 +1233,7 @@ public:
 				superGroup->verifyInvariants();
 			}
 
-			assert(atFullCapacity(false));
+			assert(atFullCapacityUnlocked());
 			verifyInvariants();
 			verifyExpensiveInvariants();
 			P_TRACE(2, "asyncGet() finished");
@@ -1172,7 +1259,10 @@ public:
 		ticket->session.reset();
 		ticket->exception.reset();
 
-		asyncGet(options, boost::bind(syncGetCallback, ticket, _1, _2));
+		GetCallback callback;
+		callback.func = syncGetCallback;
+		callback.userData = ticket;
+		asyncGet(options, callback);
 
 		ScopedLock lock(ticket->syncher);
 		while (ticket->session == NULL && ticket->exception == NULL) {
@@ -1197,13 +1287,14 @@ public:
 		Ticket ticket;
 		{
 			LockGuard l(syncher);
-			if (superGroups.get(options.getAppGroupName()) == NULL) {
+			SuperGroupPtr *superGroup;
+			if (!superGroups.lookup(options.getAppGroupName(), &superGroup)) {
 				// Forcefully create SuperGroup, don't care whether resource limits
 				// actually allow it.
 				createSuperGroup(options);
 			}
 		}
-		return get(options2, &ticket)->getGroup();
+		return get(options2, &ticket)->getGroup()->shared_from_this();
 	}
 
 	void setMax(unsigned int max) {
@@ -1222,7 +1313,7 @@ public:
 			 * resources to eventually complete. Favoring waiters
 			 * on the pool should be fairer.
 			 */
-			vector<Callback> actions;
+			boost::container::vector<Callback> actions;
 			assignSessionsToGetWaiters(actions);
 			possiblySpawnMoreProcessesForExistingGroups();
 
@@ -1240,30 +1331,29 @@ public:
 		garbageCollectionCond.notify_all();
 	}
 
-	unsigned int capacityUsed(bool lock = true) const {
-		DynamicScopedLock l(syncher, lock);
-		SuperGroupMap::const_iterator it, end = superGroups.end();
-		int result = 0;
-		for (it = superGroups.begin(); it != end; it++) {
-			const SuperGroupPtr &superGroup = it->second;
-			result += superGroup->capacityUsed();
-		}
-		return result;
+	void enableSelfChecking(bool enabled) {
+		LockGuard l(syncher);
+		selfchecking = enabled;
 	}
 
-	bool atFullCapacity(bool lock = true) const {
-		DynamicScopedLock l(syncher, lock);
-		return capacityUsed(false) >= max;
+	unsigned int capacityUsed() const {
+		LockGuard l(syncher);
+		return capacityUsedUnlocked();
+	}
+
+	bool atFullCapacity() const {
+		LockGuard l(syncher);
+		return atFullCapacityUnlocked();
 	}
 
 	vector<ProcessPtr> getProcesses(bool lock = true) const {
 		DynamicScopedLock l(syncher, lock);
 		vector<ProcessPtr> result;
-		SuperGroupMap::const_iterator it, end = superGroups.end();
-		for (it = superGroups.begin(); OXT_LIKELY(it != end); it++) {
-			const SuperGroupPtr &superGroup = it->second;
-			vector<GroupPtr> &groups = superGroup->groups;
-			vector<GroupPtr>::const_iterator g_it, g_end = groups.end();
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
+			SuperGroup::GroupList &groups = superGroup->groups;
+			SuperGroup::GroupList::const_iterator g_it, g_end = groups.end();
 			for (g_it = groups.begin(); g_it != g_end; g_it++) {
 				const GroupPtr &group = *g_it;
 				ProcessList::const_iterator p_it;
@@ -1278,6 +1368,7 @@ public:
 					result.push_back(*p_it);
 				}
 			}
+			sg_it.next();
 		}
 		return result;
 	}
@@ -1290,10 +1381,11 @@ public:
 	unsigned int getProcessCount(bool lock = true) const {
 		DynamicScopedLock l(syncher, lock);
 		unsigned int result = 0;
-		SuperGroupMap::const_iterator it, end = superGroups.end();
-		for (it = superGroups.begin(); OXT_LIKELY(it != end); it++) {
-			const SuperGroupPtr &superGroup = it->second;
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
 			result += superGroup->getProcessCount();
+			sg_it.next();
 		}
 		return result;
 	}
@@ -1305,22 +1397,23 @@ public:
 
 	SuperGroupPtr findSuperGroupBySecret(const string &secret, bool lock = true) const {
 		DynamicScopedLock l(syncher, lock);
-		SuperGroupMap::const_iterator it, end = superGroups.end();
-		for (it = superGroups.begin(); OXT_LIKELY(it != end); it++) {
-			const SuperGroupPtr &superGroup = it->second;
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
 			if (superGroup->secret == secret) {
 				return superGroup;
 			}
+			sg_it.next();
 		}
 		return SuperGroupPtr();
 	}
 
-	ProcessPtr findProcessByGupid(const string &gupid, bool lock = true) const {
+	ProcessPtr findProcessByGupid(const StaticString &gupid, bool lock = true) const {
 		vector<ProcessPtr> processes = getProcesses(lock);
 		vector<ProcessPtr>::const_iterator it, end = processes.end();
 		for (it = processes.begin(); it != end; it++) {
 			const ProcessPtr &process = *it;
-			if (process->gupid == gupid) {
+			if (StaticString(process->gupid, process->gupidSize) == gupid) {
 				return process;
 			}
 		}
@@ -1342,54 +1435,51 @@ public:
 	bool detachSuperGroupByName(const string &name) {
 		TRACE_POINT();
 		ScopedLock l(syncher);
+		SuperGroupPtr superGroup = superGroups.lookupCopy(name);
 
-		SuperGroupPtr superGroup = superGroups.get(name);
 		if (OXT_LIKELY(superGroup != NULL)) {
-			if (OXT_LIKELY(superGroups.get(superGroup->name) != NULL)) {
-				UPDATE_TRACE_POINT();
-				verifyInvariants();
-				verifyExpensiveInvariants();
-
-				vector<Callback> actions;
-				boost::shared_ptr<DetachSuperGroupWaitTicket> ticket =
-					boost::make_shared<DetachSuperGroupWaitTicket>();
-				ExceptionPtr exception = copyException(
-					GetAbortedException("The containing SuperGroup was detached."));
-
-				forceDetachSuperGroup(superGroup, actions,
-					boost::bind(syncDetachSuperGroupCallback, _1, ticket));
-				assignExceptionToGetWaiters(superGroup->getWaitlist,
-					exception, actions);
-				#if 0
-				/* If this SuperGroup had get waiters, either
-				 * on itself or in one of its groups, then we must
-				 * reprocess them immediately. Detaching such a
-				 * SuperGroup is essentially the same as restarting it.
-				 */
-				migrateSuperGroupGetWaitlistToPool(superGroup);
+			P_ASSERT_EQ(superGroup->name, name);
+			UPDATE_TRACE_POINT();
+			verifyInvariants();
+			verifyExpensiveInvariants();
 
-				UPDATE_TRACE_POINT();
-				assignSessionsToGetWaiters(actions);
-				#endif
-				possiblySpawnMoreProcessesForExistingGroups();
+			boost::container::vector<Callback> actions;
+			boost::shared_ptr<DetachSuperGroupWaitTicket> ticket =
+				boost::make_shared<DetachSuperGroupWaitTicket>();
+			ExceptionPtr exception = copyException(
+				GetAbortedException("The containing SuperGroup was detached."));
+
+			forceDetachSuperGroup(superGroup, actions,
+				boost::bind(syncDetachSuperGroupCallback, _1, ticket));
+			assignExceptionToGetWaiters(superGroup->getWaitlist,
+				exception, actions);
+			#if 0
+			/* If this SuperGroup had get waiters, either
+			 * on itself or in one of its groups, then we must
+			 * reprocess them immediately. Detaching such a
+			 * SuperGroup is essentially the same as restarting it.
+			 */
+			migrateSuperGroupGetWaitlistToPool(superGroup);
 
-				verifyInvariants();
-				verifyExpensiveInvariants();
+			UPDATE_TRACE_POINT();
+			assignSessionsToGetWaiters(actions);
+			#endif
+			possiblySpawnMoreProcessesForExistingGroups();
 
-				l.unlock();
-				UPDATE_TRACE_POINT();
-				runAllActions(actions);
-				actions.clear();
+			verifyInvariants();
+			verifyExpensiveInvariants();
 
-				UPDATE_TRACE_POINT();
-				ScopedLock l2(ticket->syncher);
-				while (!ticket->done) {
-					ticket->cond.wait(l2);
-				}
-				return ticket->result == SuperGroup::SUCCESS;
-			} else {
-				return false;
+			l.unlock();
+			UPDATE_TRACE_POINT();
+			runAllActions(actions);
+			actions.clear();
+
+			UPDATE_TRACE_POINT();
+			ScopedLock l2(ticket->syncher);
+			while (!ticket->done) {
+				ticket->cond.wait(l2);
 			}
+			return ticket->result == SuperGroup::SUCCESS;
 		} else {
 			return false;
 		}
@@ -1410,7 +1500,7 @@ public:
 
 	bool detachProcess(const ProcessPtr &process) {
 		ScopedLock l(syncher);
-		vector<Callback> actions;
+		boost::container::vector<Callback> actions;
 		bool result = detachProcessUnlocked(process, actions);
 		fullVerifyInvariants();
 		l.unlock();
@@ -1422,7 +1512,7 @@ public:
 		ScopedLock l(syncher);
 		ProcessPtr process = findProcessByPid(pid, false);
 		if (process != NULL) {
-			vector<Callback> actions;
+			boost::container::vector<Callback> actions;
 			bool result = detachProcessUnlocked(process, actions);
 			fullVerifyInvariants();
 			l.unlock();
@@ -1437,7 +1527,7 @@ public:
 		ScopedLock l(syncher);
 		ProcessPtr process = findProcessByGupid(gupid, false);
 		if (process != NULL) {
-			vector<Callback> actions;
+			boost::container::vector<Callback> actions;
 			bool result = detachProcessUnlocked(process, actions);
 			fullVerifyInvariants();
 			l.unlock();
@@ -1448,11 +1538,11 @@ public:
 		}
 	}
 
-	DisableResult disableProcess(const string &gupid) {
+	DisableResult disableProcess(const StaticString &gupid) {
 		ScopedLock l(syncher);
 		ProcessPtr process = findProcessByGupid(gupid, false);
 		if (process != NULL) {
-			GroupPtr group = process->getGroup();
+			Group *group = process->getGroup();
 			// Must be a boost::shared_ptr to be interruption-safe.
 			boost::shared_ptr<DisableWaitTicket> ticket = boost::make_shared<DisableWaitTicket>();
 			DisableResult result = group->disable(process,
@@ -1476,10 +1566,9 @@ public:
 
 	bool restartGroupByName(const StaticString &name, RestartMethod method = RM_DEFAULT) {
 		ScopedLock l(syncher);
-		SuperGroupMap::iterator sg_it, sg_end = superGroups.end();
-
-		for (sg_it = superGroups.begin(); sg_it != sg_end; sg_it++) {
-			const SuperGroupPtr &superGroup = sg_it->second;
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
 			foreach (const GroupPtr &group, superGroup->groups) {
 				if (name == group->name) {
 					if (!group->restarting()) {
@@ -1488,6 +1577,7 @@ public:
 					return true;
 				}
 			}
+			sg_it.next();
 		}
 
 		return false;
@@ -1495,15 +1585,16 @@ public:
 
 	unsigned int restartSuperGroupsByAppRoot(const StaticString &appRoot) {
 		ScopedLock l(syncher);
-		SuperGroupMap::iterator sg_it, sg_end = superGroups.end();
+		SuperGroupMap::ConstIterator sg_it(superGroups);
 		unsigned int result = 0;
 
-		for (sg_it = superGroups.begin(); sg_it != sg_end; sg_it++) {
-			const SuperGroupPtr &superGroup = sg_it->second;
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
 			if (appRoot == superGroup->options.appRoot) {
 				result++;
 				superGroup->restart(superGroup->options);
 			}
+			sg_it.next();
 		}
 
 		return result;
@@ -1514,13 +1605,15 @@ public:
 	 */
 	bool isSpawning(bool lock = true) const {
 		DynamicScopedLock l(syncher, lock);
-		SuperGroupMap::const_iterator it, end = superGroups.end();
-		for (it = superGroups.begin(); it != end; it++) {
-			foreach (GroupPtr group, it->second->groups) {
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
+			foreach (GroupPtr group, superGroup->groups) {
 				if (group->spawning()) {
 					return true;
 				}
 			}
+			sg_it.next();
 		}
 		return false;
 	}
@@ -1545,9 +1638,9 @@ public:
 		result << endl;
 
 		result << headerColor << "----------- Application groups -----------" << resetColor << endl;
-		SuperGroupMap::const_iterator sg_it, sg_end = superGroups.end();
-		for (sg_it = superGroups.begin(); sg_it != sg_end; sg_it++) {
-			const SuperGroupPtr &superGroup = sg_it->second;
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
 			const Group *group = superGroup->defaultGroup;
 			ProcessList::const_iterator p_it;
 
@@ -1573,6 +1666,7 @@ public:
 				inspectProcessList(options, result, group, group->detachedProcesses);
 				result << endl;
 			}
+			sg_it.next();
 		}
 		return result.str();
 	}
@@ -1580,8 +1674,8 @@ public:
 	string toXml(bool includeSecrets = true, bool lock = true) const {
 		DynamicScopedLock l(syncher, lock);
 		stringstream result;
-		SuperGroupMap::const_iterator sg_it;
-		vector<GroupPtr>::const_iterator g_it;
+		SuperGroupMap::ConstIterator sg_it(superGroups);
+		SuperGroup::GroupList::const_iterator g_it;
 		ProcessList::const_iterator p_it;
 
 		result << "<?xml version=\"1.0\" encoding=\"iso8859-1\" ?>\n";
@@ -1590,7 +1684,7 @@ public:
 		result << "<passenger_version>" << PASSENGER_VERSION << "</passenger_version>";
 		result << "<process_count>" << getProcessCount(false) << "</process_count>";
 		result << "<max>" << max << "</max>";
-		result << "<capacity_used>" << capacityUsed(false) << "</capacity_used>";
+		result << "<capacity_used>" << capacityUsedUnlocked() << "</capacity_used>";
 		result << "<get_wait_list_size>" << getWaitlist.size() << "</get_wait_list_size>";
 
 		if (includeSecrets) {
@@ -1607,8 +1701,8 @@ public:
 		}
 
 		result << "<supergroups>";
-		for (sg_it = superGroups.begin(); sg_it != superGroups.end(); sg_it++) {
-			const SuperGroupPtr &superGroup = sg_it->second;
+		while (*sg_it != NULL) {
+			const SuperGroupPtr &superGroup = sg_it.getValue();
 
 			result << "<supergroup>";
 			result << "<name>" << escapeForXml(superGroup->name) << "</name>";
@@ -1631,6 +1725,8 @@ public:
 				result << "</group>";
 			}
 			result << "</supergroup>";
+
+			sg_it.next();
 		}
 		result << "</supergroups>";