{"id":670,"date":"2010-07-09T05:04:00","date_gmt":"2010-07-09T05:04:00","guid":{"rendered":"\/blogs\/paul\/post\/Benchmarking-Introducing-SSDs-(Part-2-sequential-inserts).aspx"},"modified":"2013-01-01T21:06:46","modified_gmt":"2013-01-02T05:06:46","slug":"benchmarking-introducing-ssds-part-2-sequential-inserts","status":"publish","type":"post","link":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/","title":{"rendered":"Benchmarking: Introducing SSDs (Part 2: sequential inserts)"},"content":{"rendered":"<p>\n<font face=\"verdana,geneva\" size=\"2\">Over the last month we&#39;ve been teaching in Europe and I haven&#39;t had much time to focus on benchmarking, but I&#39;ve finally finished the first set of tests and analyzed the results. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">You can see my benchmarking hardware setup <\/font><a href=\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-hardware-setup\/\"><font face=\"verdana,geneva\" size=\"2\">here<\/font><\/a><font face=\"verdana,geneva\" size=\"2\">, with the addition of the Fusion-io ioDrive Duo 640GB drives that <\/font><a href=\"https:\/\/www.sqlskills.com\/blogs\/paul\/new-hardware-to-play-with-fusion-io-ssds\/\"><font face=\"verdana,geneva\" size=\"2\">Fusion-io were nice enough to lend me<\/font><\/a><font face=\"verdana,geneva\" size=\"2\">. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">In this set of tests I wanted to check three things for a sequential write-only&nbsp;workload (i.e. no reads or updates) <\/font>\n<\/p>\n<ul>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Best file layout with the hardware I have available <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Best way to format the SSDs<\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font size=\"2\">Whether SSDs give a significant performance gain over SCSI storage<\/font>\n\t<\/div>\n<\/li>\n<\/ul>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">The Fusion-io SSDs can be formatted four ways: <\/font>\n<\/p>\n<ul>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Regular Windows format <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Fusion-io&#39;s format <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Fusion-io&#39;s improved write performance format <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Fusion-io&#39;s maximum write performance format <\/font>\n\t<\/div>\n<\/li>\n<\/ul>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">I&#39;m using one of the 640GB SSDs in my server, which presents itself as two 320GB drives that I can use individually or tie together in a RAID array. The actual capacity varies depending on how the drives are formatted: <\/font>\n<\/p>\n<ul>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">With the Windows and normal Fusion-io format, each of the 320GB drives has 300GB capacity <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">With the improved write performance format, each of the 320GB drives has only 210GB capacity, 70% of normal <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">With the maximum write performance format, each of the 320GB drives has only 151GB capacity, 50% of normal <\/font>\n\t<\/div>\n<\/li>\n<\/ul>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">In my tests, I want to determine whether the loss in capacity is worth it in terms of a performance gain. The SSD format is performed using Fusion-io&#39;s ioManager tool, with their latest publicly-released driver (1.2.7.1). <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">My tests involve 16 connections to the server, running server-side code to insert 6.25GB each into a table with a clustered index, one row per page. The database is 160GB with a variety of file layouts: <\/font>\n<\/p>\n<ul>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">1 x 160GB file <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">2 x 80GB files <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">4 x 40GB files <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">8 x 20GB files <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">16 x 10GB files <\/font>\n\t<\/div>\n<\/li>\n<\/ul>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">These drop down to 128\/64\/32\/etc when using a single 320GB drive with the maximum write capacity format. The log file is pre-created at 8GB and does not need to grow during the test. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">I tested&nbsp;each of the five data file layouts on the&nbsp;following configurations (all using 1MB partition offsets, 64k NTFS allocation unit size, 128k RAID stripe size &#8211; where applicable): <\/font>\n<\/p>\n<ul>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Data on RAID-10 SCSI (8 x 300GB 15k), log on RAID-10 SATA (8 x 1TB 7.2k) <\/font>\n\t<\/div>\n<\/li>\n<li><font face=\"verdana,geneva\" size=\"2\">Data round-robin between two RAID-10 SCSI (each with 4 x 300GB 15k and one server NIC), log on RAID-10 SATA (8 x 1TB 7.2k)<\/font><\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Data on two 320GB SSDs in RAID-0 (each of the 4 ways of formatting), log on RAID-10 SATA (8 x 1TB 7.2k) <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Log and data on two 320GB SSDs in RAID-0 (each of the 4 ways of formatting) <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Log and data on single 320GB SSD (each of the 4 ways of formatting) <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Log and data on separate 320GB SSDs (each of the 4 ways of formatting) <\/font>\n\t<\/div>\n<\/li>\n<li>\n<div>\n\t<font face=\"verdana,geneva\" size=\"2\">Log and data round-robin between two 320GB SSDs (each of the 4 ways of formatting) <\/font>\n\t<\/div>\n<\/li>\n<\/ul>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">That&#39;s a total of 22 configurations, with 5 data file layouts in each configuration &#8211; making 110 separate configurations. I ran each test 5 times and then took an average of the results &#8211; so altogether I ran 550 tests, for a cumulative test time of just less than 110 million seconds (12.7 days) over the last 4 weeks. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">And yes, I do have a test harness that automates a lot of this so I only had to reconfigure things 22 times manually. And no, for these tests I didn&#39;t have wait stats being captured. I&#39;ve upgraded the test harness and now it captures wait stats for each test &#8211; that&#39;ll come in my next post. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">On to the results&#8230; <em><u>bear in mind that these results are testing a 100GB sequential insert-only workload and are not using the full size of the disks involved!!!<\/u><\/em> <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\"><font size=\"2\"><strong>Data on SCSI RAID-10, log on SATA RAID-10<\/strong> <\/font><\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\"><img fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/6\/multidatafiles.jpg\" alt=\"\" width=\"596\" height=\"424\" \/>&nbsp; <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">I already blogged about these tests <\/font><a href=\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-do-multiple-data-files-make-a-difference\/\"><font face=\"verdana,geneva\" size=\"2\">here<\/font><\/a><font face=\"verdana,geneva\" size=\"2\">&nbsp;last week. They prove that for this particular workload, multiple data files on the same RAID array does give a performance boost &#8211; albeit only 6%. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">The best performance I could get from the SCSI\/SATA configurations was completing the test in 1755 seconds. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\"><font size=\"2\"><strong>Data and log on 640GB RAID-0 SSDs (Data on 640GB RAID-0 SSDs, log on SATA RAID-10)<\/strong> <\/font><\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">&nbsp;<img decoding=\"async\" src=\"\/blogs\/paul\/wp-content\/uploads\/2010\/7\/3-640.jpg\" alt=\"\" width=\"581\" height=\"385\" \/> <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">The performance whether the log file was on SATA or on the SSD was almost identical, so I&#39;m only including one graph, in the interests in making this post a little shorter. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">These results clearly show that the SSDs have to be formatted correctly to get any performance out of them. The SSDs performed the same for all data file configurations until performance almost doubles when the number of data files hits 16. I tested 32 and 64 files and didn&#39;t get any further increase. My guess here is that I had enough files that when checkpoints or lazywrites occured, the behavior was as if I was doing a random-write workload rather than sequential-write workload. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">The best performance I could get here was with 16 files and the maximum-write format when the test completed in 934 seconds, 1.88x faster than the best SCSI time. This is only 13 seconds slower than the normal format which gives 100% more capacity. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\"><font size=\"2\"><strong>Data and log on single 320GB SSD<\/strong> <\/font><\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">&nbsp;<img decoding=\"async\" src=\"\/blogs\/paul\/wp-content\/uploads\/2010\/7\/3-1x320-2.jpg\" alt=\"\" width=\"580\" height=\"385\" \/> <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">Here the performance truly sucked when the SSD wasn&#39;t formatted correctly. Once it was, the performance was roughly the same for 1, 2, or 4 files but degraded by almost 50% with normal formatting for 8 or 16 files. With improved-wait and maximum-write formatting, the performance was the same as for the 640GB RAID-0 SSD array, but the sharp performance increase with 16 files only happened with the maximum-write formatting. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\"><font size=\"2\"><strong>Data and log on separate 320GB SSDs<\/strong> <\/font><\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">&nbsp;<img loading=\"lazy\" decoding=\"async\" src=\"\/blogs\/paul\/wp-content\/uploads\/2010\/7\/3-2x320-2.jpg\" alt=\"\" width=\"578\" height=\"364\" \/> <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">No major difference here&nbsp;&#8211; same characteristics as before when formatted correctly, and the best performance coming from maximum-write formatting and 16 data files. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">This configuration gave the best overall performance &#8211; 909 seconds &#8211; 1.93x the bext performance from the SCSI storage. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\"><font size=\"2\"><strong>Data and log round-robin between separate 320GB SSDs<\/strong> <\/font><\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">&nbsp;<img loading=\"lazy\" decoding=\"async\" src=\"\/blogs\/paul\/wp-content\/uploads\/2010\/7\/3-2x320rr.jpg\" alt=\"\" width=\"577\" height=\"363\" \/> <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">No major differences from the previous configuration. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\"><font size=\"2\"><strong>Best-case&nbsp;performance for each number of data files<\/strong> <\/font><\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">&nbsp;<img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/7\/best1.jpg\" alt=\"\" width=\"517\" height=\"305\" \/>&nbsp;<img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/7\/best2.jpg\" alt=\"\" width=\"517\" height=\"304\" \/> <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">&nbsp;<img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/7\/best4.jpg\" alt=\"\" width=\"518\" height=\"304\" \/>&nbsp;<img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/7\/best8.jpg\" alt=\"\" width=\"516\" height=\"305\" \/> <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">&nbsp;<img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/7\/best16.jpg\" alt=\"\" width=\"516\" height=\"303\" \/> <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">Clearly the SSDs outperform the SCSI storage for these tests, but not by very much. The improvement factor varied by the number of data files: <\/font>\n<\/p>\n<ul>\n<li><font face=\"verdana,geneva\" size=\"2\">1: SSD was 1.11x faster than SCSI<\/font><\/li>\n<li><font face=\"verdana,geneva\" size=\"2\">2: SSD was 1.09x faster than SCSI<\/font><\/li>\n<li><font face=\"verdana,geneva\" size=\"2\">4: SSD was 1.06x faster than SCSI<\/font><\/li>\n<li><font face=\"verdana,geneva\" size=\"2\">8: SSD was 1.04x faster than SCSI<\/font><\/li>\n<li><font face=\"verdana,geneva\" size=\"2\">16: SSD was 2.03x faster than SCSI<\/font><\/li>\n<\/ul>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">The configuration of 16 data files on one SSD and the log on the other SSD, with maximum-write format for both,&nbsp;was the best overall performer, beating the best SCSI configuration (8 data files) by a factor of 1.93. <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\"><font size=\"2\"><strong>Summary<\/strong> <\/font><\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">Reminder: this test was 100GB of sequential inserts with no reads or updates (i.e. no random IO). It is very important to consider the limited scenario being tested and to draw appropriate conclusions<\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">Several things are clear from these tests: <\/font>\n<\/p>\n<ol>\n<li><font face=\"verdana,geneva\" size=\"2\">The Fusion-io SSDs do not perform well unless they are formatted with Fusion-io&#39;s tool, which takes seconds and is very easy. I don&#39;t see this as a downside at all, and it makes sense to me.<\/font><\/li>\n<li><font face=\"verdana,geneva\" size=\"2\">For sequential write-only IO workloads, the improved-write and maximum-write SSD formats do not produce a performance gain and so the loss in storage capacity (30% and 50% respectively)&nbsp;is not worth it.<\/font><\/li>\n<li><font face=\"verdana,geneva\" size=\"2\">For sequential write-only IO workloads, the SSDs do not provide a substantial gain over SCSI storage (which is not overloaded).<\/font><\/li>\n<\/ol>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">All three of these results were things I&#39;d heard anecdotally and experienced in ad-hoc tests, but now I have the empirical evidence to be able to state them publicly (and now so do you!). <\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">These tests back-up the assertion I&#39;ve heard over and over that sequential write-only IO workloads are not the best use-case for SSDs.<\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">One very interesting other result came from these tests &#8211; moving to 16 data files changed the characteristics of the test to a more random write-only&nbsp;IO workload, and so the maximum-write format produced a massive performance boost &#8211; almost twice the performance of the SCSI storage!<\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">The next set of tests is running right now &#8211; 64GB of inserts into a clustered index with a GUID key &#8211; random reads and writes in a big way. Early results show the SSDs are *hammering* the performance of the SCSI storage &#8211; more in a week or so!<\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\">Hope you find these results useful and thanks for reading!<\/font>\n<\/p>\n<p>\n<font face=\"verdana,geneva\" size=\"2\"><\/font><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Over the last month we&#39;ve been teaching in Europe and I haven&#39;t had much time to focus on benchmarking, but I&#39;ve finally finished the first set of tests and analyzed the results. You can see my benchmarking hardware setup here, with the addition of the Fusion-io ioDrive Duo 640GB drives that Fusion-io were nice enough [&hellip;]<\/p>\n","protected":false},"author":5,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[15,66,89],"tags":[],"class_list":["post-670","post","type-post","status-publish","format-standard","hentry","category-benchmarking","category-performance-tuning","category-ssds"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v26.5 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Benchmarking: Introducing SSDs (Part 2: sequential inserts) - Paul S. Randal<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Benchmarking: Introducing SSDs (Part 2: sequential inserts) - Paul S. Randal\" \/>\n<meta property=\"og:description\" content=\"Over the last month we&#039;ve been teaching in Europe and I haven&#039;t had much time to focus on benchmarking, but I&#039;ve finally finished the first set of tests and analyzed the results. You can see my benchmarking hardware setup here, with the addition of the Fusion-io ioDrive Duo 640GB drives that Fusion-io were nice enough [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/\" \/>\n<meta property=\"og:site_name\" content=\"Paul S. Randal\" \/>\n<meta property=\"article:published_time\" content=\"2010-07-09T05:04:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2013-01-02T05:06:46+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/6\/multidatafiles.jpg\" \/>\n<meta name=\"author\" content=\"Paul Randal\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Paul Randal\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/\",\"name\":\"Benchmarking: Introducing SSDs (Part 2: sequential inserts) - Paul S. Randal\",\"isPartOf\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/6\/multidatafiles.jpg\",\"datePublished\":\"2010-07-09T05:04:00+00:00\",\"dateModified\":\"2013-01-02T05:06:46+00:00\",\"author\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#primaryimage\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/6\/multidatafiles.jpg\",\"contentUrl\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/6\/multidatafiles.jpg\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Benchmarking: Introducing SSDs (Part 2: sequential inserts)\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#website\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/\",\"name\":\"Paul S. Randal\",\"description\":\"In Recovery...\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce\",\"name\":\"Paul Randal\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g\",\"caption\":\"Paul Randal\"},\"sameAs\":[\"http:\/\/3.209.169.194\/blogs\/paul\"],\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/author\/paul\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Benchmarking: Introducing SSDs (Part 2: sequential inserts) - Paul S. Randal","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/","og_locale":"en_US","og_type":"article","og_title":"Benchmarking: Introducing SSDs (Part 2: sequential inserts) - Paul S. Randal","og_description":"Over the last month we&#39;ve been teaching in Europe and I haven&#39;t had much time to focus on benchmarking, but I&#39;ve finally finished the first set of tests and analyzed the results. You can see my benchmarking hardware setup here, with the addition of the Fusion-io ioDrive Duo 640GB drives that Fusion-io were nice enough [&hellip;]","og_url":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/","og_site_name":"Paul S. Randal","article_published_time":"2010-07-09T05:04:00+00:00","article_modified_time":"2013-01-02T05:06:46+00:00","og_image":[{"url":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/6\/multidatafiles.jpg","type":"","width":"","height":""}],"author":"Paul Randal","twitter_misc":{"Written by":"Paul Randal","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/","url":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/","name":"Benchmarking: Introducing SSDs (Part 2: sequential inserts) - Paul S. Randal","isPartOf":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#primaryimage"},"image":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#primaryimage"},"thumbnailUrl":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/6\/multidatafiles.jpg","datePublished":"2010-07-09T05:04:00+00:00","dateModified":"2013-01-02T05:06:46+00:00","author":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce"},"breadcrumb":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#primaryimage","url":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/6\/multidatafiles.jpg","contentUrl":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-content\/uploads\/2010\/6\/multidatafiles.jpg"},{"@type":"BreadcrumbList","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/benchmarking-introducing-ssds-part-2-sequential-inserts\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.sqlskills.com\/blogs\/paul\/"},{"@type":"ListItem","position":2,"name":"Benchmarking: Introducing SSDs (Part 2: sequential inserts)"}]},{"@type":"WebSite","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#website","url":"https:\/\/www.sqlskills.com\/blogs\/paul\/","name":"Paul S. Randal","description":"In Recovery...","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.sqlskills.com\/blogs\/paul\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce","name":"Paul Randal","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g","caption":"Paul Randal"},"sameAs":["http:\/\/3.209.169.194\/blogs\/paul"],"url":"https:\/\/www.sqlskills.com\/blogs\/paul\/author\/paul\/"}]}},"_links":{"self":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/posts\/670","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/comments?post=670"}],"version-history":[{"count":0,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/posts\/670\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/media?parent=670"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/categories?post=670"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/tags?post=670"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}