rockdog-passenger 0.0.1

data/benchmark/ApplicationPool.cpp

@@ -0,0 +1,52 @@
+//#define USE_SERVER
+
+#include <iostream>
+#include <boost/bind.hpp>
+#include <boost/thread.hpp>
+#ifdef USE_SERVER
+	#include "ApplicationPoolServer.h"
+#else
+	#include "StandardApplicationPool.h"
+#endif
+#include "Utils.h"
+#include "Logging.h"
+
+using namespace std;
+using namespace boost;
+using namespace Passenger;
+
+#define TRANSACTIONS 20000
+#define CONCURRENCY 24
+
+ApplicationPoolPtr pool;
+
+static void
+threadMain(unsigned int times) {
+	for (unsigned int i = 0; i < times; i++) {
+		Application::SessionPtr session(pool->get("test/stub/minimal-railsapp"));
+		for (int x = 0; x < 200000; x++) {
+			// Do nothing.
+		}
+	}
+}
+
+int
+main() {
+	thread_group tg;
+	#ifdef USE_SERVER
+		ApplicationPoolServer server("ext/apache2/ApplicationPoolServerExecutable",
+			"bin/passenger-spawn-server");
+		pool = server.connect();
+	#else
+		pool = ptr(new StandardApplicationPool("bin/passenger-spawn-server"));
+	#endif
+	pool->setMax(6);
+	
+	for (int i = 0; i < CONCURRENCY; i++) {
+		tg.create_thread(boost::bind(&threadMain, TRANSACTIONS / CONCURRENCY));
+	}
+	
+	tg.join_all();
+	return 0;
+}
+

data/benchmark/DummyRequestHandler.cpp

@@ -0,0 +1,101 @@
+#include "MessageChannel.h"
+#include "Utils.cpp"
+#include "Logging.cpp"
+#include <vector>
+#include <unistd.h>
+#include <errno.h>
+
+using namespace std;
+using namespace Passenger;
+
+typedef vector< pair<string, string> > HeaderSet;
+
+static void
+readHeaders(int reader, HeaderSet &headers) {
+	string buffer;
+	char buffer2[1024 * 32];
+	buffer.reserve(1024 * 32);
+	while (true) {
+		ssize_t ret = read(reader, buffer2, sizeof(buffer2));
+		if (ret == 0) {
+			break;
+		} else {
+			buffer.append(buffer2, ret);
+		}
+	}
+	
+	string::size_type start = 0;
+	string::size_type pos;
+	while (true) {
+		pos = buffer.find('\0', start);
+		if (pos != string::npos) {
+			string name(buffer.substr(start, pos - start));
+			start = pos + 1;
+			pos = buffer.find('\0', start);
+			string value(buffer.substr(start, pos - start));
+			start = pos + 1;
+			headers.push_back(make_pair(name, value));
+		} else {
+			break;
+		}
+	}
+}
+
+static void
+processRequest(int reader, int writer) {
+	HeaderSet headers;
+	readHeaders(reader, headers);
+	close(reader);
+	
+	string content;
+	content.reserve(1024 * 7);
+	content += "<b>Using C++ DummyRequestHandler</b><br>\n";
+	for (HeaderSet::const_iterator it(headers.begin()); it != headers.end(); it++) {
+		content.append("<tt>");
+		content.append(it->first);
+		content.append(" = ");
+		content.append(it->second);
+		content.append("</tt><br>\n");
+	}
+	
+	string header;
+	header.reserve(512);
+	header.append("Status: 200 OK\r\n"
+		"Content-Type: text/html\r\n"
+		"Content-Length: ");
+	header.append(toString(content.size()));
+	header.append("\r\n\r\n");
+	
+	MessageChannel channel(writer);
+	channel.writeRaw(header);
+	channel.writeRaw(content);
+	channel.close();
+}
+
+static bool
+acceptNextRequest(int fd) {
+	char c;
+	if (read(fd, &c, 1) == 0) {
+		return true;
+	}
+	
+	MessageChannel listener(fd);
+	int fd1[2], fd2[2];
+	pipe(fd1);
+	pipe(fd2);
+	listener.writeFileDescriptor(fd1[0]);
+	listener.writeFileDescriptor(fd2[1]);
+	close(fd1[0]);
+	close(fd2[1]);
+	processRequest(fd2[0], fd1[1]);
+	return false;
+}
+
+int
+main() {
+	bool done = false;
+	while (!done) {
+		done = acceptNextRequest(STDIN_FILENO);
+	}
+	return 0;
+}

data/benchmark/accept_vs_socketpair_vs_named_pipes.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+require 'benchmark'
+require 'socket'
+require 'dl/import'
+
+ITERATIONS = 100000
+# Constants to relieve the garbage collector
+MESSAGE = " " * 512
+MESSAGE_SIZE = [MESSAGE.size].pack('n')
+FIFO = 'fifo'
+R = 'r'
+W = 'w'
+
+def start
+	if ARGV.empty?
+		benchmark_accept
+		benchmark_socketpair
+		benchmark_named_pipes
+	elsif ARGV.size == 1 && ARGV[0] == 'accept'
+		benchmark_accept
+	elsif ARGV.size == 1 && ARGV[0] == 'socketpair'
+		benchmark_socketpair
+	elsif ARGV.size == 1 && ARGV[0] == 'named_pipes'
+		benchmark_named_pipes
+	else
+		puts "Usage: accept_vs_socketpair.rb <accept|socketpair>"
+		exit(1)
+	end
+end
+
+def benchmark_accept
+	begin
+		puts "Benchmarking accept()..."
+		File.unlink("benchmark.socket") rescue nil
+		pid = fork do
+			server = UNIXServer.new("benchmark.socket")
+			ITERATIONS.times do
+				client = server.accept
+				client.readline
+				client.close
+			end
+			server.close
+		end
+		result = Benchmark.measure do
+			ITERATIONS.times do
+				conn = UNIXSocket.new("benchmark.socket")
+				conn.puts("hello")
+				conn.close
+			end
+		end
+		Process.waitpid(pid)
+		puts "User/system/real time: #{result}"
+		printf "%.2f messages per second\n", ITERATIONS / result.real
+	ensure
+		File.unlink("benchmark.socket") rescue nil
+	end
+end
+
+def benchmark_socketpair
+	puts "Benchmarking socketpair()..."
+	listener, connector = UNIXSocket.pair
+	pid = fork do
+		connector.close
+		ITERATIONS.times do
+			a, b = UNIXSocket.pair
+			listener.send_io(a)
+			a.close
+			b.readline
+			b.close
+		end
+		listener.close
+	end
+	result = Benchmark.measure do
+		listener.close
+		ITERATIONS.times do
+			conn = connector.recv_io
+			conn.puts("hello")
+			conn.close
+		end
+		connector.close
+	end
+	Process.waitpid(pid)
+	puts "User/system/real time: #{result}"
+	printf "%.2f messages per second\n", ITERATIONS / result.real
+end
+
+def benchmark_named_pipes
+	puts "Benchmarking named pipes..."
+	listener, connector = UNIXSocket.pair
+	pid = fork do
+		connector.close
+		ITERATIONS.times do
+			LIBC.mkfifo(FIFO, 0600)
+			listener.write("#{FIFO}\n")
+			File.open(FIFO, R) do |f|
+				f.readline
+			end
+			File.unlink(FIFO)
+		end
+		listener.close
+	end
+	result = Benchmark.measure do
+		listener.close
+		ITERATIONS.times do
+			fifo_name = connector.readline
+			fifo_name.rstrip!
+			File.open(fifo_name, W) do |f|
+				f.puts("hello")
+			end
+		end
+		connector.close
+	end
+	Process.waitpid(pid)
+	puts "User/system/real time: #{result}"
+	printf "%.2f messages per second\n", ITERATIONS / result.real
+end
+
+# Urgh, Ruby does not support mkfifo...
+module LIBC
+	extend DL::Importable
+	dlload 'libc.so.6'
+	extern 'int mkfifo(char*, uint)'
+	extern 'void perror(char*)'
+end
+
+start

data/benchmark/dispatcher.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# Benchmark raw speed of the Rails dispatcher.
+PASSENGER_ROOT = File.expand_path("#{File.dirname(__FILE__)}/..")
+$LOAD_PATH << "#{PASSENGER_ROOT}/lib"
+$LOAD_PATH << "#{PASSENGER_ROOT}/ext"
+ENV["RAILS_ENV"] = "production"
+
+require 'yaml'
+require 'benchmark'
+require 'config/environment'
+require 'passenger/railz/cgi_fixed'
+require 'dispatcher'
+
+class OutputChannel
+	def write(data)
+		# Black hole
+	end
+end
+
+def start(iterations)
+	headers = YAML.load_file("#{PASSENGER_ROOT}/test/stub/http_request.yml")
+	output = OutputChannel.new
+	milestone = iterations / 10
+	milestone = 1 if milestone == 0
+	result = Benchmark.measure do
+		iterations.times do |i|
+			cgi = PhusionPassenger::Railz::CGIFixed.new(headers, output, output)
+			::Dispatcher.dispatch(cgi,
+				::ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS,
+				cgi.stdoutput)
+			if i % milestone == 0 && i != 0
+				puts "Completed #{i} requests"
+			end
+		end
+	end
+	puts "#{iterations} requests: #{result}"
+	printf "Speed: %.2f requests/sec\n", iterations / result.total.to_f
+end
+
+puts "Benchmark started."
+start(ARGV[0] ? ARGV[0].to_i : 2000)
+

data/benchmark/overhead_of_password_checking.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+require 'benchmark'
+require 'socket'
+
+ITERATIONS = 100000
+REQUEST = " " * 800
+REQUEST_SIZE = REQUEST.size
+RESPONSE = " " * 5 * 1024
+RESPONSE_SIZE = RESPONSE.size
+PASSWORD = "x" * 128
+PASSWORD_SIZE = PASSWORD.size
+
+def start
+	benchmark_with_password_checking
+	puts ""
+	benchmark_without_password_checking
+end
+
+def benchmark_with_password_checking
+	puts "Benchmarking with password checking..."
+	parent, child = UNIXSocket.pair
+	pid = fork do
+		parent.close
+		ITERATIONS.times do
+			password = child.read(PASSWORD_SIZE)
+			if password == PASSWORD
+				child.read(REQUEST_SIZE)
+				child.write(RESPONSE)
+				# This flush here improves performance significantly!
+				child.flush
+			else
+				child.close
+				break
+			end
+		end
+	end
+	child.close
+	
+	result = Benchmark.measure do
+		ITERATIONS.times do
+			parent.write(PASSWORD)
+			parent.write(REQUEST)
+			parent.flush
+			parent.read(RESPONSE_SIZE)
+		end
+	end
+	parent.close
+	Process.waitpid(pid)
+	puts "User/system/real time: #{result}"
+	printf "%.2f messages per second\n", ITERATIONS / result.real
+end
+
+def benchmark_without_password_checking
+	puts "Benchmarking without password checking..."
+	parent, child = UNIXSocket.pair
+	pid = fork do
+		parent.close
+		ITERATIONS.times do
+			child.read(REQUEST_SIZE)
+			child.write(RESPONSE)
+			# This flush here improves performance significantly!
+			child.flush
+		end
+	end
+	child.close
+	
+	result = Benchmark.measure do
+		ITERATIONS.times do
+			parent.write(REQUEST)
+			# We do not call flush. For some reason it degrades performance.
+			parent.read(RESPONSE_SIZE)
+		end
+	end
+	parent.close
+	Process.waitpid(pid)
+	puts "Without password checking:"
+	puts "User/system/real time: #{result}"
+	printf "%.2f messages per second\n", ITERATIONS / result.real
+end
+
+start

data/benchmark/socket_connections_vs_persistent_pipe.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+# We've tried to implement the usage of persistent pipes in Passenger,
+# but we found out that it made Apache slower than when we use socket
+# connections. That is in contrast to the results of this benchmark.
+#
+# We couldn't have used persistent pipes (for multiple sessions) in
+# Passenger anyway, because it's too fragile. If something goes wrong
+# in one session, then the entire pipe becomes unusable for subsequent
+# sessions because the protocol will be in an undefined state. Sockets
+# don't have this problem because if an error occurs because each socket
+# connection belongs to exactly one session.
+require 'benchmark'
+
+ITERATIONS = 100000
+MESSAGE = " " * 512
+MESSAGE_SIZE = [MESSAGE.size].pack('n')
+
+def start
+	if ARGV.empty?
+		benchmark_unix_sockets
+		benchmark_persistent_pipes
+	elsif ARGV.size == 1 && ARGV[0] == 'unix_sockets'
+		benchmark_unix_sockets
+	elsif ARGV.size == 1 && ARGV[0] == 'pipes'
+		benchmark_persistent_pipes
+	else
+		puts "Benchmarks performance ."
+		puts "Usage: socket_connections_vs_persistent_pipes.rb <unix_sockets|pipes>"
+		exit(1)
+	end
+end
+
+def benchmark_unix_sockets
+	require 'socket'
+	begin
+		puts "Benchmarking socket connections..."
+		File.unlink("benchmark.socket") rescue nil
+		pid = fork do
+			server = UNIXServer.new("benchmark.socket")
+			ITERATIONS.times do
+				client = server.accept
+				size = client.read(2).unpack('n')[0]
+				client.read(size)
+				client.write(MESSAGE)
+				client.close
+			end
+			server.close
+		end
+		result = Benchmark.measure do
+			ITERATIONS.times do
+				conn = UNIXSocket.new("benchmark.socket")
+				conn.write(MESSAGE_SIZE)
+				conn.write(MESSAGE)
+				conn.read
+				conn.close
+			end
+		end
+		Process.waitpid(pid)
+		puts "User/system/real time: #{result}"
+		printf "%.2f messages per second\n", ITERATIONS / result.real
+	ensure
+		File.unlink("benchmark.socket") rescue nil
+	end
+end
+
+def benchmark_persistent_pipes
+	puts "Benchmarking pipes connections..."
+	reader1, writer1 = IO.pipe
+	reader2, writer2 = IO.pipe
+	pid = fork do
+		reader1.close
+		writer2.close
+		reader = reader2
+		writer = writer1
+		ITERATIONS.times do
+			size = reader.read(2).unpack('n')[0]
+			reader.read(size)
+			writer.write(MESSAGE_SIZE)
+			writer.write(MESSAGE)
+		end
+	end
+	reader2.close
+	writer1.close
+	reader = reader1
+	writer = writer2
+	result = Benchmark.measure do
+		ITERATIONS.times do
+			writer.write(MESSAGE_SIZE)
+			writer.write(MESSAGE)
+			size = reader.read(2).unpack('n')[0]
+			reader.read(size)
+		end
+	end
+	Process.waitpid(pid)
+	puts "User/system/real time: #{result}"
+	printf "%.2f messages per second\n", ITERATIONS / result.real
+end
+
+start