Isaac Newton, SPC-1, and The Real World


The SPC-1 is an industry recognized storage performance benchmark developed by the Storage Performance Council to objectively and consistently measure storage system performance under real-world high-intensity workloads (principally, OLTP database workloads).


Over the last four years, the storage industry has transformed at an amazing rate. It seemed almost every other week, another software-defined storage startup emerged. On the surface this appears great, right? Lots of competition, lots of choice, etc. However, with all of this also comes lots of confusion and disappointment. What is actually new with all of these developments? Are there truly pioneers out there taking us into new and uncharted territory? Let’s go exploring!

Isaac Newton and the SPC-1

Wait, What? How in the world does Isaac Newton relate to the SPC-1? As you may know, Newton was the founder of calculus, discovered the laws of motion and gravity. He is unquestionably one of the most notable scientists in history. Without him, we don’t have much of the modern world that we enjoy today. While some appreciate what he accomplished technically speaking, most people do not go around citing the intricacies of Newtonian Mechanics. However, we do appreciate the result of his discoveries: cars, planes, space shuttles, sending satellites to other planets, and many other amazing things. So, while these things are necessary to operate in the modern world, they are generally reserved for the areas of academia. Such is the case with the SPC-1.

This article has one simple objective. It is focused on drawing the parallel of what the SPC-1 demonstrates to implications in the real world. Similar to Newtonian Mechanics, most do not walk around citing SPC-1 results. However, just like with Newton, the results have real world implications specifically to the information technology world; a world which we are all deeply connected to in one way or another.

What Does The SPC-1 Show Us and… “So What?”

The SPC-1 analyzes all out performance and price/performance for a given storage configuration. While not showcased, latency analysis is also included within the full disclosure report for each benchmark run. The importance of latency will become apparent later in this article. But in the end, who doesn’t want performance, right?

One question that usually jumps out after referring to the SPC-1 results is, “so what?”. Well as it turns that is precisely what I am trying to answer here. On the surface there is basic vendor performance comparison. The higher the IO per second, the better the all-out performance is. The lower the $/IO the more cost efficient a system is. What happens when a vendor is able to achieve top performance numbers and price/performance numbers on the same benchmark run? Now that would be interesting.

Generally speaking, you will not find the same vendor system in the top 10 for both categories simultaneously mainly because the two categories fall at opposite ends of the spectrum. Typically, the higher the IOps produced, the more expensive the system and conversely, the lower the $/IO, the lower the total overall performance.

So hypothetically speaking, what would it mean if a vendor was to construct an individual storage system that landed in both categories? First off, it would mean that the system is both really fast and really efficient (one could argue that it is really fast because it is really efficient). Second, it would raise certain questions about how storage systems are constructed. In other words, it would be like having a Bugatti Veyron with a top speed of 268 mph for the price of a Toyota Camry. It wouldn’t just be interesting; it would change the entire industry.

If your next response is, “But I don’t need millions of IOps”, you would be missing the point completely. Ok, so you don’t need millions of IOps, but you get them anyways. What you need to realize is that you don’t need as many systems to achieve your goal in the infrastructure. In other words, why buy 10 of something when 2 will do the job?

What I am driving toward here is this: imagine how much more performance you could get for every dollar spent, imagine how much more application and storage consolidation you could get while simultaneously reducing the number of systems, imagine how much more you could save on operational expenses with less hardware, imagine running hundreds of enterprise virtual machines with true data and service high-availability in an N+1 configuration while simultaneously serving enterprise storage services to the rest of the network. Oh, the possibilities.

Below are examples of one type of convergence you can achieve with a system such as this. The server models shown below are used for illustration purposes, but it could be Lenovo, Dell, Cisco, or any multi-core x86-based system available in the market today. While traditional SAN, converged, and hyper-converged models are also easily achievable and have been available for many years, the model shown below represents a hybrid-converged model. It provides the highest level of internal application consolidation while simultaneously presenting enterprise storage services externally to the rest of the infrastructure. Without DataCore SANsymphony-V, this level of workload consolidation wouldn’t be possible.



So, Does This System Actually Exist?

As it turns out, this isn’t theoretical, it is very real. It has been very real for many years now. DataCore’s SANsymphony-V software is what makes this possible. DataCore’s approach to performance begins and ends with software. This is completely opposite of all other vendors who try to solve the performance problem by throwing more expensive hardware at it. And this is precisely why for the first time (from what I can tell), a vendor (specifically DataCore) landed on both top 10 categories (price and price/performance) simultaneously with the same test system.

And What About This Matter of Latency?

There still tends to be a lot of talk about IOps. As I have been saying for years now, IOps is a meaningless number unless you have other pieces of information regarding the test conditions such as % read, % write, % random, % sequential, and block size. Then, even with this information, it only becomes useful when comparing systems that have been tested with the same set of conditions. In the marketing world, this is never the case. Every storage vendor touts some sort of performance achievement, but the numbers are incomparable to other systems because the test conditions are different. This is why the SPC-1 is so significant. It is a consistent application of test conditions for all systems making objective comparison possible.

One thing that is not talked about enough, however, is latency, and specifically the latency across the entire workload range. Latency is what will define the application performance and user experience in the end.

In general, when comparing systems, IOps are inversely proportional to latency (response time). In other words, the higher the IOps the lower the latency tends to be and vice versa. Note, this is not always the case because there are some systems the deliver decent IOps, but terrible latency (primarily due to large queue depths and/or queuing issues).

DataCore SANsymphony-V not only set the world record lowest price/performance number, not only landed in both top-10 categories for the same test system, but also set a new world record in terms of the lowest latency ever recorded by the SPC-1… sub-100 microseconds! Interestingly, the most impressive part, which you could miss if you are not paying attention, is that they achieved this world record latency at 100% workload. This is simply staggering! Granted, you may not run at an all-out 100% workload intensity, but that just means your latency will be that much lower under normal conditions. The analogy here is the same Bugatti Veyron mentioned earlier running at top speed while towing 10 tractor-trailers behind it.

Below shows a throughput latency curve comparing DataCore SANsymphony-V to the previous fastest response time on the SPC-1 benchmark (the fastest one I could find in the top-10 at least). Notice how flat the latency curve is for DataCore. This is indicative of how efficient DataCore’s engine is. Not only did DataCore SANsymphony-V post better than 7x latency numbers (at 100% workload) against Hitachi, it also drove an additional 900,000 SPC-1 IOs per second. And finally, it achieved this result at a cost of 1/13th the previous record holder!


How was this accomplished? Simply put, it is baked into the foundation of how DataCore moves IO through the system, in a non-interrupt-real-time-parallel fashion. In other words, DataCore doesn’t just “not get in the way”, it actually removes the barriers that normally exist.


Hopefully by now you can see the answer to the “so what” question. These SPC-1 results go well beyond just a storage discussion. This directly impacts the way applications are delivered. You can now achieve what was once impossible. Is it virtual desktops you are after? Imagine running 10x more with less hardware without sacrificing performance. Is it mailboxes you are after? Imagine running 20x more with less hardware without sacrificing performance. Is it database performance you are after? Imagine running on the fastest storage system on the planet (not my words, the SPC-1’s findings) with the lowest latency and doing it at a cost that is untouchable by other solutions (hardware and software-defined alike). So while the SPC-1 is rooted in storage performance, the effect this has on the rest of the ecosystem is beyond just interesting… it is revolutionary!


Storage Performance Council Website
SPC-1 Top Ten List
DataCore Parallel IO Website

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s