Archive for the ‘XtremIO’s Random Thoughts’ Category

XtremIO Makes History with a Blowout Q4

Since early January, I’ve barely been able to keep a lid on my excitement.  That was the day when I received the Q4’14 sales report from EMC finance, which confirmed that XtremIO had just made history by becoming the fastest-growing enterprise storage product ever – for the company, and likely, the industry.

Reporting the results internally to the XtremIO team was the proudest moment of my career.  We had all worked tirelessly since introducing XtremIO in November 2013 to build the deal pipeline.  And by last summer, we all shifted into a new gear most of us didn’t know we had as we could feel we were on record pace to close out the year on December 31st.

Now that we have all caught our breath, and EMC’s leadership has announced Q4 earnings for the entire company, I can spend a few minutes to recap the highlights of XtremIO’s blowout results:

  • A near $300M quarter, with doubled Q/Q bookings. Q3’14 was fantastic at approximately $150 million. Then we doubled it again in Q4!  On the earnings call last week, David Goulden, CEO of EMC Information Infrastructure, said XtremIO is “by far the fastest growing product in the history of EMC… this is because XtremIO has the right architecture…” What he didn’t mention on the call, but has said many times before, is that XtremIO’s success is also due to the brilliant execution of the best worldwide sales force in the information infrastructure business.
  • XtremIO bested the competition. By a lot.  Our internal analysts estimate the all-flash array market was approximately $645 million in Q4, and we won 45% of those bookings. We believe the next closest all-flash array product captured 15% of the market.  There are many product-related reasons for our success, which we will cover in future blog posts.
  • More than 40% of the Fortune 200 bought XtremIO.  Dozens of large customers signed with XtremIO in Q4, helping us further establish dominance in the top of the market. Our mid-market penetration isn’t too shabby either: we now have 26% of the Fortune 1000. In addition, customers are buying larger XtremIO arrays and re-ordering from us frequently. We now have over 130 customers that have spent $1 million or more on XtremIO.
  • A stellar 2015 ahead.  Back in November 2014 when we celebrated XtremIO’s one-year anniversary, we announced a $500 million annualized run rate for Q3’14.  We more than doubled that run rate in Q4’14.  This year we have XtremIO 4.0 coming which will be simply amazing.  We will continue to define the All-Flash Array market, continue to drive XtremIO’s growth, continue to make history, and continue to break records.

It’s been no small feat to achieve all of this growth. It takes an amazing product, brought to market at the right time, with the right team. I am so proud to be part of this effort, and so excited about the year to come.

I’ll report back on our market progress in a few months.


The Short and Exciting History of the Enterprise Flash Market

Flash is one of the hottest, fastest growing enterprise technology markets in computing history.  While it just entered the mainstream in 2014, analysts are now predicting it to be well over a $1 billion market this year with sustained growth rates in excess of 50 percent per year for the foreseeable future.

And along the way, there have been many dynamic moments — as to be expected when such a disruptive technology gets invented and every incumbent vendor grabs for market share. Should you be listening to all the buzz?  Should you be looking to deploy this new technology?  The answer is yes, but only with the clarity of hindsight.


In the Beginning…

Venture capitalists began investing in flash storage companies in 2007.  By 2013, over $2 billion had been invested in more than 40 of them.

Perhaps the first notable startup in the flash space was Fusion-io.  In fact, as we were working with our early alpha and beta customers we often found Fusion-io was there too.  Fusion-io grew rapidly for a couple of years and executed a high valuation IPO in 2011, pricing shares at $19.   The company raised $233 million dollars (on top of more than $100 million of early-stage venture capital) at a valuation of $1.5 billion.  At one point, the stock rose to a $4 billion valuation.

However, the good times didn’t last, as Forbes reported:

“Fusion-IO is another company that has seen the venture capitalists cash out and stock investors get creamed.  It went public in 2011 at a sky high multiple of 41 times the previous year’s sales, valuing the company at $1.48 billion. Fusion IO raised $233 million in the IPO by selling shares for $19 each and the shares jumped to as high as $39.60 in its first five months as a public company. Since then the shares have crashed. Fusion-IO’s stock has plunged by 37% in 2013 and is now trading for 25% less than its IPO price.”

From mid 2012 until 2014 its shares continued to slide and SanDisk acquired it in July 2014 for $11.25 per share, for a total valuation of $1.1 billion.

Fusion-io stock price - IPO to Sandisk acquisition

Fusion-io’s stock price from IPO until Sandisk acquired the company


The Flash Arrays Cometh

The next flash contender was Violin Memory.  Whereas Fusion-io built PCIe cards installed into servers, Violin Memory was a pioneer in the concept of a flash array, the hottest part of the market today.  Violin gained significant prominence in 2012.  In an interview with Silicon Angle at EMC World that year, Violin’s CEO Don Basile stated (just as EMC was completing the acquisition of XtremIO):

“One of our partners, ICI, has us in one of the booths here, showing a great VDI solution using Violin….they’re a long-time EMC distributor and need some flash to go ahead and make those VDIs run and are demonstrating Violin in the booth.”

When asked about Violin Memory going public, Basile replied, “I think the public market has shown, and hats off to the Fusion[-io] management team today in that they’ve basically been able to derive a multi-billion dollar valuation in the public market – able to access capital.  And I think that we’re being asked to do the same thing.  Our customers, our partners are saying ‘go public, raise another few hundred million dollars of capital, grow Violin even faster to go ahead to take advantage of the opportunity’.  Cisco did it in its day, Google did it in its day, Netscape did it in its day.   It seems like the right thing to do for our customers, our employees, and our shareholders.”

Violin raised $250 million in venture capital, with its last round before its 2013 IPO valuing the company at $800 million.  At one point, the company was ranked #1 in flash array sales by IDC, with revenue of $74 million, but with losses for the same period of $109 million.

While Violin reaped $162 million during its IPO, its stock dropped 22 percent the first day of trading, leaving the valuation under $600 million — less than the $2 billion valuation Violin widely publicized it would get.  The stock has continued to drop since then, recently trading at a valuation under $450 million.

Violin Memory's stock price from IPO until today

Violin Memory’s stock price from IPO until today


Pure Storage’s Entry

Pure Storage was founded about the same time as XtremIO, and with a similar idea to deliver a high value, data services rich, purpose-built all-flash array.  To date, Pure Storage has raised nearly $500 million of venture capital at a $3 billion post-money valuation.  Similar to Violin, Pure gained early market traction, achieving solid market share rankings back in in 2013 from both IDC and Gartner.

Pure Storage is rumored to have an IPO in 2015.  Your guess is as good as mine as to how it will play out.  As we saw with the Hortonworks’ IPO filing last month, sometimes valuations that private investors are willing to give in earlier investment rounds do not reflect what public offering underwriters like Goldman Sachs are willing to support.  Just as we never knew the real revenues and cash burn rate of Hortonworks, we won’t know much about Pure until it files its S-1.


The XtremIO Factor

I’ve written about how far XtremIO has come in shaping the landscape of flash arrays.  Compared to the lofty capital raises and valuations of other flash storage companies, XtremIO had a much more sober history.  EMC didn’t disclose the purchase price for XtremIO, but it was widely reported as $430 million, right about where Violin Memory’s valuation is today.

XtremIO’s acquisition almost three years ago really wasn’t about the valuation (although at the time it was big news).  While the other flash companies have fallen to more reasonable levels, it turns out that the steadiest player, in terms of product innovation, company growth and customer service, is XtremIO.  We were acquired at the perfect time, at a non-disruptive price and plugged into the greatest storage company in the world — by an integration team that knew what it was doing.  It took some time to prove out that this was the best way to go, but now we have.  The benefit to our customers and prospects is the best of all worlds:  we never skipped a beat, we have outperformed all other flash storage companies and our plan is to continue our leadership path.

The magic of XtremIO is in the core technology and what we enable customers to do in their data centers, not in the valuation hype.  We’re as interested as ever to see if the latest flash startups can achieve and maintain their lofty valuations.   It’s a fun spectator sport, but that’s not what sets a company apart and it’s not anything you should pay attention to as a technology buyer.  You’re investing in your data center, not in the stock market.

XtremIO Just Got Better for Microsoft Environments

For quite some time now, XtremIO has been integrated tightly with vSphere, allowing the array to be configured and managed directly within vSphere.  As part of our ongoing efforts to integrate XtremIO tightly into application environments, we have just released support for similar integration in Microsoft environments.  The ESI (EMC System Integrator) 3.6 release, makes running XtremIO in Microsoft-based data centers easier and more flexible.

As usual our amazing Systems Engineer, Itzik Reich has provided a great write-up on these new capabilities.   And you can link to download ESI from the announcement page at the EMC Community site here.

Itzik also recorded a demo of ESI in action:

Small Things, Big Impacts

Remember that old saying about how a butterfly flapping its wings can affect weather patterns on the other side of the world?  How could such a small detail result in such a big impact?  While this saying is most likely hyperbole, nature is amazingly interconnected – in ways it has taken us decades to understand.  As we now know, small changes can have big impacts.

Today we announced a slew of new capabilities in the XtremIO array, most significantly three new inline data services, encryption, compression, and agile writeable snapshots.  On the surface these sound just like things you already know about that have been in storage arrays for years.  But scratch beneath the surface of the “feature check boxes” and there is much more utility and capability to be found with XtremIO.  This is possible because of some seemingly small things XtremIO did early on that are just now beginning to deliver their big impact.

XtremIO New Features Overview

XtremIO New Features Overview

Let’s look at those small things and the big impacts that come with them:

Small Thing – Software-centric architecture

The XtremIO architecture is entirely based on software innovation.  XtremIO arrays have no proprietary hardware – they use standard form factor SSDs, the drive shelf is shared across other EMC products, and the array controllers are standard x86 servers.

Big Impact – Rapid improvements and performance gains

With this release we not only introduce new features and inline data services, but the array’s performance also increases across the board, and by very significant amounts.  This is impossible to do with proprietary hardware – you’ve got to rev all the hardware in order make performance improvements, and oftentimes to add new features.  With XtremIO we can deliver innovation and performance with code updates.  And when x86 server generations improve, we will improve along with them.  The ability to automatically gain performance from the x86 server market frees our engineers to focus on software innovation, where we can provide superior differentiation.

Small Thing – Content Addressing

XtremIO arrays store data blocks in a unique way – according to their very contents, rather than by the traditional method of storing them by their logical block address.

Big Impact – Inherent Balance, Inline Deduplication, and Content Awareness

Content addressing delivers big impacts in three ways.  First, by leveraging the randomness of the content signatures, XtremIO arrays maintain inherent balance of everything, which makes them easy to setup (create a volume, map it to hosts), eliminates tuning (balance is inherent, there is nothing to tune), and ensures that maximum performance is always delivered since all scale-out system resources are employed evenly all the time on every volume.  The second benefit derives from the first.  Since the array is already calculating content signatures in order to place and balance data, it is a natural extension to track all past content signatures and know if any new block is a match.  This allows XtremIO arrays to deduplicate globally inline in the data path.  XtremIO delivers its amazing performance with inline deduplication because deduplication is an outcome of the content addressing process, not a separate feature.  And third, by tracking content signatures for inline deduplication, XtremIO arrays are content aware – they have the ability to understand if blocks already exist on the array.  The impact of this is already evident in how fast the array can clone virtual machines (hint – it’s all done with content signature metadata without the need to copy data blocks) and content awareness is an area where we will continue to innovate, both within the XtremIO array and across the EMC ecosystem of products.

Small Thing – Inline all the time

XtremIO was designed to process all data services inline, all the time.  The array doesn’t batch process.  It doesn’t post-process.  Data services do not throttle back in performance or switch off under load.

Big Impact – Flash Endurance with Consistent and Predicable Performance

The first big impact of inline all the time is that deduplication, and now compression, are performed before anything hits the flash.  Lots of vendors talk about being “inline”, but ask them to commit in writing that a duplicate block is never (NEVER!) committed to flash and they can’t.  We’ve guaranteed it with $1M.  There are two reasons this matters.  First is flash endurance – when duplicates are never written to flash and the remaining unique data is compressed before it gets to flash, the array will maximize its endurance (content addressing’s inherent balance also provides a significant endurance benefit as all the flash media sees an even number of writes) through write avoidance.  Second, when data services are inline all the time, performed on every single I/O right in the data path, the performance and latency profile is clear and unvarying.  Batch and post-processing cause performance profiles to change depending on when the processing occurs.  With XtremIO performance is always consistent and predictable because all data services are budgeted for on every single I/O.  Consistent and predictable performance is one of XtremIO’s hallmarks.

Small Thing – In-memory metadata

XtremIO arrays maintain all their runtime metadata in globally shared memory (having a scale-out architecture is a prerequisite for this).  This allows all metadata to be accessed at memory speeds without the need to read de-staged metadata from the flash (fast as flash is, it is still orders of magnitude slower than RAM).

Big Impact – Workload independence and Agile Writeable Snapshots

With metadata accesses always happening from memory, XtremIO arrays are insensitive to workload patterns that crush performance on other products.  Random or sequential, locality of reference or totally random, small volumes or large volumes – none of it matters on XtremIO.  The performance is always there.  XtremIO engineers built not only a rich set of inline data services, they figured out how to structure the metadata to fit in system memory.  This was already remarkable, but with today’s agile writeable snapshot announcement we take it from remarkable to game changing.

Snapshot implementations have been user data space efficient for years.  But until now, none have been metadata space efficient, especially for writeable snapshots.  This means that significant amounts of metadata build in the array as more writeable snapshots accumulate, bloating capacity consumption and forcing the metadata to de-stage out of memory, which causes performance to drop substantially.  This has held back snapshots from being used as a high performance tool.

XtremIO’s agile writeable snapshots are space efficient for both user data and metadata, which combined with the array’s in-memory metadata architecture means snapshots are now, for the first time, identical to their parent volumes in every way – performance (bandwidth, IOPS, latency, for both reads and writes), features (all inline data services remain active), and usability (take snapshots of snapshots of snapshots, rapidly delete from anywhere in the snapshot tree without impacting other snapshots or parent volumes).

XtremIO’s agile writeable snapshots completely eliminate brute force data copy operations that are commonly used today.  Application development and test environments can be instantly created off a master production volume, all with tremendous scale-out performance that allows R&D to work with the same high performance infrastructure as the production instance.  It’s a game changing business process innovation that leads to faster application development times and higher quality rollouts.  That’s a big impact.

The biggest impact of all this technology in XtremIO is that it’s accessible and surprisingly affordable.  XtremIO’s inline data services deliver incredible efficiency and utility out of small amount of physical flash.  Having the best capacity efficiency in the industry means that now a single XtremIO cluster with 90TiB of physical usable flash effectively (through inline deduplication, inline compression, and agile writeable snapshots) serves petabyte-scale application environments.  XtremIO’s ability to leverage and amplify such a small amount of flash into 10X or more value, all with consistent and predictable performance, all inherently balanced and easy to use, and with scale-out IOPS in abundance to handle even the heaviest consolidated workloads, is our big impact.

XtremIO is Redefining the Possible across the globe.  Since our general availability in November 2013, XtremIO has become the fastest growing storage array of any kind in history, and the #1 All-Flash Array in the market.  Our customers are doing one small thing…choosing XtremIO, and having a very big impact in their organizations delivering the speed, agility, and innovation that are highly visible to any consumer of IT.  And the best is yet to come.


XtremIO’s In-Memory Metadata Architecture – Fact and Fiction

During our launch last week we discussed the amazing benefits of XtremIO’s In-Memory Metadata architecture.  Some have seen fit to FUD this approach as risky – what happens to valuable metadata if a controller (or power) fails and memory contents are lost?  Believe it or not, we did think about these things when designing XtremIO.  So let us clear the air – in-memory metadata is a run-time capability of the array that significantly boosts performance. Metadata is not exclusively kept in memory.  It is also journaled, protected, and hardened to SSD and can tolerate any failure event in the array.  We couldn’t cover every detail of this during a one-hour launch event, so here’s what we didn’t have time to say last week.

To set the foundation, let’s briefly review the concept of metadata. In the context of storage systems, metadata is simply useful internal information managed by the array to describe and locate user data.  All modern arrays abstract the physical media and present logical (virtualized) addresses to clients in the form of LUNs.  The mapping between the logical address and physical address is a form of metadata that the array needs to manage.  That’s typically the most common form of metadata for SAN storage systems.  Newer architectures manage additional metadata to implement additional capabilities. For example, snapshots, change tracking for efficient remote replication, deduplication pointers, and compression all involve managing some form of metadata.

Computers operate on information in memory, so by definition if a system is performing metadata operations then the metadata must be in memory.  So why are we making a big deal about our in-memory metadata architecture?  That’s where the related concept of “working set” comes in.  The working set can be defined as the collection of information the system needs to operate for a given time interval.  In the current context, that’s all the metadata needed to service client data requests within some acceptable response time.  For All-Flash Arrays that “acceptable response time” is typically below one millisecond.

Depending on architecture and implementation, not all metadata may fit into memory.  If some metadata is part of the working set but not in memory, the array must first fetch it from media, then use it to figure out the next step, and finally perform the client data operation.  This adds latency to operations and creates inconsistencies in response times.  It also causes multiple accesses to the back-end array (the flash or SSDs) for every host I/O operation.  Under load, this added latency and extra back-end load can push systems beyond the acceptable response time, or lower their overall performance.  In addition, fetching new metadata bumps some other metadata out of memory.  In the worst case, the working set is larger than available memory and the array is constantly churning data and metadata through memory and having to issue double the I/O’s: one for metadata and the other for user data.

These effects are often masked by typical lab or proof-of-concept testing because working data sets are small.  In other words, if you have 20TB of flash and create 20 x 100GB LUNs to test the array, you’re only hitting 2TB, or 10% of the array’s addressable capacity.  This should easily allow metadata to be cached in the controllers.  But when the array is in production and is running 80% full, with a blended workload from many servers and applications, and little predictability in the I/O pattern (poor locality of reference) – exactly the kinds of conditions for which you invest in a flash array – the controllers will no longer be able to cache the metadata required for fast performance.  This has noticeable and sometimes very significant performance effects.

The problem is exacerbated with dual-controller designs.  Adding more flash capacity without a corresponding increase in memory means that less of the metadata on a percentage basis can be held in the controller RAM.  If a 20TB dual-controller flash array that could cache 20% of its metadata is expanded to 40TB it can only cache 10% of its metadata. At 80TB it can only cache 5% of its metadata.  The larger the array gets, the worse the performance gets.

EMC XtremIO is architected so that all metadata is always in memory.  This is possible because of three important aspects of the design:

  1. XtremIO is a true scale-out system. Larger capacity arrays also have more controllers, which in turn have more RAM to hold more metadata.
  2. XtremIO’s scale-out is based on N-way active controllers, networked together using Remote Direct Memory Access. Not only do we have the RAM to hold all metadata in memory, but that memory is aggregated and shared among all the controllers in the cluster. Any controller can utilize its own memory or the memory on another controller at incredible speeds. Note that having Infiniband (or any other high bandwidth low latency network) is necessary but not sufficient for the lowest latencies. Actually implementing RDMA semantics is required to take full advantage of Infiniband capabilities. With XtremIO, we fully leverage RDMA and Infiniband is not just a fast interconnect.
  3. XtremIO’s brilliant engineers spent a lot of time and effort designing hyper-efficient metadata structures that allow us to keep mounds of granular metadata (for every 4KB stored in the array) in a minimal RAM footprint. This is one of the many patent-pending technologies in the array. Some may think what we’ve done is impossible because they haven’t figured out how to do it.

With this unique architecture, we never introduce extra metadata latency because of access patterns. This is the advantage of having 100% in-memory metadata and why we’ve been making a big deal about our architecture. If you care about consistent, predictable performance, you’ll think this is a big deal too.

Now let’s take a look at some of common areas of confusion that have been floating around since our launch…

Perhaps the biggest misconception is that because all our metadata is in memory we don’t also have a copy of it safely stored on SSD. This misconception implies that we only bother to dump metadata to SSD on shutdown and power loss. Seriously?! EMC has been the leading provider of enterprise storage systems for decades and knows about keeping data safe.

Every metadata update made on an XtremIO controller is immediately journaled over RDMA to other controllers in the cluster. These journals are persisted to SSD using an efficient write amortization scheme that coalesces and batches updates to more efficiently use the flash media and avoid write amplification.  Metadata is protected on flash using XDP (XtremIO Data Protection) and other techniques.  This is ultra safe and tolerates any type of failure, not just power outages.

Which is a good segue to another question some have raised about the need for battery backup units instead of NV-RAM.  About this we have two things to say.  First, battery backup has been used in enterprise storage systems for decades. So we’re not forging any unknown territory here.  Second, while NV-RAM has its merits, there is no NV-RAM on the market that can keep up with the performance of XtremIO. We certainly could have placed an NV-RAM card in our controllers and built a 50,000 IOPS system, but that would be way off the mark in performance.  Some solutions use mirrored SLC SSDs as their NV-RAM device.  Performance is thus bottlenecked by how fast the SLC device can go.  No matter how large the array grows, performance is always choked at that single point in the architecture.  Battery-backup isn’t needed, but you don’t get the flash performance you paid for.  Sometimes super-capacitors in the power supplies are used, which is nifty – but this is only feasible when there is no metadata to protect.  Arrays that use this technique have no thin provisioning, no deduplication, no magic VM cloning – nothing.  They are just a box of flash.

Now, back to In-Memory Metadata on XtremIO.  The way XtremIO works is no different from how other modern arrays handle metadata updates.  Where we’re different is that we only have to read metadata from SSD once: when the storage controller starts.  It means all metadata operations are handled in memory and never require additional round trips to the SSDs.  Fetching metadata from SSD impacts both read and write operations: even when metadata is being updated, it’s usually first read.  Having all XtremIO metadata in-memory gives us incredible VMware VAAI performance since all client operations just access memory before being acknowledged.  The result is consistent, predictable performance across all workloads; something that can’t be matched by architectures that need to read metadata from flash as part of client requests.  As more applications are consolidated and virtualized and the “I/O Blender” effect intensifies, this benefit will continue to grow in importance.

Another thing to consider is how the XtremIO journals are implemented.  We can complete mirrored journal writes very quickly thanks to fast DRAM access times over our low latency RDMA cluster fabric.  We considered other options like using NV-RAM (see above), dedicated RAM devices, and even a “faster” class of SSDs (see above) as the journal device.  And we rejected them all.  They introduced too much latency, complexity (risk for bugs), or bottlenecks.  All of these may have been acceptable choices when dealing with spinning disks or even hybrid storage where media access times are measured in multiple milliseconds.  For All-Flash Arrays, keeping as much of the activity in main system memory is the best way to achieve consistent, predictable performance and low latency.

Another misconception is that we use local SSDs in the X-Brick storage controllers to hold our metadata.  That’s mostly incorrect. The persistent storage medium for our metadata is the bank of 25 SSDs in each X-Brick DAE (SSD shelf). We distribute and protect the metadata across all those SSDs using XDP for precisely the same reason that we store user data there: speed and reliability.

In normal operations we read all the metadata only once from the DAE at boot time.  After that, we reliably synchronize changes back to the DAE after first journaling and mirroring the changes across controllers using RDMA.  When the cluster is stopped, it pushes out any final updates to the DAE so that everything will be there when the system is started again.  It’s only in the case of an emergency shutdown that local drives in the storage controllers may be used to persistently save any unsynchronized metadata updates.  Even then, only certain failure scenarios prevent the metadata from being saved to the DAE.  We’ve carefully considered all the various ways that storage systems can fail, and architected XtremIO to provide the performance and reliability EMC customers have come to expect.

XtremIO at EMC World Area 51

For those who weren’t able to attend in person, here’s a link to the Area 51 presentation XtremIO gave at EMC World on May 19th. Watch at 1:03:00 (One hour three minutes) into the video for the XtremIO section. And if you’re really sharp, see if you can find the hidden XtremIO reference in the Area 51 opening sequence.

Five Ways XtremIO Helps With Capacity Management

There are two types of storage sprawl. The first results from the never-ending creation of new content that must be retained. This type of sprawl is typically capacity driven and while storage must be purchased to keep pace, often inexpensive large capacity SATA arrays are more than sufficient to do the job.

The second type of storage sprawl results from performance-oriented applications. While it may not lead to as many terabytes deployed in the data center and thus isn’t typically thought of as a capacity problem, this type of sprawl represents the most expensive portion of the storage environment because it is reliant on enterprise class disk drives in high-performance arrays, which are much more expensive (and smaller in capacity) than SATA drives. In these environments, several factors lead to storage sprawl, but often administrators don’t even recognize the problem because it has existed for so long it’s just accepted as “the way things are.”

On XtremIO customer calls, we frequently hear things along the lines of “we don’t have a capacity problem” or “we don’t have a performance problem” because the customer has an environment that is currently meeting their needs. It’s interesting as you dig deeper and look at what it took to “not have problems.” What we find is very consistent and paints a crystal clear picture of how inefficient current storage environments are. I’d encourage you to think about your own storage environment in this context.

Inefficient Storage Practices

  1. Using RAID 10 – RAID 10 is commonly used in performance-oriented environments because it provides excellent read performance (there are two distinct copies of the data residing on separate groups of drives which can be read in parallel) with low overhead for writes (each host write results in two array writes, one to each side of the mirror). Of all the available RAID levels, RAID 10 delivers the best performance, but at the high cost of requiring twice the number of drives for data protection. Losing 50% of your raw capacity to data protection overhead right from the start is a stiff price to pay for performance, especially when using expensive 15K RPM enterprise drives.
  2. Gaining performance by stranding capacity – This often happens in database environments. Imagine a company with an SAP environment running on Oracle. The SAP database is 3TB in size but needs 30,000 IOPS. While the database will physically fit on just a couple of large capacity drives, it will not deliver the required performance if provisioned that way. So instead, it is striped across dozens of spindles (easily 100+ in this example). Assuming a common 15K RPM drive size of 300GB, this database is now consuming 30TB of storage (before factoring in data protection overhead), even though it is only 3TB in size. Unfortunately the extra capacity is often useless as allocating it to any other applications would subtract from the performance required in the SAP/Oracle environment.
  3. Ineffective multipathing – Multipathing, the technique of allowing hosts to access storage over parallel connections to improve performance (and reliability in the case of a path failure), is essential to driving the best I/O performance from a storage array. In many array designs, all paths are not created equal. There is a fast path that goes through the storage controller that owns the LUN, and a slow path that goes through an alternate controller without LUN ownership. This hinders the ability of the application to drive I/O into and out of the array and leads to over provisioning to compensate.
  4. Spare drives – Storage arrays maintain spare drives to allow RAID rebuilds to begin the moment a drive fails. At all other times spare drives are just added cost and capacity that is unavailable to use.
  5. Inability to use snapshots – Snapshots are powerful tools for data protection, but also can be used for making space-efficient volume clones. This is helpful in development and test environments to make quick copies of the production volumes. However, when actively used, snapshots deliver inferior performance, especially over time as their contents diverge from that of their parent volume. When snapshots can’t be used effectively, full volume clones must be created, consuming additional spindles.
  6. Inability to fill the array – Storage arrays degrade in performance as they fill up. Even high-end enterprise arrays start to see performance trail off with as little as 40% of the array filled. This forces administrators to run the arrays with large amount of free space that is stranded capacity. It’s there, but you can’t touch it.
  7. Inability to use data reduction – Data reduction techniques can substantially lower the amount of capacity required, especially in certain environments where duplicate data is common, such as virtualization. However, deduplication techniques are computationally intensive and inherently lead to volume fragmentation. Both of these issues substantially reduce performance and prevent data reduction from being utilized with performance sensitive applications.
  8. Mismatched thin provisioning – Thin provisioning is a powerful tool to more efficiently allocate capacity within an array and defer capacity purchases. However, thin provisioning schemes typically use allocation sizes far larger than the I/O sizes used by applications and operating systems. This mismatch causes over-allocation of capacity out of the thin provisioning pool, and leads to stranded, unusable capacity, and the need for the array to run performance sapping reclamation operations.

It’s easy to see how inefficient storage provisioning becomes. Think back to our example of a 3TB SAP/Oracle database needing 30,000 IOPS. Imagine if you bought 36TB of performance disk (120 x 300GB 15K drives). 50% remains off-limits in order to preserve array performance. You have 18TB left. Thin provisioning inefficiency reduces this another 10% to 16.2TB. You lose another 600GB for a couple of hot spares and are down to 15.6TB. You have to use RAID 10, so now you’re down to 7.8TB. That’s more than enough for your 3TB databases, but the remaining 4.8TB of space is useless to you since all 30K IOPS are consumed by the SAP/Oracle application. Your storage efficiency ratio? A dismal 8.3% (3TB/36TB).

Even worse is you have to purchase additional storage in order to support the SAP/Oracle development and test environment. This may be a less expensive SATA array, but it still costs money, takes up space, burns power, and requires administration.

Ahhh, but you say, disk is cheap. Certainly less expensive than the SSD arrays XtremIO sells. And you are correct. On a $/GB (raw) basis flash is substantially more expensive than disk. But let’s look at what it took to get the job done. The SAP/Oracle production array in our example above would cost roughly $5/GB or $180,000 (36,000GB x $5/GB). An array to handle the development/test environment will run another $2/GB, which works out to roughly $100,000 to get enough space for a handful of database copies. $280K total street price for support of this one application. I feel very comfortable saying that for this price you could have a shiny new XtremIO flash array that would easily support both the production and development/test environment we just described with vastly more performance, simplicity of operation, future expandability, and operational efficiency.

How can that be? It’s because XtremIO’s all-SSD design doesn’t just give you faster storage, it gives you better, more efficient storage. Here are five specific ways XtremIO helps better manage capacity and storage sprawl, in contrast to the picture painted above.

Five ways XtremIO helps with Capacity Management

  1. Efficient data protection – You don’t need to run RAID 10 mirroring in order to get amazing performance from an XtremIO array. This isn’t just because we use flash and rely on speed to make up for the inefficiency difference. XtremIO arrays use a patent-pending flash-specific data protection algorithm that requires very little capacity overhead yet outperforms all existing RAID algorithms. In an XtremIO array, more of the capacity you purchase is available for your data.
  2. Easily accessible performance – With XtremIO you don’t have to think about how many spindles (or SSDs in our case) are needed to get to a desired performance level. When you configure a volume it automatically gets the full performance potential off all the SSDs in the array. And if you want more performance, you can always scale-out the system. The problem of stranded capacity simply vanishes.
  3. Higher array capacity utilization – XtremIO arrays can be run to capacity without degrading in performance. You don’t have to leave huge percentages of free space in order to get the best results. Again, you get to use more of what you paid for.
  4. Efficient data reduction – XtremIO storage automatically deduplicates data in real-time without impacting the array’s performance. You’ll store less and make the most effective use of SSD capacity, and what needs to be stored will be kept with minimal overhead.
  5. No other wasted space – We’ll provide more details about this in the future, but suffice it to say here that XtremIO storage doesn’t have the limitations with respect to snapshots, thin provisioning, spare drives, or multipathing that exist in other systems.

Next time you walk through your data center, take a good look at the refrigerators full of drives and think about how much of it is just wasted space causing sprawl and needless expense. Flash may cost more on a $/GB basis, but if you need far fewer GB to get the job done, you might find it surprisingly cost effective.

You Should Expect More From Flash Storage

Anybody who knows me knows that I’m a certified car nut. When I was in engineering school I thought I would work in the automotive industry (but that’s another story) because I had such a strong appreciation of design and performance. I have an affinity for two types of cars; supercars (Ferraris, Lamborghinis) and powerful sedans (BMW M5, AMG Mercedes). What astounds me about the latter category is that when executed well they provide nearly the same performance as the supercars, but have room to seat four, comfortable luxury amenities, return better gas mileage, and all around are more practical and easy to live with in nearly every situation. They’ll even give the supercars a run for their money at the occasional track day. In fact, they are so good that one should really question why you’d ever buy a supercar. I can think of only a couple of reasons. The first is design. Supercars are indeed beautiful. The second is outright performance. If you need to eek that last tenth of a second off your lap time, the supercar is the way to go. But in nearly every conceivable real-world situation, the powerful sedan is the better choice.

Flash storage products on the market today are analogous to supercars. They’re fast and sexy, but expensive and impractical for most use cases. Just like supercars, you sacrifice many features and amenities in the pursuit of ultimate performance. In fact, we hear many customers tell us that the only reason these products have been deployed is because they were the only option in the market. Imagine a world where your car options were limited to a Toyota Camry or a Ferrari. Ferraris are awesome, but they’re not affordable, utilitarian, or comfortable to drive most of the time. In today’s storage world, if you need more than Camry performance, you have little choice but to buy a Ferrari flash storage product.

At XtremIO, we don’t believe you should have to make this type of tradeoff. In fact, we believe that you should expect far more from your flash storage array than what is on the market today. Our storage system is analogous to the BMW M5 or AMG Mercedes – packed with amenities, tons of performance, and easy to live with in a wide variety of use cases. In fact, we’re even better in two ways. First, if you want Ferrari – or even Formula One performance – our system easily scales to deliver it and more. Our scaling is so powerful it actually goes far past Formula One performance and is more akin to having a fighter jet. Second, our technology is so efficient that you don’t have to pay a huge premium in order to get it. After all, fighter jets, Formula One cars, Ferraris, BMWs, and Mercedes are more expensive than a Camry. XtremIO’s flash storage array is total cost of ownership competitive with the disk arrays you already own. To sum up, you get any level of performance you need, all the enterprise storage features you expect, a system that is easy to live with day to day, and capabilities that simply don’t exist in other storage systems. I’ll be writing more about that last statement in future posts.

If the automotive industry delivered better than Formula One performance with the features and amenities of a luxurious sedan, AND with the price, economy, and reliability of a Camry, it would forever alter the landscape of the business. XtremIO is leveraging flash to deliver just such a step function in enterprise storage. You literally can have it all. If you think this sounds too good to be true, I strongly encourage you to register for our Early Access Program and try XtremIO for yourself. Fair warning – you won’t want to give it back.

What’s Extreme about XtremIO?

Welcome to the XtremIO blog. This is the place to read about our company and products, but also to learn about flash storage and how it is applied to improve performance, ease-of-use, and efficiency for several different application environments including databases, ERP applications, analytics, and virtualization.

Let’s begin with an anecdote about XtremIO. A good place to start is with the pronunciation of our company name. The correct way to say it is, “Extreme Eye Oh”. Some common incorrect pronunciations are “extreme-ee-oh” and “ex-tremm-ee-oh”. We’ll still answer to these, but it’s best to set the record straight. Now that we have that out of the way, let’s talk about why we chose this somewhat hard-to-pronounce name. It is common knowledge that server and networking technologies have followed Moore’s Law for many years while storage performance has badly lagged due to the limitations imposed by hard disk drives. This has created an I/O (input/output) bottleneck. We have the capability to create and process vast amounts of information, but we lack the ability to rapidly move it on and off of persistent storage. Meanwhile, the cost and complexity involved in trying to close this storage performance gap has become acute. What’s needed is a new approach to storage – one that is extremely ease-to-use, extremely efficient in the data center (in terms of space, power, and cooling requirements), extremely scalable so it can keep pace with Moore’s Law, and deliver extreme utilization rates (usable capacity, consistent performance). In a nutshell, we need extreme I/O capability to match our extremely powerful servers, extremely fast networks, and extremely efficient virtualized data centers. Thus, XtremIO was coined.

XtremIO was founded in 2009 by a very experienced team of engineers with a vision of leveraging flash technology to provide a step function in every aspect of storage systems. Flash is gaining wide acceptance in the data center today because of its performance potential, and as you’ll see, XtremIO takes the performance of flash to new heights. Performance is an important piece of our story, but it is only the beginning. Our team realized that by engineering a storage system around random access media such as flash (rather than sequential media like disk) incredible gains in efficiency, functionality, and ease-of-use could also be realized. So XtremIO storage is amazingly fast and scalable, but it is also the easiest storage to use that you’ll likely ever encounter and incredibly efficient in every dimension. This is important, because one of our goals is to make enterprise-grade flash storage arrays accessible to a broad market. All the technology in the world doesn’t help if the resulting product is priced out of reach of existing storage budgets. So one area where we are not “extreme” is in our cost of ownership. In fact, in many environments XtremIO storage will cost less than the disk storage it is replacing.

Thank you for following us. We are very excited about what we’re building and eager to share more details in the coming weeks. Stay tuned.

Visit for more information on all-flash storage