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:

 

  1. Download the latest and greatest firmware from:
  1. 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

   
  1. 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


 

 

  1. 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

  1. Here is the Output

  2. Let me try a simple file transfer to the IO Accelerator… It is pretty good I get about 1 GB /sec

  3. 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.

  4. 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.

     

 

Advertisements