Flipping Bits

Perfcollect video series

Perfcollect is really easy to use, but generates a bunch of interesting data which can be bewildering to a new user of the tool.  So I’ve started a little video series on the topic, which perhaps will blossom into a series on Windows performance analysis and triage in general.

I’ve got three up now, all linked off the perfcollect page.  The videos are hosted on EMC’s Everything Microsoft at EMC site – you don’t need to have a login to watch the videos.

Right now, here's what's up there:

• Running Perfcollect
• Troubleshooting Perfcollect
• Evaluating Perfcollect data
• Using Perfcollect with the PAL tool

 

Enterprise Flash Drives: not just performance

I often encounter the misconception that EFDs are not beneficial unless you need to either reduce latencies below what traditional disks can get you, or you’re short-stroking your disk in order to maintain performance.  So I figured I’d go through the three general use cases I talk about with EFDs:

1. Do more stuff
2. Do the same stuff faster
3. Do the same stuff, but with less gear

These are not mutually exclusive.  In most cases, EFDs allow people to do more stuff, faster, with less gear.  But your goals for EFDs will certainly flavor how to best deploy them.

Do more stuff (increase scale)

Let’s use an entirely contrived order processing system (like a trading desk). Let’s say this system can support 1,000 trades a minute. But during peak trading times, you’re getting more trades than you can process.

The business case for EFDs here would be that you can increase revenue by processing more orders.  Here’s an example where six EFDs supported seven times the transactions of six traditional fibre channel drives.  And this is a perfect example of how increased scale and reduced latency are not mutually exclusive – the response times on the EFD drives were 7 times lower than the response times on the spinning disks.

source

Note that both of the cases thus far really depend on how much your EFDs cost, and how much productivity improvement you’re going to see from their deployment.  That’s significantly different than this one:

Do the same stuff faster (reduce latency):

Let’s take a large manual order-entry system, where user wait time for a query is 5 seconds, and users do about a one query per minute. Let’s say the performance gate in this scenario is storage and it’s getting about 5-7 ms latency (about as good as you can get with a performance HDD at scale due to rotational latency).

The business case for EFDs here would be that employees in this role spend about 8% of their time waiting on the database. If you can reduce that to 1.6%, you realize massive productivity improvements.

Here’s some data: Note the graphs are not on the same scale.

source

Do the same stuff, but with less gear (decrease footprint): 

Let’s say that you’ve got an application that’s fat and happy residing on ninety 10k performance HDDs.  You’re not short-stroking them too badly, but it’s still taking about $6,000 a year to power them, $2,000 a year to cool them, about 18U of rack space to store them, not to mention the maintenance cost associated with them.  But the fact is that in most environments, only part of the data set is actually frequently accessed.  An example of this might be an order processing or inventory system that may go back years or even decades.  The old data isn’t accessed very frequently at all, while the newer data is getting hammered.

Using either manual or automated tiering, you put the older data on cheaper, denser, and more power efficient nl-SAS drives, while the most frequently accessed data can reside on faster, less dense (but still more power efficient) EFDs.

Here’s some supporting data.  Now, the performance was slightly increased, but the bulk of the savings came in the form of footprint – acquisition, power, management, and so forth.  Had the goal been to increased scale or reduce response time, then the deployment method would have differed.

  

source

Three SQL Server 2012 Game Changers you might not know about

SQL 2012 has a lot of changes for storage – naturally people focus on Availability Groups and all the flexibility that they bring in terms of workload isolation, high availability, and disaster recovery.  Here are a couple of nuggets you might not know about:

• Support for SMB/CIFS shares:  For at least a decade (if not longer) Oracle DBAs running in *nix environments have enjoyed the possibility of accessing their data files over NFS.  It allows a lot of flexibility, opens new possibilities for disaster recovery, and greatly simplifies storage provisioning, maintenance and expansion.  Now SQL admins have access to the same storage technique as their Oracle counterparts.  There are some considerations – particularly for those who choose to achieve high availability with shared-storage clusters.  The current version of SMB doesn’t support transparent failover, but that will be fixed with the new version of SMB (arriving with Windows Server 8).
• Placement of tempdb on local disk in clustered environments:  This is probably not a big deal for folks who don’t do geographically dispersed clustering.  But in past versions of SQL server, tempdb had to be placed on a clustered disk on which the SQL resource group was dependent.  In geographically dispersed environments, this meant that tempdb had to be replicated (something that’s not necessary if you’re just replicating the data and not trying to stretch the cluster).  There have always been methods to achieve it, but the methods required going outside the context of SQL Server.  Reduced bandwidth utilization and faster failover FTW!
• Multi-subnet clustering:  Microsoft made a lot of improvements in their clustering model with Windows 2008.  One of those improvements allowed administrators to have nodes in a cluster reside in separate subnets.  Unfortunately, SQL Server 2008 didn’t support it, but SQL Server 2012 does.

Max Worker Threads in upgraded SQL instances

The default Max Worker Threads setting is 255 in SQL 2000, and 0 in SQL 2005 and later.  It’s not actually zero, but setting it to zero allows SQL to determine the setting based on the server configuration (whether it’s 32 or 64 bit, and number of processors).

Microsoft is pretty clear that the setting should only be changed under their guidance:

“If you configure a number of worker threads to a value that is greater than the default, it is almost always counterproductive and slows performance because of scheduling and resource overhead. Only increase this setting under very unusual circumstances and when rigorous methodical testing demonstrates that it is useful to do so.”  (Emphasis theirs.  Link)

So I was surprised when a customer found it set to 255 on their SQL08 instance, and asked our advice on changing it.  They said nobody had changed it from the default.

It turns out that when you upgrade an instance, the setting is inherited from previous version.

So if you’ve got an ancient install that’s been upgraded, it’s worth your time to check it out and change it if necessary.

SQL Server Logical Disk Layout

A few weeks ago, I was talking to a meetup of SQL Server folks here in the Hartford area about storage and SQL Server. We were going through the ideal storage layout of SQL server, and someone in the group summarized it as "so I need a minimum of five disks (LUNs) for a SQL Server?" I'd never really thought of it in those terms, so let's get down to the thinking:

First, this has mostly to do with logical layout of data. Aside from separating logs and databases on different physical media, it has nothing to do with physical layout of data. Even if you have only a couple of disks to allocate to the server, you can still logically partition it so that it's easy to evaluate performance later on.

As with almost everything else related to SQL Server, it's going to depend on the workload. The key aspects are:

• Performance sensitivity - This is not necessarily a performance intensive workload – it could be nearly idle. The key question is "if performance of this application suffers, which business processes will suffer, and how many users will suffer?" If there's a chance that someone important is going to call you up and ask you to fix a performance problem with this SQL server, it's performance sensitive. Even if you're resource constrained, it would help to have things laid out so you can evaluate performance without reconfiguring the database (which in reality includes nearly as much effort as migrating to entirely new storage).
• Recoverability – This would be dictated by whether you'll need to be able to perform up to the minute recovery of the database. If you do, you'll need to consider the physical layout of the data so that the failure of a physical disk or RAID group doesn't take out the database and its transaction logs at the same time.

Here's a quick version of the rules:

1. If your database is neither performance sensitive and you do not need the ability to recover data up to the last transaction, then you only need one or two:
   1. OS/Apps
   2. Databases and transaction logs
2. If the data in your database is critical enough that you'll want to be able to recover up to the latest transaction, you'll need three.
   1. OS
   2. Databases
   3. Transaction logs (you also need to make sure that these are physically separated from the databases, so that you don't lose data from both of them at the same time).
3. If your data is performance sensitive (regardless of whether the data is sensitive), you need a minimum of five, and possibly more:
   1. OS
   2. System databases (other than tempdb)
   3. User databases
   4. User database transaction logs
   5. One for tempdb and its logs

The principle behind this separation is the performance evaluation of these components independently of each other. If I have my user databases mixed with tempdb, and I'm having performance issues, I have no real way of telling which database is presenting the IO, and which database is starving. All I know is that performance stinks equally on both databases. More importantly for transaction logs, you want to both avoid contention between the IO that log flushes create and normal user IO, and you also want to make sure that transaction log disks get a write response time of well less than 10 milliseconds.

These five LUNs are a starting point – I often see systems with a dozen or even a couple dozen LUNs. What's the reason for adding LUNs above this five?

• Additional segregation of the unrelated workloads. I can put two different databases on two different LUNs.
• Segregation of related, but different workloads. For example, I could put my non-clustered indexes on different disk than my data files.
• Simply adding queues – each disk gets an additional queue
• Increase the granularity of restore options if you're using hardware-based snapshots, clones, or CDP. In this case, the management boundary is the LUN itself, so if you want to do rapid restore of a failed or corrupt data file using this method, then you would restore all the databases on that LUN together (whether they are corrupt or not). There are ways to do selective restore in this case, but it can take longer to perform the restore.

Remember that multiple LUNs can actually share the same physical disks, so your workloads can still step on each other if that's the case. However, it makes the troubleshooting process much easier. And if you're using the right technology, fixing the problems can be completely seamless.

Hartford SQL Server Meetup!

Chuck Boyce has created a SQL Server meetup.  He spun up the Philadelphia SSUG, and I’m hoping he can weave his magic for Hartford!

Our first event will be on January 24th at the EMC office in Rocky Hill at 7pm.  I’ll be presenting on storage basics for DBAs, including techniques to analyze and improve storage performance and availability, various techniques for disaster recovery and application failover.  We’ll have a few giveaways and some food.

Make sure to RSVP here at meetup if you’d like to attend so we can make sure you get information around how get there and into the building.  We look forward to seeing you there!

Please stop using SQLIOSim to model SQL workloads

Every few months I get a (sometimes panicked) call or email about SQLIOSim that goes like this: 

“We’re doing some testing of a new disk array.  SQL Server’s going to be one of the workloads, so we downloaded SQLIOSim and are running it, but the disk latency is terrible.  Can you help?”

Well, the disk latency is terrible because SQLIOSim is designed to test IO stability and functional correctness, not to model a particular workload.  SQLIOSim actually attempts to break the storage (create page corruption or stale reads) so as to expose configuration or hardware problems that can cause data corruption.  It doesn’t really try to create a workload that “looks” like, say, an OLTP or DW workload.

So you can use SQLIOSim to make sure your storage is healthy, but keep in mind:

• It is a pass/fail test.  Either you have stale reads/corrupt pages or you don’t.
• Performance data like queue length and latency are irrelevant during SQLIOSim runs
• You cannot compare the performance results of one SQLIOSim run to another
• Be careful about other workloads on the array while you’re running SQLIOSim

For more discussion on SQLIOSim, there are a bunch of good links referenced here.

You might wonder how you actually see how a new storage environment is going to perform under a particular workload.  There are several options, and I’ll list them in terms of accuracy of the model.

Use SQL Profiler to capture and replay traces

This is by far and away the most accurate way of seeing how a given storage configuration will perform under a production workload.  After all, it is precisely the same workload as production.  You can also use something like Benchmark Factory to modify the workload to anticipate growth and so forth.

Use Perfmon to gather data and Iometer to create the workload

This is somewhat less accurate than traces, but can be easier to set up.  You gather all the information needed to create iometer workloads using perfmon and educated guesses.

• Disk Reads & Disk Writes/sec – use that to figure the r:w ratio
• Data file sizes – use that to figure the working set
• Disk Bytes/Read & Write – use that to figure the IO sizes
• Random vs Sequential – there is no way to determine randomness of the workload from perfmon. Logs will always be 100% sequential, DB files will be a mix. Think about the workload a bit to determine the mix (100% random will usually be safe).

Aside from the educated guesses around randomness and thread counts, there are two other big issues with iometer:  It goes as fast as it can.  There’s no way to configure Iometer to only issue a specific number of IOs/second.  So it will reflect the workload type, but not the workload rate.  The other thing it will not approximate is the skew.  Most database environments will have certain tables or parts of the dataset that are more active than others.  In some cases, over 90% of the IO can be directed at less than 5% of the total data set (low skew).  Consider an order/inventory OLTP database that has decades of data in it – nearly all the IO will be directed at the latest data – this is a low skew environment.  If you believe you have a low skew environment, you can set the file size to what you estimate the total skew to be, and create a fully random worker (but preferably use a trace instead of iometer).

Use the SQLIO Disk Subsystem Benchmark Tool

This is actually my least favorite method.  SQLIO is indeed extremely simply to use, but there is no way to make this look like a production workload.  You choose one workload type – all reads, or all writes.  One IO size.  Random or sequential.  Although it can expose some of the limits around a disk configuration, there is no way to make it look like a “real” SQL workload.

At the end of the day, the only workload generator that will create a workload that looks like yours is SQL Profiler and traces.  And it’s more important than ever to capture and recreate the workload accurately, including such features of the workload such as skew, since they directly impact the effectiveness of modern storage techniques such as extended cache and storage auto-tiering.

Background Database Maintenance in Exchange 2010

Database size is a critical aspect to consider in Exchange 2010 designs where DAG is in play. This is regardless of the disk backend you choose. JBOD, DAS RAID, and SAN designs all need planning where small passive databases are in play. Since Microsoft offers no configurability of BDM on passive databases, there is nothing you can do but be aware of and plan for the workload (aside from going with a standalone configuration).

Many Exchange administrators are used to having small databases (100-200GB) so that ESE maintenance tasks and restore SLAs are easier to address.  I find that this can trip up otherwise solid storage architectures.  BDM can lead to problems, primarily because admins aren’t necessarily aware that BDM schedules that they set via EMC or powershell applies only to the active copy of the database.

Microsoft calls background database maintenance “online database scanning” or “database checksumming” or “background database maintenance”.  It can be associated with page zeroing.  It’s a googlicious challenge – and a tagging nightmare for bloggers. 

Let’s see what Technet says about BDM (aka “checksumming”):

Background database maintenance I/O is sequential database file I/O associated with checksumming both active and passive database copies. Background database maintenance has the following characteristics:

• On active databases, it can be configured to run either 24 × 7 or during the online maintenance window. Background database maintenance (Checksum) runs against passive database copies 24 × 7. For more information, see "Online Database Scanning" in the New Exchange Core Store Functionality topic.
• Reads approximately 5 MB per second for each actively scanning database (both active and passive copies). The I/O is 100 percent sequential, so the storage subsystem can process the I/Os efficiently.
• Stops scanning the database if the checksum pass completes in less than 24 hours.
• Issues a warning event if the scan doesn't complete within three days (not configurable).

Let’s reiterate interesting bit:

Background database maintenance (Checksum) runs against passive database copies 24 × 7.

Now let’s look at what another technet page says about this:

Exchange scans the database no more than once per day. This read I/O is 100 percent sequential (which makes it easy on the disk) and equates to a scanning rate of about 5 megabytes (MB)/sec on most systems.

The important thing to remember is that when you set a maintenance schedule for a database as described on this technet page, the setting applies only to the active copy of the database.

Now, how do you plan for this workload?  Frequently, you don’t have to worry about it at all.  Let’s say you have 5000 users with 2GB mailboxes on a server.  That’s 10 TB of mailbox data.  If you have 2 TB mailbox databases, you have about 5 databases, or about 25 MB/s in BDM workload.  Not a problem.

However, if you limit your databases to 100GB, that can present a problem.  That 5000 users translates to 100 databases, each of which can launch a 5MB/s read workload (or more) at any given time.  Aggregated over a whole single mailbox server, 500MB/s is nothing to sneeze at, especially if it’s mixed with user workload on the same disk. 

What you can do to limit the impact of BDM:

1. Use larger databases (1-2TB in size).  Although it will increase the amount of time required to maintain the databases, remember that with a DAG configuration, it’s often more expedient to reseed than it is to do ESE maintenance. 
2. If you are concerned about restore times, use an array that can act as a VSS provider and store your first-tier backups in snapshots, clones, or CDP bookmarks.  In these scenarios, restore times are largely uniform whether you have a 1TB database or a 100GB database (log replay notwithstanding).
3. If after considering hardware-assisted VSS, you STILL can’t leverage larger databases, confer with your storage vendor to architect for what will turn out to be large block reads at unpredictable rates and unpredictable intervals.  To the best of your ability, isolate the passive from active databases so that BDM doesn’t impact user mailboxes.
4. Ask Microsoft why passive database maintenance is not configurable.  As it is today, a completely passive Exchange server can generate over 500MB/s in read bandwidth.  Let’s be crystal clear about this: 500+ MB/s is data warehouse territory, and it’s absurd to think that this can occur with no active users on it, and no backups running against it.  It makes little sense, especially in configurations where the silent corruption they’re looking for is detected by other techniques.

Now, I have a couple questions I haven’t been able to get an answer to:

1. What happens to the schedule when checksum pass completes in less than 24 hours?  Does it start again in 24 hours?  Is that from the start of the prior run, or from the end of the prior run?  An authoritative answer would be helpful for those who have to plan for this workload.
2. What factors can make the scanning run faster or slower than “most” systems?  Does the system issue a 256KB every XX ms?  Does that depend on the processor clock rate?  Can we thus expect the read rate to increase with clock rate?  The difference between 5-8 MB/s doesn’t really matter on a single database, but it really does matter when you’re talking about hundreds or thousands of databases on a single disk array.

Oracle StatsPack/AWR Data Collection

In the interest of keeping our performance data collection procedures in one place for both Oracle and Windows, Bill Gaynor, Saty Desai and I have created a set of pages outlining the procedures for generating Oracle Statspack and AWR reports.

You can check them out here.

Geographically Dispersed Clustering with Windows

Have you ever wanted to know how you can automate site to site failover with Windows failover clustering, but only have 3 minutes to spend?

Here's a video just for you: