Martin.Thompson

Martin Thompson

High Performance & Low Latency Specialist

Martin is a high-performance and low-latency specialist, with experience gained over two decades working on large scale transactional and big-data systems. He believes in Mechanical Sympathy, i.e. applying an understanding of the hardware to the creation of software as being fundamental to delivering elegant high-performance solutions. The Disruptor framework is just one example of what his mechanical sympathy has created. Martin was the co-founder and CTO of LMAX. He blogs at mechanical-sympathy.blogspot.com, and can be found giving training courses on performance and concurrency, or hacking code to make systems better.

Practicing at the cutting edge: Learning and unlearning about Java performance
Track: Java at the Cutting Edge

Location:
Grand Ballroom A

Abstract:
They say that wisdom comes with age. Like many concepts in software, we have an imperfect proxy here. Age being the imperfect proxy for experience, discovery, and learning. When pushing a technology to the limits of performance one has a lot to learn and then unlearn over time as the language, runtime, operating systems, and hardware evolves. Martin will reflect on his experience with Java since its inception. Starting with building financial GUIs to run on OS2 and NT, then the era of Servlets and J2EE, streaming data and media concurrently to thousands of devices, processing and indexing the largest catalogues, encryption on mobile phones, LMAX and the Disruptor, and the current generation of low-latency trading applications that must cope with millions of events per second with latency measured in the microseconds. The talk will focus on the major steps in the evolution of Java and how it contrasts to C/C++ over time. We will also cover the challenges of pushing the limits of performance and how we need to collaborate with industry experts and organise our teams, which often stands at odds with the development culture in many industries and organisations.
Java vs. C/C++ Performance Panel
Track: Java at the Cutting Edge

Location:
Grand Ballroom A

Abstract:
This is a question that almost everyone doing a major project asks: should I use C++, or Java, or C#? Maybe it is more abstract than that, such as, should I use native code, like C++, or a managed runtime, like Java? Mostly, this is a matter of taste. Or is it? When it comes to ultimate performance, most applications are native, C++/C, with even having some hand crafted assembler mixed in.

But can Java, or any managed runtime in general, do nearly as good? Or maybe it could do better than native code. What could applications do to leverage the most out of these languages? With C++11, has the game changed? With Java 7 or 8, has the game changed? Or has the game really changed with the acceptance of Erlang? These and more, fellow developers, will be questions asked on this panel. It is native code vs. managed runtime in the game of performance!
Top 10 - Performance Folklore
Track: Scalability, Availability, and Performance: Putting It All Together

Location:
Bayview A/B

Abstract:
Building high-performance systems is tough. Today this is especially tough since a lot of the common wisdom for what makes a system high-performance is misleading at best, and often just plain wrong. This talk aims to expose the myths and folklore commonly found on the web related to building high-performance systems. Martin will cover his updated Top 10 performance myths that even experts building high-performance trading or big data systems fall prey to. Taking an approach of "measure everything" has been an enlightening education into what works, and what doesn't, when trying to achieve high-throughput at low-latencies. This talk highlights the findings of working on systems requiring the extremes of performance and how they truly test any high-performance systems design. Topics covered will include Java, concurrency, operating systems, functional programming, and how hardware really works.

Lock-free and high-performance concurrent algorithms
Location:
Seacliff B

Duration:
Full Day

Abstract:
Candidates in this workshop will be introduced to a completely new way of thinking about concurrent programming. By taking a hardware up, rather than theory down, approach you'll learn how modern x86 hardware operates and how when you show sympathy for this hardware your algorithms will absolutely scream. In addition to learning the basic techniques of building high-performance data structures, a performance testing and profiling discipline will be introduced that is fundamental to working at the extremes of systems performance. Understanding Mechanical Sympathy Performance considerations on modern hardware How modern x86-64 hardware informs concurrent and high performance programming techniques Memory models for software and hardware Why contention of any type is the enemy and how to avoid it How we manage contention when we absolutely must How the JVM provides support for concurrent programs Profiling and performance testing Concurrent and High-performance Algorithm Design Lock-free concurrency primitives Signalling state change Ensuring order Concurrent data structures Candidate Requirements Experience of the Java Programming Language. A laptop capable of running 4 concurrent threads - This can be a dual core with hyperthreading enabled Java 5+, and Ant 1.8+ installed, plus IDE of your choice More advanced profiling techniques can be demonstrated if running Linux