Jon Hoffman hoffrocket

Use a 64-core PCI-E board (Made by Tilera: http://www.tilera.com/sites/default/files/productbriefs/TILEncore-Gx36_PB028-02.pdf ) with two onboard 10GB NICS in in-line mode, each core can run its own copy of a hard real-time (RTOS) BSD microkernel with a shared RDMA buffers ad/or a group of CPUS can be run in SMP or parallel mode for heavy calculations.

Pin the market data to as single core or multiple cores (e.g. one for tick data, one for completed orders). Offload all TCP (TOE, and a few dozen settings) to the NIC chips and share a revolving buffer using RDMA (this provides a lock-free mechanism with no mutexes, no context switching, and no buffer copying).

Cascade the market data into additional cores in SMP or Parallel mode (depending upon the calculation attributes) for quantitative algorithmic calculations (e.g. in-stream Kalman filters, SMC/UPF, ANNs etc.). Outbound orders on the second NIC fed by a microkernel pinned to a single core.

Configuration is also be used for ultra fast order cross

	db.getCollectionNames().forEach(function(n){
	var shardConfig = db.getSisterDB('config').collections.findOne({_id:"foursquare." + n},{key:1});
	if (shardConfig){
	var shardKeyNameParts = [];
	for (var keyPart in shardConfig.key) {
	shardKeyNameParts.push(keyPart + "_" + shardConfig.key[keyPart]);
	}
	var shardKeyName = shardKeyNameParts.join('_');
	var shardKeySizeMb = Math.round(db[n].stats().indexSizes[shardKeyName]/1024/1024);
	db[n].getIndexes().forEach(function(i){

	import java.io.ByteArrayInputStream
	import java.io.ByteArrayOutputStream
	import java.io.EOFException
	import java.io.InputStream
	import java.io.OutputStream

	import org.bson.BSONCallback
	import org.bson.BSONObject

	import com.mongodb.DBCallback

	#!/usr/bin/env python

	from multiprocessing import Process, Pool
	import time
	import urllib2

	def millis():
	return int(round(time.time() * 1000))

	def http_get(url):


	import java.io.ByteArrayOutputStream
	import java.io.OutputStreamWriter

	object WriteBufferTest {

	def writeData(appendable: java.lang.Appendable) {
	var i = 0
	while (i < 1000) {
	appendable.append("hello there ").append(i.toString())

	import static org.junit.Assert.*;

	import org.junit.Test;

	public class TimeTest {
	private final static long nanoTimeOffset = (System.currentTimeMillis() * 1000000) - System.nanoTime();

	public static long currentTimeNanos() {
	return System.nanoTime() + nanoTimeOffset;
	}

	package jon.trace;

	import java.io.IOException;
	import java.io.OutputStream;
	import java.io.PrintWriter;
	import java.net.InetSocketAddress;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;
	import java.util.concurrent.Executors;

	#!/usr/bin/env python

	import atexit
	import datetime
	from datetime import timedelta
	import logging
	import os
	import smtplib
	import subprocess as sub
	import sys

	import java.util.HashMap;
	import java.util.Map;

	public class LRUCache<K, V> {

	private final Map<K, Pair<Node<K>, V>> map = new HashMap<K, Pair<Node<K>,V>>();
	private Node<K> head = null;
	private Node<K> tail = null;
	private final int maxSize;

	#!/usr/bin/env python

	import memcache
	import re
	import subprocess
	import sys

	KESTREL_HOST = 'localhost:22133'

	def record(name, value):