passenger 4.0.60 → 5.0.0.beta1

data/ext/common/ApplicationPool2/Common.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-2013 Phusion
+ *  Copyright (c) 2011-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -27,14 +27,17 @@
 
 #include <boost/thread.hpp>
 #include <boost/shared_ptr.hpp>
+#include <boost/intrusive_ptr.hpp>
 #include <boost/function.hpp>
 #include <oxt/tracable_exception.hpp>
 #include <ResourceLocator.h>
 #include <RandomGenerator.h>
+#include <StaticString.h>
+#include <MemoryKit/palloc.h>
+#include <DataStructures/StringKeyTable.h>
 #include <UnionStation/Core.h>
 #include <UnionStation/Transaction.h>
 #include <ApplicationPool2/Options.h>
-#include <Utils/StringMap.h>
 #include <Utils/VariantMap.h>
 
 namespace tut {
@@ -52,6 +55,7 @@ class Pool;
 class SuperGroup;
 class Group;
 class Process;
+class Socket;
 class Session;
 
 /**
@@ -160,13 +164,25 @@ typedef boost::shared_ptr<Pool> PoolPtr;
 typedef boost::shared_ptr<SuperGroup> SuperGroupPtr;
 typedef boost::shared_ptr<Group> GroupPtr;
 typedef boost::shared_ptr<Process> ProcessPtr;
-typedef boost::shared_ptr<Session> SessionPtr;
+typedef boost::intrusive_ptr<Session> SessionPtr;
 typedef boost::shared_ptr<tracable_exception> ExceptionPtr;
-typedef StringMap<SuperGroupPtr> SuperGroupMap;
-typedef boost::function<void (const SessionPtr &session, const ExceptionPtr &e)> GetCallback;
+typedef StringKeyTable<SuperGroupPtr> SuperGroupMap;
 typedef boost::function<void (const ProcessPtr &process, DisableResult result)> DisableCallback;
 typedef boost::function<void ()> Callback;
 
+struct GetCallback {
+	void (*func)(const SessionPtr &session, const ExceptionPtr &e, void *userData);
+	mutable void *userData;
+
+	void operator()(const SessionPtr &session, const ExceptionPtr &e) const {
+		func(session, e, userData);
+	}
+
+	static void call(GetCallback cb, const SessionPtr &session, const ExceptionPtr &e) {
+		cb(session, e);
+	}
+};
+
 struct GetWaiter {
 	Options options;
 	GetCallback callback;
@@ -188,36 +204,36 @@ struct Ticket {
 
 struct SpawnerConfig {
 	// Used by error pages and hooks.
-	ResourceLocator resourceLocator;
+	ResourceLocator *resourceLocator;
 	const VariantMap *agentsOptions;
 
 	// Used for Union Station logging.
 	UnionStation::CorePtr unionStationCore;
 
 	// Used by SmartSpawner and DirectSpawner.
-	/** A random generator to use. */
 	RandomGeneratorPtr randomGenerator;
+	string instanceDir;
 
 	// Used by DummySpawner and SpawnerFactory.
 	unsigned int concurrency;
 	unsigned int spawnerCreationSleepTime;
 	unsigned int spawnTime;
 
-	SpawnerConfig(const ResourceLocator &_resourceLocator,
-		const UnionStation::CorePtr &_unionStationCore = UnionStation::CorePtr(),
-		const RandomGeneratorPtr &randomGenerator = RandomGeneratorPtr(),
-		const VariantMap *_agentsOptions = NULL)
-		: resourceLocator(_resourceLocator),
-		  agentsOptions(_agentsOptions),
-		  unionStationCore(_unionStationCore),
+	SpawnerConfig()
+		: resourceLocator(NULL),
+		  agentsOptions(NULL),
 		  concurrency(1),
 		  spawnerCreationSleepTime(0),
 		  spawnTime(0)
-	{
-		if (randomGenerator != NULL) {
-			this->randomGenerator = randomGenerator;
-		} else {
-			this->randomGenerator = boost::make_shared<RandomGenerator>();
+		{ }
+
+	void finalize() {
+		TRACE_POINT();
+		if (resourceLocator == NULL) {
+			throw RuntimeException("ResourceLocator not initialized");
+		}
+		if (randomGenerator == NULL) {
+			randomGenerator = boost::make_shared<RandomGenerator>();
 		}
 	}
 };
@@ -228,6 +244,7 @@ ExceptionPtr copyException(const tracable_exception &e);
 void rethrowException(const ExceptionPtr &e);
 void processAndLogNewSpawnException(SpawnException &e, const Options &options,
 	const SpawnerConfigPtr &config);
+void recreateString(psg_pool_t *pool, StaticString &str);
 
 } // namespace ApplicationPool2
 } // namespace Passenger

data/ext/common/ApplicationPool2/DirectSpawner.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-2013 Phusion
+ *  Copyright (c) 2011-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -26,6 +26,7 @@
 #define _PASSENGER_APPLICATION_POOL2_DIRECT_SPAWNER_H_
 
 #include <ApplicationPool2/Spawner.h>
+#include <Constants.h>
 #include <limits.h>  // for PTHREAD_STACK_MIN
 #include <pthread.h>
 
@@ -111,10 +112,10 @@ private:
 		shared_array<const char *> &args) const
 	{
 		vector<string> startCommandArgs;
-		string agentsDir = config->resourceLocator.getAgentsDir();
+		string agentFilename = config->resourceLocator->findSupportBinary(AGENT_EXE);
 		vector<string> command;
 
-		split(options.getStartCommand(config->resourceLocator), '\t', startCommandArgs);
+		split(options.getStartCommand(*config->resourceLocator), '\t', startCommandArgs);
 		if (startCommandArgs.empty()) {
 			throw RuntimeException("No startCommand given");
 		}
@@ -126,9 +127,10 @@ private:
 			command.push_back("exec \"$@\"");
 			command.push_back("SpawnPreparerShell");
 		} else {
-			command.push_back(agentsDir + "/SpawnPreparer");
+			command.push_back(agentFilename);
 		}
-		command.push_back(agentsDir + "/SpawnPreparer");
+		command.push_back(agentFilename);
+		command.push_back("spawn-preparer");
 		command.push_back(preparation.appRoot);
 		command.push_back(serializeEnvvarsFromPoolOptions(options));
 		command.push_back(startCommandArgs[0]);
@@ -144,14 +146,11 @@ private:
 	}
 
 public:
-	DirectSpawner(const ServerInstanceDir::GenerationPtr &_generation,
-		const SpawnerConfigPtr &_config)
+	DirectSpawner(const SpawnerConfigPtr &_config)
 		: Spawner(_config)
-	{
-		generation = _generation;
-	}
+		{ }
 
-	virtual ProcessPtr spawn(const Options &options) {
+	virtual SpawnObject spawn(const Options &options) {
 		TRACE_POINT();
 		this_thread::disable_interruption di;
 		this_thread::disable_syscall_interruption dsi;
@@ -222,17 +221,17 @@ public:
 			details.options = &options;
 			details.debugDir = debugDir;
 
-			ProcessPtr process;
+			SpawnObject object;
 			{
 				this_thread::restore_interruption ri(di);
 				this_thread::restore_syscall_interruption rsi(dsi);
-				process = negotiateSpawn(details);
+				object = negotiateSpawn(details);
 			}
-			detachProcess(process->pid);
+			detachProcess(object.process->pid);
 			guard.clear();
 			P_DEBUG("Process spawning done: appRoot=" << options.appRoot <<
-				", pid=" << process->pid);
-			return process;
+				", pid=" << object.process->pid);
+			return boost::move(object);
 		}
 	}
 };

data/ext/common/ApplicationPool2/DummySpawner.h

@@ -50,24 +50,25 @@ public:
 		cleanCount = 0;
 	}
 
-	virtual ProcessPtr spawn(const Options &options) {
+	virtual SpawnObject spawn(const Options &options) {
 		TRACE_POINT();
 		possiblyRaiseInternalError(options);
 
 		SocketPair adminSocket = createUnixSocketPair();
-		SocketListPtr sockets = boost::make_shared<SocketList>();
-		sockets->add("main", "tcp://127.0.0.1:1234", "session", config->concurrency);
+		SocketList sockets;
+		sockets.add("main", "tcp://127.0.0.1:1234", "session", config->concurrency);
 		syscalls::usleep(config->spawnTime);
 
 		boost::lock_guard<boost::mutex> l(lock);
 		count++;
-		ProcessPtr process = boost::make_shared<Process>(
-			(pid_t) count, "gupid-" + toString(count),
-			toString(count),
+		SpawnObject object;
+		string gupid = "gupid-" + toString(count);
+		object.process = boost::make_shared<Process>(
+			(pid_t) count, gupid,
 			adminSocket.second, FileDescriptor(), sockets,
 			SystemTime::getUsec(), SystemTime::getUsec());
-		process->dummy = true;
-		return process;
+		object.process->dummy = true;
+		return boost::move(object);
 	}
 
 	virtual bool cleanable() const {

data/ext/common/ApplicationPool2/ErrorRenderer.h

@@ -74,7 +74,7 @@ public:
 		params.set("ENVIRONMENT", options.environment);
 		params.set("MESSAGE", message);
 		params.set("IS_RUBY_APP",
-			(options.appType == "classic-rails" || options.appType == "rack")
+			(options.appType == "rack")
 			? "true" : "false");
 		if (e != NULL) {
 			params.set("TITLE", "Web application could not be started");

data/ext/common/ApplicationPool2/Group.h

@@ -34,9 +34,12 @@
 #include <boost/foreach.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/atomic.hpp>
 #include <oxt/macros.hpp>
 #include <oxt/thread.hpp>
 #include <oxt/dynamic_thread_group.hpp>
+#include <sys/stat.h>
 #include <cstdlib>
 #include <cassert>
 #include <ApplicationPool2/Common.h>
@@ -44,10 +47,9 @@
 #include <ApplicationPool2/SpawnerFactory.h>
 #include <ApplicationPool2/Process.h>
 #include <ApplicationPool2/Options.h>
+#include <MemoryKit/palloc.h>
 #include <Hooks.h>
 #include <Utils.h>
-#include <Utils/CachedFileStat.hpp>
-#include <Utils/FileChangeChecker.h>
 #include <Utils/SmallVector.h>
 
 namespace Passenger {
@@ -93,22 +95,6 @@ public:
 			{ }
 	};
 
-	/**
-	 * Protects `lifeStatus`.
-	 */
-	mutable boost::mutex lifetimeSyncher;
-	/**
-	 * A Group object progresses through a life.
-	 *
-	 * Do not access directly, always use `isAlive()`/`getLifeStatus()` or
-	 * through `lifetimeSyncher`.
-	 *
-	 * Invariant:
-	 *    if lifeStatus != ALIVE:
-	 *       enabledCount == 0
-	 *       disablingCount == 0
-	 *       disabledCount == 0
-	 */
 	enum LifeStatus {
 		/** Up and operational. */
 		ALIVE,
@@ -124,7 +110,7 @@ public:
 		 * from this Group anymore.
 		 */
 		SHUT_DOWN
-	} lifeStatus;
+	};
 
 	/**
 	 * A back reference to the containing SuperGroup. Should never
@@ -132,11 +118,9 @@ public:
 	 * Groups.
 	 * Read-only; only set during initialization.
 	 */
-	boost::weak_ptr<SuperGroup> superGroup;
-	CachedFileStat cstat;
-	FileChangeChecker fileChangeChecker;
-	string restartFile;
-	string alwaysRestartFile;
+	SuperGroup *superGroup;
+	time_t lastRestartFileMtime;
+	time_t lastRestartFileCheckTime;
 
 	/** Number of times a restart has been initiated so far. This is incremented immediately
 	 * in Group::restart(), and is used to abort the restarter thread that was active at the
@@ -150,6 +134,19 @@ public:
 	 *     if processesBeingSpawned > 0: m_spawning
 	 */
 	short processesBeingSpawned;
+	/**
+	 * A Group object progresses through a life.
+	 *
+	 * You should not access this directly. You should use `isAlive()`/`getLifeStatus()`.
+	 *
+	 * Invariant:
+	 *    if lifeStatus != ALIVE:
+	 *       enabledCount == 0
+	 *       disablingCount == 0
+	 *       disabledCount == 0
+	 *       nEnabledProcessesTotallyBusy == 0
+	 */
+	boost::atomic<boost::uint8_t> lifeStatus;
 	/**
 	 * Whether the spawner thread is currently working. Note that even
 	 * if it's working, it doesn't necessarily mean that processes are
@@ -158,7 +155,7 @@ public:
 	 * the newly-spawned process to the group. During that time it's not
 	 * technically spawning anything.
 	 */
-	bool m_spawning;
+	bool m_spawning: 1;
 	/** Whether a non-rolling restart is in progress (i.e. whether spawnThreadRealMain()
 	 * is at work). While it is in progress, it is not possible to signal the desire to
 	 * spawn new process. If spawning was already in progress when the restart was initiated,
@@ -169,11 +166,16 @@ public:
 	 * Invariant:
 	 *    if m_restarting: processesBeingSpawned == 0
 	 */
-	bool m_restarting;
+	bool m_restarting: 1;
+	bool alwaysRestartFileExists: 1;
 
 	/** Contains the spawn loop thread and the restarter thread. */
 	dynamic_thread_group interruptableThreads;
 
+	string restartFile;
+	string alwaysRestartFile;
+	ProcessPtr nullProcess;
+
 	/** This timer scans `detachedProcesses` periodically to see
 	 * whether any of the Processes can be shut down.
 	 */
@@ -183,28 +185,18 @@ public:
 	GroupPtr selfPointer;
 
 
-	static void _onSessionInitiateFailure(Session *session) {
-		ProcessPtr process = session->getProcess();
-		assert(process != NULL);
-		process->getGroup()->onSessionInitiateFailure(process, session);
-	}
-
-	static void _onSessionClose(Session *session) {
-		ProcessPtr process = session->getProcess();
-		assert(process != NULL);
-		process->getGroup()->onSessionClose(process, session);
-	}
-
-	static string generateSecret(const SuperGroupPtr &superGroup);
-	static string generateUuid(const SuperGroupPtr &superGroup);
-	void onSessionInitiateFailure(const ProcessPtr &process, Session *session);
-	void onSessionClose(const ProcessPtr &process, Session *session);
+	static void generateSecret(const SuperGroup *superGroup, char *secret);
+	static string generateUuid(const SuperGroup *superGroup);
+	static void _onSessionInitiateFailure(Session *session);
+	static void _onSessionClose(Session *session);
+	OXT_FORCE_INLINE void onSessionInitiateFailure(Process *process, Session *session);
+	OXT_FORCE_INLINE void onSessionClose(Process *process, Session *session);
 
 	/** Returns whether it is allowed to perform a new OOBW in this group. */
 	bool oobwAllowed() const;
 	/** Returns whether a new OOBW should be initiated for this process. */
-	bool shouldInitiateOobw(const ProcessPtr &process) const;
-	void maybeInitiateOobw(const ProcessPtr &process);
+	bool shouldInitiateOobw(Process *process) const;
+	void maybeInitiateOobw(Process *process);
 	void lockAndMaybeInitiateOobw(const ProcessPtr &process, DisableResult result, GroupPtr self);
 	void initiateOobw(const ProcessPtr &process);
 	void spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process);
@@ -214,17 +206,20 @@ public:
 		unsigned int restartsInitiated);
 	void spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options,
 		unsigned int restartsInitiated);
-	void finalizeRestart(GroupPtr self, Options oldOptions, Options newOptions,
-		RestartMethod method, SpawnerFactoryPtr spawnerFactory,
-		unsigned int restartsInitiated, vector<Callback> postLockActions);
+	void finalizeRestart(GroupPtr self, Options options, RestartMethod method,
+		SpawnerFactoryPtr spawnerFactory, unsigned int restartsInitiated,
+		boost::container::vector<Callback> postLockActions);
 	void startCheckingDetachedProcesses(bool immediately);
 	void detachedProcessesCheckerMain(GroupPtr self);
 	void wakeUpGarbageCollector();
+	bool selfCheckingEnabled() const;
 	bool poolAtFullCapacity() const;
 	bool anotherGroupIsWaitingForCapacity() const;
-	boost::shared_ptr<Group> findOtherGroupWaitingForCapacity() const;
-	ProcessPtr poolForceFreeCapacity(const Group *exclude, vector<Callback> &postLockActions);
+	Group *findOtherGroupWaitingForCapacity() const;
+	ProcessPtr poolForceFreeCapacity(const Group *exclude, boost::container::vector<Callback> &postLockActions);
 	bool testOverflowRequestQueue() const;
+	void callAbortLongRunningConnectionsCallback(const ProcessPtr &process);
+	psg_pool_t *getPallocPool() const;
 	const ResourceLocator &getResourceLocator() const;
 	void runAttachHooks(const ProcessPtr process) const;
 	void runDetachHooks(const ProcessPtr process) const;
@@ -232,11 +227,17 @@ public:
 
 	void verifyInvariants() const {
 		// !a || b: logical equivalent of a IMPLIES b.
+		#ifndef NDEBUG
+		if (!selfCheckingEnabled()) {
+			return;
+		}
+
+		LifeStatus lifeStatus = (LifeStatus) this->lifeStatus.load(boost::memory_order_relaxed);
 
 		assert(enabledCount >= 0);
 		assert(disablingCount >= 0);
 		assert(disabledCount >= 0);
-		assert(enabledProcesses.empty() == (pqueue.top() == NULL));
+		assert(nEnabledProcessesTotallyBusy >= 0);
 		assert(!( enabledCount == 0 && disablingCount > 0 ) || ( processesBeingSpawned > 0) );
 		assert(!( !m_spawning ) || ( enabledCount > 0 || disablingCount == 0 ));
 
@@ -255,19 +256,28 @@ public:
 		assert(!( m_restarting ) || ( processesBeingSpawned == 0 ));
 
 		// Verify lifeStatus.
-		LifeStatus lifeStatus = getLifeStatus();
-		assert(!( lifeStatus != ALIVE ) || ( enabledCount == 0 ));
-		assert(!( lifeStatus != ALIVE ) || ( disablingCount == 0 ));
-		assert(!( lifeStatus != ALIVE ) || ( disabledCount == 0 ));
+		if (lifeStatus != ALIVE) {
+			assert(enabledCount == 0);
+			assert(disablingCount == 0);
+			assert(disabledCount == 0);
+			assert(nEnabledProcessesTotallyBusy == 0);
+		}
+
+		// Verify list sizes.
+		assert((int) enabledProcesses.size() == enabledCount);
+		assert((int) disablingProcesses.size() == disablingCount);
+		assert((int) disabledProcesses.size() == disabledCount);
+		assert(nEnabledProcessesTotallyBusy <= enabledCount);
+		#endif
 	}
 
 	void verifyExpensiveInvariants() const {
 		#ifndef NDEBUG
 		// !a || b: logical equivalent of a IMPLIES b.
 
-		assert((int) enabledProcesses.size() == enabledCount);
-		assert((int) disablingProcesses.size() == disablingCount);
-		assert((int) disabledProcesses.size() == disabledCount);
+		if (!selfCheckingEnabled()) {
+			return;
+		}
 
 		ProcessList::const_iterator it, end;
 
@@ -275,7 +285,6 @@ public:
 		for (it = enabledProcesses.begin(); it != end; it++) {
 			const ProcessPtr &process = *it;
 			assert(process->enabled == Process::ENABLED);
-			assert(process->pqHandle != NULL);
 			assert(process->isAlive());
 			assert(process->oobwStatus == Process::OOBW_NOT_ACTIVE
 				|| process->oobwStatus == Process::OOBW_REQUESTED);
@@ -285,7 +294,6 @@ public:
 		for (it = disablingProcesses.begin(); it != end; it++) {
 			const ProcessPtr &process = *it;
 			assert(process->enabled == Process::DISABLING);
-			assert(process->pqHandle == NULL);
 			assert(process->isAlive());
 			assert(process->oobwStatus == Process::OOBW_NOT_ACTIVE
 				|| process->oobwStatus == Process::OOBW_IN_PROGRESS);
@@ -295,7 +303,6 @@ public:
 		for (it = disabledProcesses.begin(); it != end; it++) {
 			const ProcessPtr &process = *it;
 			assert(process->enabled == Process::DISABLED);
-			assert(process->pqHandle == NULL);
 			assert(process->isAlive());
 			assert(process->oobwStatus == Process::OOBW_NOT_ACTIVE
 				|| process->oobwStatus == Process::OOBW_IN_PROGRESS);
@@ -303,7 +310,6 @@ public:
 
 		foreach (const ProcessPtr &process, detachedProcesses) {
 			assert(process->enabled == Process::DETACHED);
-			assert(process->pqHandle == NULL);
 		}
 		#endif
 	}
@@ -322,18 +328,14 @@ public:
 	#endif
 
 	/**
-	 * Persists options into this Group. Called at creation time and at restart time.
-	 * Values will be persisted into `destination`. Or if it's NULL, into `this->options`.
+	 * Sets options for this Group. Called at creation time and at restart time.
 	 */
-	void resetOptions(const Options &newOptions, Options *destination = NULL) {
-		if (destination == NULL) {
-			destination = &this->options;
-		}
-		*destination = newOptions;
-		destination->persist(newOptions);
-		destination->clearPerRequestFields();
-		destination->groupSecret = secret;
-		destination->groupUuid   = uuid;
+	void resetOptions(const Options &newOptions) {
+		options = newOptions;
+		options.persist(newOptions);
+		options.clearPerRequestFields();
+		options.groupSecret = StaticString(secret, SECRET_SIZE);
+		options.groupUuid   = uuid;
 	}
 
 	/**
@@ -346,8 +348,8 @@ public:
 		options.maxPreloaderIdleTime = other.maxPreloaderIdleTime;
 	}
 
-	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)();
 		}
@@ -382,21 +384,21 @@ public:
 	RouteResult route(const Options &options) const {
 		if (OXT_LIKELY(enabledCount > 0)) {
 			if (options.stickySessionId == 0) {
-				if (pqueue.top()->canBeRoutedTo()) {
-					return RouteResult(pqueue.top());
+				Process *process = findProcessWithLowestBusyness(enabledProcesses);
+				if (process->canBeRoutedTo()) {
+					return RouteResult(process);
 				} else {
 					return RouteResult(NULL, true);
 				}
 			} else {
-				Process *process = findProcessWithStickySessionId(options.stickySessionId);
+				Process *process = findProcessWithStickySessionIdOrLowestBusyness(
+					options.stickySessionId);
 				if (process != NULL) {
 					if (process->canBeRoutedTo()) {
 						return RouteResult(process);
 					} else {
 						return RouteResult(NULL, false);
 					}
-				} else if (pqueue.top()->canBeRoutedTo()) {
-					return RouteResult(pqueue.top());
 				} else {
 					return RouteResult(NULL, true);
 				}
@@ -411,22 +413,23 @@ public:
 		}
 	}
 
-	SessionPtr newSession(Process *process) {
-		SessionPtr session = process->newSession();
+	SessionPtr newSession(Process *process, unsigned long long now = 0) {
+		bool wasTotallyBusy = process->isTotallyBusy();
+		SessionPtr session = process->newSession(now);
 		session->onInitiateFailure = _onSessionInitiateFailure;
 		session->onClose   = _onSessionClose;
 		if (process->enabled == Process::ENABLED) {
-			if (process == pqueue.top()) {
-				pqueue.pop();
-			} else {
-				pqueue.erase(process->pqHandle);
+			enabledProcessBusynessLevels[process->index] = process->busyness();
+			if (!wasTotallyBusy && process->isTotallyBusy()) {
+				nEnabledProcessesTotallyBusy++;
 			}
-			process->pqHandle = pqueue.push(process, process->busyness());
 		}
 		return session;
 	}
 
-	bool pushGetWaiter(const Options &newOptions, const GetCallback &callback) {
+	bool pushGetWaiter(const Options &newOptions, const GetCallback &callback,
+		boost::container::vector<Callback> &postLockActions)
+	{
 		if (OXT_LIKELY(!testOverflowRequestQueue()
 			&& (newOptions.maxRequestQueueSize == 0
 			    || getWaitlist.size() < newOptions.maxRequestQueueSize)))
@@ -437,7 +440,8 @@ public:
 			return true;
 		} else {
 			P_WARN("Request queue is full. Returning an error");
-			callback(SessionPtr(), boost::make_shared<RequestQueueFullException>());
+			postLockActions.push_back(boost::bind(GetCallback::call,
+				callback, SessionPtr(), boost::make_shared<RequestQueueFullException>()));
 			return false;
 		}
 	}
@@ -453,16 +457,46 @@ public:
 		return NULL;
 	}
 
+	Process *findProcessWithStickySessionIdOrLowestBusyness(unsigned int id) const {
+		int leastBusyProcessIndex = -1;
+		int lowestBusyness = 0;
+		unsigned int i, size = enabledProcessBusynessLevels.size();
+		const int *enabledProcessBusynessLevels = &this->enabledProcessBusynessLevels[0];
+
+		for (i = 0; i < size; i++) {
+			Process *process = enabledProcesses[i].get();
+			if (process->stickySessionId == id) {
+				return process;
+			} else if (leastBusyProcessIndex == -1 || enabledProcessBusynessLevels[i] < lowestBusyness) {
+				leastBusyProcessIndex = i;
+				lowestBusyness = enabledProcessBusynessLevels[i];
+			}
+		}
+
+		if (leastBusyProcessIndex == -1) {
+			return NULL;
+		} else {
+			return enabledProcesses[leastBusyProcessIndex].get();
+		}
+	}
+
 	Process *findProcessWithLowestBusyness(const ProcessList &processes) const {
-		Process *result = NULL;
-		ProcessList::const_iterator it, end = processes.end();
-		for (it = processes.begin(); it != end; it++) {
-			Process *process = it->get();
-			if (result == NULL || process->busyness() < result->busyness()) {
-				result = process;
+		if (processes.empty()) {
+			return NULL;
+		}
+
+		int leastBusyProcessIndex = -1;
+		int lowestBusyness = 0;
+		unsigned int i, size = enabledProcessBusynessLevels.size();
+		const int *enabledProcessBusynessLevels = &this->enabledProcessBusynessLevels[0];
+
+		for (i = 0; i < size; i++) {
+			if (leastBusyProcessIndex == -1 || enabledProcessBusynessLevels[i] < lowestBusyness) {
+				leastBusyProcessIndex = i;
+				lowestBusyness = enabledProcessBusynessLevels[i];
 			}
 		}
-		return result;
+		return enabledProcesses[leastBusyProcessIndex].get();
 	}
 
 	/**
@@ -471,13 +505,17 @@ public:
 	 */
 	void removeProcessFromList(const ProcessPtr &process, ProcessList &source) {
 		ProcessPtr p = process; // Keep an extra reference count just in case.
-		source.erase(process->it);
+
+		source.erase(source.begin() + process->index);
+		process->index = -1;
+
 		switch (process->enabled) {
 		case Process::ENABLED:
 			assert(&source == &enabledProcesses);
 			enabledCount--;
-			pqueue.erase(process->pqHandle);
-			process->pqHandle = NULL;
+			if (process->isTotallyBusy()) {
+				nEnabledProcessesTotallyBusy--;
+			}
 			break;
 		case Process::DISABLING:
 			assert(&source == &disablingProcesses);
@@ -493,6 +531,24 @@ public:
 		default:
 			P_BUG("Unknown 'enabled' state " << (int) process->enabled);
 		}
+
+		// Rebuild indices
+		ProcessList::iterator it, end = source.end();
+		unsigned int i = 0;
+		for (it = source.begin(); it != end; it++, i++) {
+			const ProcessPtr &process = *it;
+			process->index = i;
+		}
+
+		// Rebuild enabledProcessBusynessLevels
+		if (&source == &enabledProcesses) {
+			enabledProcessBusynessLevels.clear();
+			for (it = source.begin(); it != end; it++, i++) {
+				const ProcessPtr &process = *it;
+				enabledProcessBusynessLevels.push_back(process->busyness());
+			}
+			enabledProcessBusynessLevels.shrink_to_fit();
+		}
 	}
 
 	/**
@@ -503,11 +559,14 @@ public:
 	 */
 	void addProcessToList(const ProcessPtr &process, ProcessList &destination) {
 		destination.push_back(process);
-		process->it = destination.last_iterator();
+		process->index = destination.size() - 1;
 		if (&destination == &enabledProcesses) {
 			process->enabled = Process::ENABLED;
-			process->pqHandle = pqueue.push(process.get(), process->busyness());
 			enabledCount++;
+			enabledProcessBusynessLevels.push_back(process->busyness());
+			if (process->isTotallyBusy()) {
+				nEnabledProcessesTotallyBusy++;
+			}
 		} else if (&destination == &disablingProcesses) {
 			process->enabled = Process::DISABLING;
 			disablingCount++;
@@ -518,7 +577,7 @@ public:
 		} else if (&destination == &detachedProcesses) {
 			assert(process->isAlive());
 			process->enabled = Process::DETACHED;
-			process->abortLongRunningConnections();
+			callAbortLongRunningConnectionsCallback(process);
 		} else {
 			P_BUG("Unknown destination list");
 		}
@@ -532,7 +591,7 @@ public:
 			return;
 		}
 
-		SmallVector<GetAction, 50> actions;
+		SmallVector<GetAction, 8> actions;
 		unsigned int i = 0;
 		bool done = false;
 
@@ -563,7 +622,7 @@ public:
 		}
 	}
 
-	void assignSessionsToGetWaiters(vector<Callback> &postLockActions) {
+	void assignSessionsToGetWaiters(boost::container::vector<Callback> &postLockActions) {
 		unsigned int i = 0;
 		bool done = false;
 
@@ -572,6 +631,7 @@ public:
 			RouteResult result = route(waiter.options);
 			if (result.process != NULL) {
 				postLockActions.push_back(boost::bind(
+					GetCallback::call,
 					waiter.callback,
 					newSession(result.process),
 					ExceptionPtr()));
@@ -585,7 +645,7 @@ public:
 		}
 	}
 
-	void enableAllDisablingProcesses(vector<Callback> &postLockActions) {
+	void enableAllDisablingProcesses(boost::container::vector<Callback> &postLockActions) {
 		P_DEBUG("Enabling all DISABLING processes with result DR_ERROR");
 		deque<DisableWaiter>::iterator it, end = disableWaitlist.end();
 		for (it = disableWaitlist.begin(); it != end; it++) {
@@ -604,7 +664,7 @@ public:
 	}
 
 	void removeFromDisableWaitlist(const ProcessPtr &p, DisableResult result,
-		vector<Callback> &postLockActions)
+		boost::container::vector<Callback> &postLockActions)
 	{
 		deque<DisableWaiter>::const_iterator it, end = disableWaitlist.end();
 		deque<DisableWaiter> newList;
@@ -620,7 +680,9 @@ public:
 		disableWaitlist = newList;
 	}
 
-	void clearDisableWaitlist(DisableResult result, vector<Callback> &postLockActions) {
+	void clearDisableWaitlist(DisableResult result,
+		boost::container::vector<Callback> &postLockActions)
+	{
 		// This function may be called after processes in the disableWaitlist
 		// have been disabled or enabled, so do not assume any value for
 		// waiter.process->enabled in this function.
@@ -633,7 +695,8 @@ public:
 	}
 
 	bool shutdownCanFinish() const {
-		return getLifeStatus() == SHUTTING_DOWN
+		LifeStatus lifeStatus = (LifeStatus) this->lifeStatus.load(boost::memory_order_relaxed);
+		return lifeStatus == SHUTTING_DOWN
 			&& enabledCount == 0
 			&& disablingCount == 0
 	 		&& disabledCount == 0
@@ -647,9 +710,12 @@ public:
 	/** One of the post lock actions can potentially perform a long-running
 	 * operation, so running them in a thread is advised.
 	 */
-	void finishShutdown(vector<Callback> &postLockActions) {
+	void finishShutdown(boost::container::vector<Callback> &postLockActions) {
 		TRACE_POINT();
-		assert(getLifeStatus() == SHUTTING_DOWN);
+		#ifndef NDEBUG
+			LifeStatus lifeStatus = (LifeStatus) this->lifeStatus.load(boost::memory_order_relaxed);
+			P_ASSERT_EQ(lifeStatus, SHUTTING_DOWN);
+		#endif
 		P_DEBUG("Finishing shutdown of group " << name);
 		if (shutdownCallback) {
 			postLockActions.push_back(shutdownCallback);
@@ -657,21 +723,20 @@ public:
 		}
 		postLockActions.push_back(boost::bind(interruptAndJoinAllThreads,
 			shared_from_this()));
-		{
-			boost::lock_guard<boost::mutex> l(lifetimeSyncher);
-			lifeStatus = SHUT_DOWN;
-		}
+		this->lifeStatus.store(SHUT_DOWN, boost::memory_order_release);
 		selfPointer.reset();
 	}
 
 public:
+	static const unsigned int SECRET_SIZE = 16;
+
 	Options options;
 	/** This name uniquely identifies this Group within its Pool. It can also be used as the display name. */
 	const string name;
 	/** A secret token that may be known among all processes in this Group. Used for securing
 	 * intra-group process communication.
 	 */
-	const string secret;
+	char secret[SECRET_SIZE];
 	/** A UUID that's generated on Group initialization, and changes every time
 	 * the Group receives a restart command. Allows Union Station to track app
 	 * restarts. This information is public.
@@ -698,8 +763,8 @@ public:
 	 * their numbers.
 	 * These lists do not intersect. A process is in exactly 1 list.
 	 *
-	 * 'pqueue' orders all enabled processes according to busyness() values,
-	 * from small to large.
+	 * `nEnabledProcessesTotallyBusy` counts the number of enabled processes for which
+	 * `isTotallyBusy()` is true.
 	 *
 	 * Invariants:
 	 *    enabledCount >= 0
@@ -708,9 +773,8 @@ public:
 	 *    enabledProcesses.size() == enabledCount
 	 *    disablingProcesses.size() == disabingCount
 	 *    disabledProcesses.size() == disabledCount
+	 *    nEnabledProcessesTotallyBusy <= enabledCount
      *
-	 *    enabledProcesses.empty() == (pqueue.top() == NULL)
-	 *
 	 *    if (enabledCount == 0):
 	 *       processesBeingSpawned > 0 || restarting() || poolAtFullCapacity()
 	 *    if (enabledCount == 0) and (disablingCount > 0):
@@ -718,29 +782,23 @@ public:
 	 *    if !m_spawning:
 	 *       (enabledCount > 0) || (disablingCount == 0)
 	 *
-	 *    if pqueue.top().isTotallyBusy():
-	 *       All enabled processes are totally busy.
-	 *
 	 *    for all process in enabledProcesses:
 	 *       process.enabled == Process::ENABLED
-	 *       process.pqHandle != NULL
 	 *       process.isAlive()
 	 *       process.oobwStatus == Process::OOBW_NOT_ACTIVE || process.oobwStatus == Process::OOBW_REQUESTED
 	 *    for all processes in disablingProcesses:
 	 *       process.enabled == Process::DISABLING
-	 *       process.pqHandle == NULL
 	 *       process.isAlive()
 	 *       process.oobwStatus == Process::OOBW_NOT_ACTIVE || process.oobwStatus == Process::OOBW_IN_PROGRESS
 	 *    for all process in disabledProcesses:
 	 *       process.enabled == Process::DISABLED
-	 *       process.pqHandle == NULL
 	 *       process.isAlive()
 	 *       process.oobwStatus == Process::OOBW_NOT_ACTIVE || process.oobwStatus == Process::OOBW_IN_PROGRESS
 	 */
 	int enabledCount;
 	int disablingCount;
 	int disabledCount;
-	PriorityQueue<Process> pqueue;
+	int nEnabledProcessesTotallyBusy;
 	ProcessList enabledProcesses;
 	ProcessList disablingProcesses;
 	ProcessList disabledProcesses;
@@ -751,10 +809,16 @@ public:
 	 *
 	 * for all process in detachedProcesses:
 	 *    process.enabled == Process::DETACHED
-	 *    process.pqHandle == NULL
 	 */
 	ProcessList detachedProcesses;
 
+	/**
+	 * A cache of the processes' busyness. It's in a compact structure
+	 * so that `findProcessWithLowestBusyness()` can work very quickly
+	 * when there are a large number of processes.
+	 */
+	boost::container::vector<int> enabledProcessBusynessLevels;
+
 	/**
 	 * get() requests for this group that cannot be immediately satisfied are
 	 * put on this wait list, which must be processed as soon as the necessary
@@ -808,8 +872,9 @@ public:
 	 * Constructors and destructors
 	 ********************************************/
 
-	Group(const SuperGroupPtr &superGroup, const Options &options, const ComponentInfo &info);
+	Group(SuperGroup *superGroup, const Options &options, const ComponentInfo &info);
 	~Group();
+	void initialize();
 
 	/**
 	 * Must be called before destroying a Group. You can optionally provide a
@@ -820,7 +885,9 @@ public:
 	 * One of the post lock actions can potentially perform a long-running
 	 * operation, so running them in a thread is advised.
 	 */
-	void shutdown(const Callback &callback, vector<Callback> &postLockActions) {
+	void shutdown(const Callback &callback,
+		boost::container::vector<Callback> &postLockActions)
+	{
 		assert(isAlive());
 
 		P_DEBUG("Begin shutting down group " << name);
@@ -832,10 +899,7 @@ public:
 		spawner.reset();
 		selfPointer = shared_from_this();
 		assert(disableWaitlist.empty());
-		{
-			boost::lock_guard<boost::mutex> l(lifetimeSyncher);
-			lifeStatus = SHUTTING_DOWN;
-		}
+		lifeStatus.store(SHUTTING_DOWN, boost::memory_order_release);
 	}
 
 
@@ -848,12 +912,12 @@ public:
 	 * @pre getLifeState() != SHUT_DOWN
 	 * @post result != NULL
 	 */
-	SuperGroupPtr getSuperGroup() const {
-		return superGroup.lock();
+	SuperGroup *getSuperGroup() const {
+		return superGroup;
 	}
 
-	void setSuperGroup(const SuperGroupPtr &superGroup) {
-		assert(this->superGroup.lock() == NULL);
+	void setSuperGroup(SuperGroup *superGroup) {
+		assert(this->superGroup == NULL);
 		this->superGroup = superGroup;
 	}
 
@@ -862,18 +926,17 @@ public:
 	 * @pre getLifeState() != SHUT_DOWN
 	 * @post result != NULL
 	 */
-	PoolPtr getPool() const;
+	OXT_FORCE_INLINE Pool *getPool() const;
 
 	// Thread-safe.
 	bool isAlive() const {
-		boost::lock_guard<boost::mutex> lock(lifetimeSyncher);
-		return lifeStatus == ALIVE;
+		return getLifeStatus() == ALIVE;
 	}
 
 	// Thread-safe.
+	OXT_FORCE_INLINE
 	LifeStatus getLifeStatus() const {
-		boost::lock_guard<boost::mutex> lock(lifetimeSyncher);
-		return lifeStatus;
+		return (LifeStatus) lifeStatus.load(boost::memory_order_acquire);
 	}
 
 
@@ -882,7 +945,7 @@ public:
 	 ********************************************/
 
 	SessionPtr get(const Options &newOptions, const GetCallback &callback,
-		vector<Callback> &postLockActions)
+		boost::container::vector<Callback> &postLockActions)
 	{
 		assert(isAlive());
 
@@ -913,14 +976,7 @@ public:
 		}
 
 		if (OXT_UNLIKELY(newOptions.noop)) {
-			ProcessPtr process = boost::make_shared<Process>(
-				0, string(), string(),
-				FileDescriptor(), FileDescriptor(),
-				SocketListPtr(), 0, 0);
-			process->dummy = true;
-			process->requiresShutdown = false;
-			process->setGroup(shared_from_this());
-			return boost::make_shared<Session>(process, (Socket *) NULL);
+			return nullProcess->createSessionObject((Socket *) NULL);
 		}
 
 		if (OXT_UNLIKELY(enabledCount == 0)) {
@@ -943,11 +999,11 @@ public:
 					disablingProcesses);
 				assert(process != NULL);
 				if (!process->isTotallyBusy()) {
-					return newSession(process);
+					return newSession(process, newOptions.currentTime);
 				}
 			}
 
-			if (pushGetWaiter(newOptions, callback)) {
+			if (pushGetWaiter(newOptions, callback, postLockActions)) {
 				P_DEBUG("No session checked out yet: group is spawning or restarting");
 			}
 			return SessionPtr();
@@ -958,13 +1014,13 @@ public:
 				 * Wait until a new one has been spawned or until
 				 * resources have become free.
 				 */
-				if (pushGetWaiter(newOptions, callback)) {
+				if (pushGetWaiter(newOptions, callback, postLockActions)) {
 					P_DEBUG("No session checked out yet: all processes are at full capacity");
 				}
 				return SessionPtr();
 			} else {
 				P_DEBUG("Session checked out from process " << result.process->inspect());
-				return newSession(result.process);
+				return newSession(result.process, newOptions.currentTime);
 			}
 		}
 	}
@@ -982,9 +1038,12 @@ public:
 	 * function doesn't touch `getWaitlist` so be sure to fix its invariants
 	 * afterwards if necessary, e.g. by calling `assignSessionsToGetWaiters()`.
 	 */
-	AttachResult attach(const ProcessPtr &process, vector<Callback> &postLockActions) {
+	AttachResult attach(const SpawnObject &spawnObject,
+		boost::container::vector<Callback> &postLockActions)
+	{
 		TRACE_POINT();
-		assert(process->getGroup() == NULL || process->getGroup().get() == this);
+		const ProcessPtr &process = spawnObject.process;
+		assert(process->getGroup() == NULL || process->getGroup() == this);
 		assert(process->isAlive());
 		assert(isAlive());
 
@@ -996,11 +1055,15 @@ public:
 			return AR_ANOTHER_GROUP_IS_WAITING_FOR_CAPACITY;
 		}
 
-		process->setGroup(shared_from_this());
+		process->setGroup(this);
 		process->stickySessionId = generateStickySessionId();
 		P_DEBUG("Attaching process " << process->inspect());
 		addProcessToList(process, enabledProcesses);
 
+		if (spawnObject.pool != getPallocPool()) {
+			process->recreateStrings(getPallocPool());
+		}
+
 		/* Now that there are enough resources, relevant processes in
 		 * 'disableWaitlist' can be disabled.
 		 */
@@ -1043,9 +1106,9 @@ public:
 	 * `pool->detachProcessUnlocked()` does that so you should usually use
 	 * that method over this one.
 	 */
-	void detach(const ProcessPtr &process, vector<Callback> &postLockActions) {
+	void detach(const ProcessPtr &process, boost::container::vector<Callback> &postLockActions) {
 		TRACE_POINT();
-		assert(process->getGroup().get() == this);
+		assert(process->getGroup() == this);
 		assert(process->isAlive());
 		assert(isAlive());
 
@@ -1081,13 +1144,12 @@ public:
 	 * Detaches all processes from this Group. This function doesn't touch
 	 * getWaitlist so be sure to fix its invariants afterwards if necessary.
 	 */
-	void detachAll(vector<Callback> &postLockActions) {
+	void detachAll(boost::container::vector<Callback> &postLockActions) {
 		assert(isAlive());
 		P_DEBUG("Detaching all processes in group " << name);
 
 		foreach (ProcessPtr process, enabledProcesses) {
 			addProcessToList(process, detachedProcesses);
-			process->pqHandle = NULL;
 		}
 		foreach (ProcessPtr process, disablingProcesses) {
 			addProcessToList(process, detachedProcesses);
@@ -1099,10 +1161,11 @@ public:
 		enabledProcesses.clear();
 		disablingProcesses.clear();
 		disabledProcesses.clear();
-		pqueue.clear();
+		enabledProcessBusynessLevels.clear();
 		enabledCount = 0;
 		disablingCount = 0;
 		disabledCount = 0;
+		nEnabledProcessesTotallyBusy = 0;
 		clearDisableWaitlist(DR_NOOP, postLockActions);
 		startCheckingDetachedProcesses(false);
 	}
@@ -1111,8 +1174,8 @@ public:
 	 * Marks the given process as enabled. This function doesn't touch getWaitlist
 	 * so be sure to fix its invariants afterwards if necessary.
 	 */
-	void enable(const ProcessPtr &process, vector<Callback> &postLockActions) {
-		assert(process->getGroup().get() == this);
+	void enable(const ProcessPtr &process, boost::container::vector<Callback> &postLockActions) {
+		assert(process->getGroup() == this);
 		assert(process->isAlive());
 		assert(isAlive());
 
@@ -1136,7 +1199,7 @@ public:
 	 * called later with the result of this action.
 	 */
 	DisableResult disable(const ProcessPtr &process, const DisableCallback &callback) {
-		assert(process->getGroup().get() == this);
+		assert(process->getGroup() == this);
 		assert(process->isAlive());
 		assert(isAlive());
 
@@ -1216,7 +1279,7 @@ public:
 		}
 	}
 
-	void cleanupSpawner(vector<Callback> &postLockActions) {
+	void cleanupSpawner(boost::container::vector<Callback> &postLockActions) {
 		assert(isAlive());
 		postLockActions.push_back(boost::bind(doCleanupSpawner, spawner));
 	}
@@ -1264,7 +1327,7 @@ public:
 	 * Returns false if there are no enabled processes.
 	 */
 	bool allEnabledProcessesAreTotallyBusy() const {
-		return enabledCount > 0 && pqueue.top()->isTotallyBusy();
+		return nEnabledProcessesTotallyBusy == enabledCount;
 	}
 
 	/**
@@ -1312,9 +1375,78 @@ public:
 		if (m_restarting) {
 			return false;
 		} else {
+			time_t now;
 			struct stat buf;
-			return cstat.stat(alwaysRestartFile, &buf, options.statThrottleRate) == 0 ||
-			       fileChangeChecker.changed(restartFile, options.statThrottleRate);
+
+			if (options.currentTime != 0) {
+				now = options.currentTime / 1000000;
+			} else {
+				now = SystemTime::get();
+			}
+
+			if (lastRestartFileCheckTime == 0) {
+				// First time we call needsRestart() for this group.
+				if (syscalls::stat(restartFile.c_str(), &buf) == 0) {
+					lastRestartFileMtime = buf.st_mtime;
+				} else {
+					lastRestartFileMtime = 0;
+				}
+				lastRestartFileCheckTime = now;
+				return false;
+
+			} else if (lastRestartFileCheckTime <= now - (time_t) options.statThrottleRate) {
+				// Not first time we call needsRestart() for this group.
+				// Stat throttle time has passed.
+				bool restart;
+
+				lastRestartFileCheckTime = now;
+
+				if (lastRestartFileMtime > 0) {
+					// restart.txt existed before
+					if (syscalls::stat(restartFile.c_str(), &buf) == -1) {
+						// restart.txt no longer exists
+						lastRestartFileMtime = buf.st_mtime;
+						restart = false;
+					} else if (buf.st_mtime != lastRestartFileMtime) {
+						// restart.txt's mtime has changed
+						lastRestartFileMtime = buf.st_mtime;
+						restart = true;
+					} else {
+						restart = false;
+					}
+				} else {
+					// restart.txt didn't exist before
+					if (syscalls::stat(restartFile.c_str(), &buf) == 0) {
+						// restart.txt now exists
+						lastRestartFileMtime = buf.st_mtime;
+						restart = true;
+					} else {
+						// restart.txt still doesn't exist
+						lastRestartFileMtime = 0;
+						restart = false;
+					}
+				}
+
+				if (!restart) {
+					alwaysRestartFileExists = restart =
+						syscalls::stat(alwaysRestartFile.c_str(), &buf) == 0;
+				}
+
+				return restart;
+
+			} else {
+				// Not first time we call needsRestart() for this group.
+				// Still within stat throttling window.
+				if (alwaysRestartFileExists) {
+					// always_restart.txt existed before
+					alwaysRestartFileExists = syscalls::stat(
+						alwaysRestartFile.c_str(), &buf) == 0;
+					return alwaysRestartFileExists;
+				} else {
+					// Don't check until stat throttling window is over
+					return false;
+				}
+			}
 		}
 	}
 
@@ -1350,8 +1482,9 @@ public:
 			stream << "<restarting/>";
 		}
 		if (includeSecrets) {
-			stream << "<secret>" << escapeForXml(secret) << "</secret>";
+			stream << "<secret>" << escapeForXml(StaticString(secret, SECRET_SIZE)) << "</secret>";
 		}
+		LifeStatus lifeStatus = (LifeStatus) this->lifeStatus.load(boost::memory_order_relaxed);
 		switch (lifeStatus) {
 		case ALIVE:
 			stream << "<life_status>ALIVE</life_status>";
@@ -1363,7 +1496,7 @@ public:
 			stream << "<life_status>SHUT_DOWN</life_status>";
 			break;
 		default:
-			P_BUG("Unknown 'lifeStatus' state " << (int) lifeStatus);
+			P_BUG("Unknown 'lifeStatus' state " << lifeStatus);
 		}
 
 		stream << "<options>";