Flipping Bits

Best Practices for Windows Mounts Points

Mount points – they’re understandably popular.  And although they’ve been around for quite a while, some people have questions around their implementation.  Yes, they’re really easy to set up, but you should follow some guidelines so you can take leverage advanced technologies down the road.

For the uninitiated, here’s an quick overview of mount points:

Traditionally, a windows volume (disk drive, LUN, etc) had to be mounted to a drive letter for Windows to access it.  This results in a limitation of 24 hard drives that can be mounted to a system.  To overcome this limitation, Microsoft introduced the ability to mount a drive on an empty directory within any NTFS filesystem.  You can try it yourself next time you format a USB stick.  It’s quite neat – now you can have a virtually unlimited number of drives attached to your system.  You know, like UNIX.  .  It also makes it easier to find stuff.

Here’s an example:  Let’s say I have a database with 2 data files, and 1 transaction log, and I want to keep them on separate drives for recovery and performance purposes.  Instead of mounting them to letters g:\, h:\ and i:\, I can do this:

• g:\dbname\dbfile01
• g:\dbname\dbfile02
• g:\dbname\tlog

Where dbfile01, dbfile02, and tlog are all empty directories on which a drive is mounted (mount point).  The directory structure is clear to anyone who looks at it, and if I need to add more drives to my database I just create a directory in dbname, and put a drive on it.  I try not to put the mount points on my system drive (c:\), although I’m allowed to.  The reason is that the mount point looks just like a directory – you have to know that it’s a mount point.  When I have it on another drive letter, it’s clear that there’s another drive there. 

So what’s a nested mount point?  As the name implies, it’s where you have a mount point within a mount point.  In our case, the dbname directory could be a mount point.

Are nested mount points categorically a bad idea?  Absolutely not – in fact it’s a pretty common practice.  The key is that there shouldn’t be unique data higher in the directory structure than a mount point.  For example, this is a bad idea:

• g:\dbname\dbfile
• g:\dbname\dbfile\tlog

Where both dbfile and tlog are both mount points.  First, it wouldn’t occur to another DBA that tlogs is actually a different drive.  It also has implications for backup and recovery if you’re trying to leverage a volume-based backup and recovery system.  The reason for this becomes clear when you start playing through a recovery scenario.  Let’s say I want to restore my database, but keep my transaction log around for replay.  VSS and the SQL Virtual Device Interface (VDI) backup and restore at the disk level rather than the file level.  So I’ve completely replaced not just g:\dbname\dbfile, but also g:\dbname\dbfile\tlog, where the transaction log lives.

I haven’t necessarily lost any data – I can just go find the tlog drive, mount it up, and continue my recovery.  But it clearly poses problems if I want to automate the process.

So this causes all sorts of confusion around whether nested mount points are supported.  In the case of Replication Manager, the answer is yes, nested mount points are supported, as long the volumes in the application set are not nested within each other.  To give examples, this is supported:

• g:\dbname\dbfile
• g:\dbname\tlog

Where dbname, dbfile, and tlog are all mount points, but only dbfile and tlog are part of the application set being protected.

On the other hand, this is not supported:

• g:\dbname\dbfile
• g:\dbname\dbfile\tlog

Where dbfile and tlog are mount points and both part of the application set being protected.

If you have any lessons learned about mount points you think are worth sharing, post a comment below!

Perfmon Counter of the Month–Disk Queue Length

OK, so maybe Perfmon Counter of the Week was a little optimistic.  Let’s say month, OK?

This one is another disk-related counter, but I like it because there’s so much myth around it.  It seems anytime I see a document around disk performance as it related to an application, I see references to “disk queue length”.  And it is either really vague, like “monitor the disk queue length – if it’s high, you may have problems with the disk subsystem,” or it’s really specific like “if your disk queue length is consistently higher than 2, you may have a problem with your disk”.

And neither piece of advice is quite wrong, nor is it quite right.

Here’s the thing with disk queue length, and any other queue-oriented counter:  Whether a queue length is “bad” or “good” depends on the number of resources servicing the queue. 

Imagine you’re in line at the grocery store.  There’s a single cashier, and there are nine people in front of you.  That’s a queue length of ten, and you’ll start wondering whether you really need the quinoa your wife told you to get.  Now imagine that there’s a single line with nine people in front of you, but there are 5 cashiers.  You still have a queue length of ten, but you’re going to be through it in a lot less time.  In fact, it’s better than having one person in front of you if there’s a single cashier, because that dude in front of you might have 63 coupons and a checkbook. If there are other cashiers, he’s only dominating one of multiple resources.

Unfortunately, that doesn’t make the quinoa look any more appetizing.

So does that mean that disk queue length is useless?  Not at all.  If you know how many resources there are servicing the LUN, then you can see whether it’s really a problem or not.  Typically the rule of thumb is 2 per disk.  So a queue length of 6 may indicate a bottleneck if you only have 2 disks in the RAID group servicing the LUN.  But it’s really not a problem if you have a 10-disk R1/0 RAID group.  The same goes for processor queue length.

The other aspect in which it is interesting is trending.  I’m a huge fan of measuring performance stats when application performance is good so that you have something to compare it to when things go downhill.  So it’s useful as a comparative value as well.  Even if you don’t have performance data from the “good times”, you can still visualize it with a time-series chart.

I/O Density and Exchange: A short history

Turns out that some people are dubious that Exchange 2010 and 7.2k drives are a good fit.   So I’m sometimes asked to justify spending less on storage for Exchange (a seemingly odd, but ultimately honest position to take).

Up until a short while ago, I just trotted out Microsoft’s graphs regarding the IO per “heavy use” mailbox they see in production.  It shows a 10x decrease in IO per mailbox between Exchange 2003 and Exchange 2010.

This can be unconvincing to some of the folks who fought Exchange 5.5, 2000, and 2003 in the trenches, where it was common knowledge that not only did you put Exchange on the fastest storage available, you often had to allocate more disks than you needed for capacity to meet the performance demands of the application.  A 10x reduction in IO workload doesn’t convincingly take you from “put it on the fastest storage you can afford” to “put it on the slowest storage you can buy”.

The story is actually two-fold – at the same time that IO per mailbox was being driven down, the size of the mailboxes were being driven up.  Since storage sizing is and always has been a balance between performance (how quickly you need to move data on and off the drives) and capacity (how much data you need to store on the drive), IO density (or IO per GB) is far more relevant than IO per mailbox.  In short, we don’t just look at how many IOs Exchange is driving per mailbox, we have to factor in how big those mailboxes are as well.  Typical mailboxes were only 50MB-100MB during the Exchange 2003 days.  Nowadays they’re between 10 and 100 times that.  When we do factor in mailbox sizes, it turns out that IO density isn’t 10 times lower with Exchange 2010, it’s orders of magnitude lower in most modern Exchange configurations.

I’ve come up with a graph to illustrate this notion. 

So while we saw “only” a 10x decrease in the IO per mailbox, we saw over a 400x decrease in IO per gigabyte.

Now let’s take a look at the IO density that spinning disks have offered throughout the years.

Clearly these are simple examples – the mailbox IO was far more variable in the 32-bit versions of Exchange, and the IO/GB for the disk drives doesn’t include RAID overheads, there’s no free space factored in and so forth.  But when we interpolate the IO/GB driven by mailboxes and the IO/GB provided by disks, it matches up pretty well with the typical disk topologies I recommend:

In the Exchange 5.5 to 2003 days, every IO counted, and you had allocate more disks to the Exchange workload than you needed for capacity.  Things got a lot better in Exchange 2007, where you could place your average mailboxes on either smaller 10k FC drives or larger 15k FC drives.  With Exchange 2010 and large mailboxes, the sweet spot for the typical deployment is somewhere between 1TB and 2TB drives.

Now this isn’t to say that 2TB or 1TB drives are appropriate for all Exchange deployments.  A large number of factors go into sizing storage for Exchange.  But if you’ve done your homework and factored in all the variables, and it looks like the slower drives are the way to go, then you should trust your sizing and save your organization some money.

Perfmon Counter of the Week: Logins/Sec

For the second in the series, I’m going to take a look at Logins/Sec.  You get this from SQLServer:General Statistics\Logins\sec.  It has impact on the user experience, as it takes time to set up a connection, and also has impact on the CPU consumption, as documented in Linchi Shea’s excellent blog post on the topic.  It’s important to remember that the stats reported by logins/sec do not include pooled connections

As you might imagine, there’s a direct correlation between logins/sec and transactions hitting the Master database as shown in the graph below.  I scaled them differently to show correlation, because it turns out they overlap otherwise (one login equals one transaction to Master).

You can find some great information on how to tell if connections are pooled or not in James Rowland-Jones blog post here.

There are a number of resources out there to help you figure out and solve issues around connection pooling.    Mohammed Mawla has a good post about the subject, but I think the best succinct advice is from Microsoft:

"To make the best use of connection pooling, explicitly close database connections as soon as possible. By default, a connection terminates after your script finishes execution. However, by explicitly closing a connection in your script after it is no longer needed, you reduce demand on the database server and make the connection available to other users."

Option 4: Third Party Replication (Or: How Stella Got Her Single Copy Cluster Back)

This is the fifth and final post in a series about the various options to achieve HA and DR with Exchange 2010.  In the first, I broke the DAG into its basic components (Active Manager and DAG replication).  In the second, I gave a quick overview of Native DAG.  In the third, I covered a hybrid approach that combined DAG replication and Active Manager for local HA, and array/SAN based replication for remote site recovery.  In the fourth, I described an option that deploys Exchange in a standalone configuration and leverages a hypervisor to achieve local high availability.

This one will cover Exchange’s Third Party Replication.  This one definitely has a lot of cool factor in it.  It actually leverages DAG (in the form of Active Manager) with array or SAN-based replication technology.  You get all the automatic failover, live patching, Exchange-aware coolness of DAG, zero data loss, and you only have to deploy one copy of the data at each site.

Although synchronous operation is possible with both Options 2 and 3, this is the only option shown that combines synchronous replication with automatic failover.

This option will use a plugin from EMC to coordinate the replication engine with Active Manager. This would be either Replication Enabler for Exchange 2010 (free!), or AutoStart 5.3 with the Exchange 2010 module. This option can also use a virtualization platform like Hyper-V or VMware, but a hypervisor is not necessary to leverage the benefits of this option.

Here are the cost factors:

• Storage: 2
• Network: 2

Architects and managers will typically consider this option when:

• Lossless, automatic failover is required
• Minimal hardware footprint is desired
• There is minimal latency between the sites
• A hardware VSS protection scheme is available for rapid recovery in the event of database corruption
• Live patching is required

Option 3: Virtualized Host Clustering

This is the fourth in a series of posts about the various options to achieve HA and DR with Exchange 2010.  In the first, I broke the DAG into its basic components (Active Manager and DAG replication).  In the second, I gave a quick overview of Native DAG.  In the third, I covered a hybrid approach that combined DAG replication and Active Manager for local HA, and array/SAN based replication for remote site recovery.

I call this option “Virtualized Host Clustering”, because like the Virtualized Local DAG option, this options leverages a hypervisor, but it leverages the HA capabilities of the hypervisor instead.  The Exchange mailbox role is deployed in a VM as a standalone server.  This is by far the least expensive option from all perspectives: acquisition, operation, complexity, footprint, and power.

As you can see, there are some clear cost benefits to this option. You are replicating only one copy of the database, and since the HA function is handled by the hypervisor, a second copy of the database is unnecessary. It’s also the most flexible option – the full suite of workload management tools provided by the hypervisor can be used, and we add a fourth potential replication engine – VPLEX.

I suppose it’s also worth noting that one does not necessarily need a virtualization layer to accomplish this. With the right operational recovery plan to replace the server and restore from backup, three nines (99.9% availability) could easily be achieved without any HA facility whatsoever (either at the application or hypervisor layer).

This is by far the least expensive option from all perspectives: acquisition, operation, complexity, footprint, and power.

Here are the cost factors broken down:

• Storage: 2
• Network: 2 (SRDF, MirrorView), .5 (RecoverPoint)

Administrators and managers will typically choose this option when want to:

• Minimize complexity of the deployment
• Use advanced virtualization features such as Live Migration/Vmotion, DRS, etc
• Achieve consistency with other line of business applications
• Control failover with scripts or tools like VMware Site Recovery Manager
• Control their RPO from zero data loss to minutes
• Have multiple recovery points at each site
• Control bandwidth utilized by replication
• Meet failover requirements not achievable with native Exchange’s Best Copy Selection

This solution is not without its drawbacks however.  Here are a couple of things to consider:

• This is the only option that where the administrator does not have the ability to do non-disruptive patching.  However, one should consider that boot times are pretty quick on virtual machines.  It’s very possible to achieve four 9’s (99.99% availability) with this solution despite the lack of live patching, and reboots can be scheduled for non-peak hours.
• Since only one copy of the data is available at each site, a rapid recovery mechanism for logical and physical failure modes is well advised.  This is usually achieved through hardware based snapshots or bookmarks at minimal cost.  It’s usually a good idea to have a rapid recovery scheme outside of the context of the application anyway, for a variety of reasons.

User Interfaces in Cars

This isn’t a topic I normally write about (or even think about).  But it’s been near top of mind for me as Mrs. Bits and I have been shopping for a new car.  We traded in our 2005 Toyota Sienna.  The primary feature we wanted was all-wheel drive (the 2011 New England winter was a nightmare), and of course, it needs to fit our little family of four and all the stuff we need for vacations and so forth. 

Another thing we wanted was a built in technology package that included most of the stuff we like to have around, especially for long trips.  In 2004, cutting edge vehicle technology meant having a place to plug in your iPod.  So one of the little frustrations of life was all the management of all the wires for the GPS, phone charger, DVD system, etc, etc.  Not to mention the lack of integration between all this stuff.   So one of the other things we wanted to splurge on was a robust system that we could be reasonably happy with seven or eight years from now as we progressively drive the wheels off the vehicle.

Pretty much every feature we wanted was available on every car we evaluated:  Navigation with traffic, bluetooth, satellite radio, auxiliary inputs.  Of course, all this comes at a price.  On every one of these vehicles, the tech kit was the single most expensive option on the car – typically between 10-15% of the total price of the vehicle.  Pretty hefty.

What struck me is how different the implementations were between vehicles.  Some had touch screens, some didn’t.  A couple had a particularly baffling interface that required manipulation of a joystick.  One of them was nowhere near the screen, but behind the gear shift, where the user doesn’t even have a view of the joystick.

Seriously?  You’re trying to sell me a $3500 computer where I have to blindly use a frickin joystick to type in addresses?  One salesman told me it was “because touch screens get fingerprints on them”.  Please.  I have two small kids.  Any space they occupy for more than about 10 seconds is filled with goldfish crackers and smooshed fig newtons.  Fingerprints on a touch screen don’t really concern me, especially since I can, you know, WIPE THEM OFF.

Eventually we decided on a Hyundai.  It was comparable in most respects to other vehicles we tested, but the UI on the navigation/phone/radio interface was the most familiar.  Basically, they tried to mimic other computer interfaces and GPS devices in wide use, and for the most part they were successful.

So I got to thinking about why there’s so much variance between the interfaces of different manufacturers, why so many otherwise high quality manufacturers can put out such insane technology, and whether differentiating your car with its electronics UI is a good idea.

I think I know why they do it.  It’s to differentiate themselves from their competitors; I know what it’s like to compete with other formidable products, and I realize that the smallest things can make the biggest difference to the customer.  It’s very easy for a competitor to match your specs in a car (mileage, acceleration, turning radius, etc), but it’s hard to replicate the “feel” of a car, and the tech package is a big part of the “feel” for people who actually buy and use it.

They continue to do it because nobody calls them out on it.  My brother in law is a car nut; he gets at least a half dozen car magazines, and I flip through them when I visit.  The reviewers focus on the driving experience.  How it handles, road noise, acceleration, and the numbers.  They do this because they’re all metrics, and they’re easy to review.  They barely pay attention to the technology kit, and if it's unusable, it hardly warrants a sentence.

I think it’s a terrible idea.  A moving vehicle is probably the worst possible place to introduce novel user interface concepts.  In addition, people tend to want a familiar user interface that’s easy for them to both figure how to manipulate, and works easily and quickly in operation.  It’s like trying to differentiate your car by putting the brake pedal on the right and introducing the great new pentagular steering wheel that’s safer because it forces you to rest your hands at 10 and 2.

I’m clearly not the only person who feels this way.  A quick browse turned up this article from 2004, which covers some automotive electronics UIs, but also things like remote controls.  I’m with him on the remote controls, but I’ll tell you, people don’t generally try to manipulate them on the highway.  He says that poor UIs lead to bad reviews, but I don’t agree.  Reviews of these devices barely mention a poor UI, despite the fact that I couldn’t imagine getting used to them, and people I know who have these systems barely leverage them precisely because of the UI.  He brings up a good point that manufacturers have little incentive to emphasize usability because the user doesn’t realize how bad it is until after they’ve paid for it.  He expresses hope for the future of the consumer product UI.  Unfortunately, it’s been seven years now, and few manufacturers are heeding his advice.

Option 2: Virtualized Local DAG

This is the third in a series of posts about the various options to achieve HA and DR with Exchange 2010.  In the first, I broke the DAG into its basic components (Active Manager and DAG replication).  In the second, I gave a quick overview of Native DAG.  In this post, I’m going to cover a pretty popular option for folks who’ve already made the decision to virtualize their Exchange environment.

I call it “Virtualized Local DAG” because it uses DAG replication and Active Manager for local HA, but third party technologies for remote replication and failover.

This configuration utilizes a hypervisor such as Hyper-V or VMware’s. A two member DAG group is created, and then both copies are replicated from one site to the other. It’s important to note that because HA is dealt with by Exchange natively, any HA or workload migration features offered by the hypervisor (such as VMHA, DRS, Live Migration and VMotion) should be disabled for the mailbox VMs (other Exchange roles can utilize those features).

As for the network cost, it’s going to be more expensive operationally – you’re replicating two copies of the databases and two copies of the logs, and the storage cost is identical to Native DAG Replication.  However, this can be mitigated through the use of interesting compression and data reduction techniques made available by products like RecoverPoint.

• Storage: 4
• Network: 4 (SRDF, MirrorView), 1 (RecoverPoint)

Why would anyone choose this option? Well first, the network cost isn’t much more than Native DAG replication when you need to make sure you can reseed your databases in a reasonable amount of time. And if you use a replication appliance like RecoverPoint, you can end up using even less bandwidth than Native DAG replication, owing to the very good compression and data reduction an appliance like that offers.

Basically, for customers who've decided to virtualize Exchange, and already have working replication technologies for other applications, this option offers a lot of flexibility, integration with their data center strategies, and costs nothing in terms of storage footprint when compared to traditional DAG.

Ultimately, people may choose this option when there’s a need for or concern about:

• Uptime while patching
• Simplified and coordinated failover of all Exchange roles and services
• The ability of the WAN to absorb re-seeding operations that will occur more frequently with log-based replication
• Better control of failover operations than what native Exchange’s Best Copy Selection can provide
• Full site failover of multiple applications (such as provided by PowerShell scripting with Hyper-V or VMware Site Recovery Manager)
• Consistency with other line of business applications
• Controllable RPO
• Synchronous replication (loss-less cross-site failover)
• Multiple recovery points are desired at each site
• Controllable bandwidth utilization
• Compliance and inclusion in a DR plan that includes other applications
• Business requirements that can’t be met by DAG replication or Active Manager

Option 1: Native Exchange DAG – A Quick Overview

Last month I promised a series of blog posts on the replication and HA options for Exchange, because it seems everywhere I go, people think they’re stuck with Database Availability Groups.  I started off with a level set on replication options in general, and then ended with the notion that you don’t necessarily need DAG replication and multiple copies to achieve HA and remote disaster recovery with Exchange 2010.  As Chad Sakac says, I’m agreeing to disagree with Microsoft on this point.  Microsoft contends that native Exchange approaches for protection, HA, and DR covers all needs, at all scales, and always at the lowest TCO.  I contend that sometimes it does, but not always.

So this is Option 1 in the series.  I'll be presenting three more options over the coming weeks.

DAG is actually pretty cool kit when you get into it, but like all techniques and technologies, it has its advantages and disadvantages.  Let’s get into it:

So here’s an illustration of what we’d call Native DAG Replication:

As you can see, it’s characterized by the use of DAG as the replication engine, and Active Manager as the failover manager. You might be wondering why I distinguish between the DAG members and physical copies. That’s because when you use third party replication (enabled by the Third Party Replication API in Exchange 2010 in conjunction with EMC’s Replication Enabler for Exchange), you can have multiple DAG members accessing the same physical disk (very similar to single copy clusters in previous versions of Exchange). Although it’s not shown here, this option can be deployed in conjunction with a virtualization platform like VMware or Hyper-V.

As a point of comparison, I’ll assign cost factors for storage and network. It’s fairly expensive in terms of storage – you need at least two copies locally. You can have one or two, or more copies at the remote site, but if you have only one copy, you should have enough bandwidth to comfortably reseed a full copy of all the databases on the server, since any number of situations can cause database divergence. If you don’t have the bandwidth, you can reduce the number of situations where a WAN reseed would be needed by putting a second copy at the DR site (as illustrated here). But operationally, network cost is low – only the transaction logs are replicated.

So the factors:

• Storage: 4
• Network: 1

Typically people would use this option when there is:

• A need for uptime while patching
• Plenty of bandwidth between sites
• Enough budget to acquire and maintain disk for 3-4 copies of the databases
• No need to coordinate Exchange site to site failover with other applications
• No need for zero data loss disaster recovery between sites
• No need to maintain consistency between Exchange and other line of business apps[1]
• The Best Copy Selection (BCS) process meets the requirements of the business unit

 

---

[1] An example of this might be a procurement application that leverages email or public folders for workflow

Perfmon Counter of the Week: Disk Latency

So far, all my blog posts have been sort of event-driven.  Something I read or hear about, perhaps something I’m doing for a customer tickles my fancy and I start to think about a blog post.  That’s probably why my blog went dark for a year and a half.  A few months ago my colleague Chuck Chiambalero suggested a “Perfmon Counter of the Week”.  I think really slowly, so I’m getting cracking on it now. 

About as slow as this guy

Each week, I’ll go over a perfmon counter or two that I regularly use when I’m sizing out a customer’s environment, or evaluating performance bottlenecks they may be having.  All of the counters I’ll be covering are collected in perfcollect (of course only if they’re available on the host – a SQL Server counter isn’t going to be collected if you run perfcollect on an Exchange server).

Anyway, Perfcollect looks for about 600 different counters for various applications, so that’ll keep me busy until 2023, at which point I’ll be busy selling my organs to raise college money for my kids.

We’ll start off with a couple of counters that are near and dear to my heart:  Average Disk sec/Read and Average Disk sec/Write.  These counters indicate the response time of the disk – how long it takes for a read or write request to get acknowledged by the disk.  You can grab this off of PhysicalDisk and LogicalDisk.  I prefer to look at LogicalDisk unless there’s a specific reason to be looking at PhysicalDisk.   As a general rule for databases, the average read latency should be less than 20ms for database files.  The average write latency should be 10ms for log files.  And of course since perfmon collects the data in seconds, you’ll have to multiply by a thousand in order to get your milliseconds.

General guidelines indicate that spikes should not be more than 50ms, but that’s pretty meaningless unless you’ve defined a sample interval (a 15 second sample interval is usually going to be a hell of a lot more spiky than a 2 minute or ten minute interval).

So is high disk latency ALWAYS a bad thing?  Well, no.  The numbers are there as a rule of thumb.  If you’ve got performance problems and there are high or relatively high latencies on the disks, you’ll be advised by support to investigate and fix it.  But if the latencies have been steady over time and the performance problems are new, clearly fixing the disk isn’t going to yield much for you.  Which is why it’s important not to wait until you have problems to collect perfmon data.

Another factor to consider is the IO size.  Logic and physics dictate that if you have two requests, one with a large amount of data, and one with a small amount of data, the smaller amount of data is going to complete more quickly on average.  With spinning disks and random workloads, the vast majority of time is spent seeking data as opposed to moving the data, but it’s still noticeable in a number of workloads.  So the larger the IO, the more latency you should expect.  Larger IO usually implies sequential workloads, which are measured in megabytes per second rather than IOs per second, anyway.

Can everything (including latency) be healthy and performance still stink?  Yes.  Imagine a transaction system where the organization gets paid by the number of transactions it can complete.  If the storage is a bottleneck and latencies are at 10ms, then the storage is still a bottleneck, and investigating advanced drive technologies is well advised.