Upgrading to Windows 2012 Hyper-V – IO Accelerator IOPS Testing

In this post I will show a server that we have taken from Server 2008 R2 and upgraded to Server 2012.

This particular server had been in production for the past 2 years and ran all production workloads

for this company. Now it is being refurbished and will be used for DEV / Stagging as bigger and

better servers have replaced it since.

It still has some decent hardware in it including a pair of:

HP 160GB Single Level Cell PCIe ioDrive for ProLiant Servers

These IO Accelerators from HP offer amazing performance and we will do some testing after the

Build with SQLIO to see just how well they perform. With Windows 2012 De-Deduplication

these things go a lot farther than what they used to.

The hardware is the early model HPDL380 G8’s with 256GB of RAM

This customer wasn’t ready for Server 2012 R2 just yet so we went with 2012

So here is the order we did the upgrade:

Download the latest and greatest firmware from:

http://h20566.www2.hp.com/portal/site/hpsc/template.PAGE/public/psi/swdHome/?sp4ts.oid=4151253&spf_p.tpst=swdMain&spf_p.prp_swdMain=wsrp-navigationalState%3DswEnvOID%253D4138%257CswLang%253D%257Caction%253DlistDriver&javax.portlet.begCacheTok=com.vignette.cachetoken&javax.portlet.endCacheTok=com.vignette.cachetoken

Run the IO Accelerator Console Installer first… We update the firmware from this console after.
We performed the steps in the following order:

Run the HP_IO_Accelerator_3.2.6.1212_x64_WinServer 2008R2_2012_Win7_8.exe
Click Run
Accept the EULA
It is a small installer for the HP IO Accelerator
Complete the Setup
Logon via the App that is loaded for the IO Accelerator Management Tool
Viewing the Console Overview Pane
Checking the Firmware

Ok so our Drivers look good now and the Firmware appears to be up to date. We do have 2x of these IO Accelerators in this server. So now it is time for the

Fun stuff. We will now a combination of Powershell and SQLIO to perform some load testing.

Before we get there I have to pay special credit to Mikael Nystrom a fellow Microsoft MVP that wrote this script. www.deploymentbunny.com

http://deploymentbunny.com/2014/04/02/powershell-is-kingmeasure-disk-performance-for-iops-and-transfer-rate/

Basically all you have to do is Download SQL IO from:

http://www.microsoft.com/en-us/download/details.aspx?id=20163

Grab the SQLIO.exe Binary and place it in the same folder as this script.

Then run something like

.\Measure-DiskPerformance.ps1 -TestFileName test.dat –TestFileSizeInGB 1 -TestFilepath C:\VMs -TestMode Get-LargeIO -FastMode True -RemoveTestFile True -OutputFormat Out-GridView

Here is the script — Once again Credit goes to Mikael

.Synopsis

Short description

.DESCRIPTION

Long description

.EXAMPLE

Example of how to use this cmdlet

.EXAMPLE

Another example of how to use this cmdlet

.INPUTS

Inputs to this cmdlet (if any)

.OUTPUTS

Output from this cmdlet (if any)

.NOTES

Version 1.2

.COMPONENT

The component this cmdlet belongs to

.ROLE

The role this cmdlet belongs to

.FUNCTIONALITY

The functionality that best describes this cmdlet

Param(

[parameter(mandatory=$False,HelpMessage=‘Name of test file’)]

[ValidateLength(2,30)]

$TestFileName
=
“test.dat”,

[parameter(mandatory=$False,HelpMessage=‘Test file size in GB’)]

[ValidateSet(‘1’,‘5’,’10’,’50’,‘100’,‘500’,‘1000’)]

$TestFileSizeInGB
=
1,

[parameter(mandatory=$False,HelpMessage=‘Path to test folder’)]

[ValidateLength(3,254)]

$TestFilepath
=
‘C:\Test’,

[parameter(mandatory=$True,HelpMessage=‘Test mode, use Get-SmallIO for IOPS and Get-LargeIO for MB/s ‘)]

[ValidateSet(‘Get-SmallIO’,‘Get-LargeIO’)]

$TestMode,

[parameter(mandatory=$False,HelpMessage=‘Fast test mode or standard’)]

[ValidateSet(‘True’,‘False’)]

$FastMode
=
‘True’,

[parameter(mandatory=$False,HelpMessage=‘Remove existing test file’)]

[ValidateSet(‘True’,‘False’)]

$RemoveTestFile=‘False’,

[parameter(mandatory=$False,HelpMessage=‘Remove existing test file’)]

[ValidateSet(‘Out-GridView’,‘Format-Table’)]

$OutputFormat=‘Out-GridView’

)

Function
New-TestFile{

$Folder
=
New-Item
-Path
$TestFilePath
-ItemType
Directory
-Force
-ErrorAction
SilentlyContinue

$TestFileAndPath
=
“$TestFilePath\$TestFileName“

Write-Host
“Checking for $TestFileAndPath“

$FileExist
=
Test-Path
$TestFileAndPath

if ($FileExist
-eq
$True)

{

if ($RemoveTestFile
-EQ
‘True’)

{

Remove-Item
-Path
$TestFileAndPath
-Force

}

else

{

Write-Host
‘File Exists, break’

Break

}

Write-Host
‘Creating test file using fsutil.exe…’

&
cmd.exe
/c
FSUTIL.EXE
file
createnew
$TestFileAndPath ($TestFileSizeInGB*1024*1024*1024)

&
cmd.exe
/c
FSUTIL.EXE
file
setvaliddata
$TestFileAndPath ($TestFileSizeInGB*1024*1024*1024)

}

Function
Remove-TestFile{

$TestFileAndPath
=
“$TestFilePath\$TestFileName“

Write-Host
“Checking for $TestFileAndPath“

$FileExist
=
Test-Path
$TestFileAndPath

if ($FileExist
-eq
$True)

{

Write-Host
‘File Exists, deleting’

Remove-Item
-Path
$TestFileAndPath
-Force
-Verbose

}

Function
Get-SmallIO{

Write-Host
‘Initialize for SmallIO…’

8..64 |
% {

$KBytes
=
‘8’

$Type
=
‘random’

$b
=
“-b$KBytes“;

$f
=
“-f$Type“;

$o
=
“-o $_“;

$Result
=
&
$RunningFromFolder\sqlio.exe $Duration
-kR
$f
$b
$o
-t4
-LS
-BN
“$TestFilePath\$TestFileName“

Start-Sleep
-Seconds
5
-Verbose

$iops
=
$Result.Split(“`n”)[10].Split(‘:’)[1].Trim()

$mbs
=
$Result.Split(“`n”)[11].Split(‘:’)[1].Trim()

$latency
=
$Result.Split(“`n”)[14].Split(‘:’)[1].Trim()

$SeqRnd
=
$Result.Split(“`n”)[14].Split(‘:’)[1].Trim()

New-object
psobject
-property @{

Type = $($Type)

SizeIOKBytes = $($KBytes)

OutStandingIOs = $($_)

IOPS = $($iops)

MBSec = $($mbs)

LatencyMS = $($latency)

Target = $(“$TestFilePath\$TestFileName“)

}

Function
Get-LargeIO{

$KBytes
=
‘512’

$Type
=
‘sequential’

Write-Host
‘Initialize for LargeIO…’

Write-Host
“Reading $KBytes Bytes in $Type mode using $TestFilePath\$TestFileName as target”

1..32 |
% {

$b
=
“-b$KBytes“;

$f
=
“-f$Type“;

$o
=
“-o $_“;

$Result
=
&
$RunningFromFolder\sqlio.exe $Duration
-kR
$f
$b
$o
-t1
-LS
-BN
“$TestFilePath\$TestFileName“

Start-Sleep
-Seconds
5
-Verbose

$iops
=
$Result.Split(“`n”)[10].Split(‘:’)[1].Trim()

$mbs
=
$Result.Split(“`n”)[11].Split(‘:’)[1].Trim()

$latency
=
$Result.Split(“`n”)[14].Split(‘:’)[1].Trim()

$SeqRnd
=
$Result.Split(“`n”)[14].Split(‘:’)[1].Trim()

New-object
psobject
-property @{

Type = $($Type)

SizeIOKBytes = $($KBytes)

OutStandingIOs = $($_)

IOPS = $($iops)

MBSec = $($mbs)

LatencyMS = $($latency)

Target = $(“$TestFilePath\$TestFileName“)

}

#Checking for fast mode

if ($FastMode
-lt
$True){$Duration
=
‘-s60’}else{$Duration
=
‘-s10’}

#Setting script location to find the exe’s

$RunningFromFolder
=
$MyInvocation.MyCommand.Path |
Split-Path
-Parent

Write-Host
“Running this from $RunningFromFolder“

#Main

.
New-TestFile

switch ($OutputFormat){

‘Out-GridView’ {

.
$TestMode
|
Select-Object
MBSec,IOPS,SizeIOKBytes,LatencyMS,OutStandingIOs,Type,Target |
Out-GridView

}

‘Format-Table’ {

.
$TestMode
|
Select-Object
MBSec,IOPS,SizeIOKBytes,LatencyMS,OutStandingIOs,Type,Target |
Format-Table

}

Default {}

}

.
Remove-TestFile

Here is the exact command I ran against the IO Accelerator

.\SQLIO.ps1
-TestFileName
test.dat
–TestFileSizeInGB
1
-TestFilepath
f:\VMs
-TestMode
Get-LargeIO
-FastMode
True
-RemoveTestFile
True
-OutputFormat
Out-GridView

Here is the Output
Let me try a simple file transfer to the IO Accelerator… It is pretty good I get about 1 GB /sec
interesting enough I run the same test on my Laptop that has a Samsung SSD 840 EVO 750GB… Technology that is about 2.5 years newer than
this Gen1 IO Accelerator.
As we can see based on the MBSec and IOP output that the HP IO Accelerator did out perform my local SSD.

I find it very interesting performing these kinds of test in a production environment.

My next test will be to do the same thing against some of my Windows Azure VM’s and see how they

Perform in Microsoft’s Cloud.