Maxim Filippovich fatum

Comparative Benchmark Numbers @ Rackspace

I've taken the benchmarks from Matthew Rothenberg's phoenix-showdown, updated Phoenix to 0.13.1 and ran the tests on the most powerful machines available at Rackspace.

Results

Framework	Throughput (req/s)	Latency (ms)	Consistency (σ ms)

ruby-1.9.3-p392 cumulative performance patch for rbenv

(I guarantee nothing. No warranty I am not responsible blah blah blah. Seems to work great for me so far. Thanks to Tyler Bird who I forked this from.)

This installs a patched ruby 1.9.3-p392 with the railsexpress patchsets: https://github.com/skaes/rvm-patchsets

Requirements

Here are the areas I've been researching, some things I've read and some open source packages...

Nearly all text processing starts by transforming text into vectors: http://en.wikipedia.org/wiki/Vector_space_model

Often it uses transforms such as TFIDF to normalise the data and control for outliers (words that are too frequent or too rare confuse the algorithms): http://en.wikipedia.org/wiki/Tf%E2%80%93idf

Collocations is a technique to detect when two or more words occur more commonly together than separately (e.g. "wishy-washy" in English) - I use this to group words into n-gram tokens because many NLP techniques consider each word as if it's independent of all the others in a document, ignoring order: http://matpalm.com/blog/2011/10/22/collocations_1/

Instrument Anything in Rails 3

With Rails 3.0 released a few weeks ago I've migrated a few apps and I'm constantly finding useful new improvements. One such improvement is the ability to log anything in the same way that Rails internally logs ActiveRecord and ActionView. By default Rails 3 logs look slightly spiffier than those produced by Rails 2.3: (notice the second line has been cleaned up)

Started GET "/" for 127.0.0.1 at Mon Sep 06 01:07:11 -0400 2010
  Processing by HomeController#index as HTML
  User Load (0.2ms)  SELECT `users`.* FROM `users` WHERE (`users`.`id` = 3) LIMIT 1
  CACHE (0.0ms)  SELECT `users`.* FROM `users` WHERE (`users`.`id` = 3) LIMIT 1

Rendered layouts/_nav.html.erb (363.4ms)

	# Thee will be more information here when I share the entire problem space I'm working on, but
	# in short, this is preview material for my second talk in a series called "What Computer Scientists Know".
	# The first talk is on recursion, and goes through several examples., leading up to a problem based
	# on a simple puzzle that initial estimates based on performance of a previous puzzle would take years
	# to solve on modern computers with the techniques shown in Ruby. That sets the stage for improving the
	# performance of that problem with threading, concurrency, and related tuning.
	#
	# The second talk is on threading and concurrency, touching on algorithmic performance as well.
	# Using some knowledge of the problem (board symmetry, illegal moves, etc), we reduce the problem space
	# to about .5% of what we initially thought it was. Still, the initial single threaded solution took more

	#!/bin/sh

	mkdir /tmp/ruby-build-patch
	cd /tmp/ruby-build-patch

	# download and patch the ruby sources
	wget http://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.3-p125.tar.gz
	tar xzf ruby-1.9.3-p125.tar.gz
	cd ruby-1.9.3-p125
	curl https://raw.github.com/wayneeseguin/rvm/master/patches/ruby/1.9.3/p125/gcdata.patch \| patch -p1

	echo "deb http://apt.opscode.com/ `lsb_release -cs`-0.10 main" \| sudo tee /etc/apt/sources.list.d/opscode.list

	sudo mkdir -p /etc/apt/trusted.gpg.d
	gpg --keyserver keys.gnupg.net --recv-keys 83EF826A
	gpg --export [email protected] \| sudo tee /etc/apt/trusted.gpg.d/opscode-keyring.gpg > /dev/null
	sudo apt-get update

	sudo apt-get install opscode-keyring # permanent upgradeable keyring
	sudo apt-get upgrade

	# Adapted from a C# example here:
	# http://stackoverflow.com/questions/43224/how-do-i-calculate-a-trendline-for-a-graph

	# And thanks to John Esser for helping figure out how to
	# calculate the targets to stabilize a negative slope!

	class LinearRegression
	attr_accessor :slope, :intercept

	# Pass in an array of values to get the regression on

	# Runs a specified shell command in a separate thread.
	# If it exceeds the given timeout in seconds, kills it.
	# Returns any output produced by the command (stdout or stderr) as a String.
	# Uses Kernel.select to wait up to the tick length (in seconds) between
	# checks on the command's status
	#
	# If you've got a cleaner way of doing this, I'd be interested to see it.
	# If you think you can do it with Ruby's Timeout module, think again.
	def run_with_timeout(command, timeout, tick)
	output = ''

	# install git
	sudo apt-get install g++ curl libssl-dev apache2-utils
	sudo apt-get install git-core
	# download the Node source, compile and install it
	git clone https://github.com/joyent/node.git
	cd node
	./configure
	make
	sudo make install
	# install the Node package manager for later use