LongEx Mainframe Quarterly - March 2011
The size of your mainframe, LPAR, or z/VM image, is important. It directly affects the cost of your software. It is essential for capacity and disaster recovery planning. And it often determines the cost of an outsourced mainframe. But finding this out is not as easy as you'd think. So how can you find out how big your mainframe really is?
Method One: MIPS
MIPS, or Millions of Instructions per Second, is probably the most common unit used when talking about mainframe capacity. When mainframes were still young, manufacturers could measure the MIPS capacity by running a small standard routine over and over again.
However MIPS has not been a meaningful measurement for decades. IBM mainframes have a huge number of instructions: some are simple and quick, others complicated and slow. One application using five million simple instructions will use a lot less CPU than one using five million complicated ones. And the number of instructions available is increasing: the z196 has 100 new ones.
Today's processors also use a large range of tricks to improve performance which blurs the very meaning of the term instruction. These range from caching instructions and data to converting complex instructions into more simple ones in microcode. What's more, an increasing amount of processing power is being used for housekeeping tasks such as managing multiprocessor systems and LPAR management. So MIPS is no longer connected to anything real.
Consultants and analysts such as Gartner and IDC publish a list of MIPS ratings for each mainframe model. However these values are not from independent measurements, but are calculated from IBMs published values.
IBM doesn't publish MIPS ratings as such. However it does publish a Processor Capacity Index (PCI) in its Large Systems Performance Reference (LSPR) which is basically the same.
The risk with using published MIPS values is that they aren't the same. For example, the capacity for an IBM 2064-1C5 varies from 1029 (Watson Walker) and 1085 (Hascon) to 1014 (IBM). This difference comes from the fact that MIPS values are calculated from the capacity difference between the processor and a base processor model with a defined MIPS value. For example, IBM uses the 2094-701 as a base machine, and assumes its capacity is 506 MIPS. The z196 2817-502 has been measured to be around twice as big, so its MIPS value will be 2 * 506, or 1122. Different publishers use different base processor models and values.
Even using values from one publisher at different times is fraught with danger. IBM changed the base MIPS value of the 2094-701 from 568 in October 2008 to 506 in May 2010. This means that MIPS ratings for all its machines similarly changed.
So MIPS are fine if you're looking for a very rough guide, but can vary a lot depending on the source and the time the value is obtained.
Method Two: MSU
Traditionally CPU seconds, or the number of seconds a CPU is actually in use, was a measurement of how much work a processor performed. CPU seconds was, and often still is, used as a measurement for charging mainframe usage. z/OS records the number of CPU seconds that each unit of work has consumed, providing an excellent way of measuring the workload. The problem is that the amount of work that can be done in one CPU second is not the same for each processor model. So one z800 CPU second is different to a z196 CPU second.
Service Units were developed to be a number that can be compared across processors. They are calculated by multiplying CPU seconds by a constant value, called an SRM (Systems Resource Manager) constant. IBM publishes SRM constants for each of its processors; and you may think that this could be used as a measure. But the SRM constant has nothing to do with processor size. The z196 2817-415 has the same SRM constant as the 2817-401, but is around 12 times the capacity.
It's from Service Units that MSU was created: Millions of Service Units per Hour. MSU measures the rate of CPU usage, but also can refer to the size of a processor. So a processor with a MSU of 100 can process up to 100 million service units per hour.
Anyone who wants the capacity of a single LPAR or z/VM image rather than the whole processor complex will like MSU. Unlike MIPS, it is possible to obtain the MSU rating for any LPAR or z/VM image. In fact, when systems programmers limit the capacity of an image, they specify an MSU value. Even better, application programs can access this MSU rating. Example REXX and C programs can be found in the Longpela Expertise Tools and Resources section.
MSU is primarily intended for software licensing. Most vendors scale their software licensing fee to an MSU rating. IBMs sub-capacity licensing also uses MSU when calculating the final bill. This makes MSU a tempting number to use for everything, however the very fact that IBM uses it for software licensing is its downfall.
IBM has felt free to tweak the MSU capacity of processors in order to lure users to a newer machine. Recent processor generations have offered a 10% MSU 'discount' on previous models. Or in other words, an application using 100 MSU on a previous processor would only use 90 on the newer model. IBM has offered no MSU discount for the z196.
So it is no surprise that IBM recommends against using MSU for serious capacity planning. But MSU discounting is not the only reason. IBM has found that MSU, as well as MIPS values, can change depending on the workload. So a batch workload will have a different MIPS or MSU to an online workload. In fact IBM has found that this difference is larger with more recent processor models. For example, the difference can be up to 8% for a zSeries 800, and an incredible 34% for the latest z196.
IBM recommends another way of determining capacity.
Method Three: ITR
IBMs preferred method is to use the Internal Transaction Rate (ITR) published in its LSPR. This is a number that compares a processor to IBMs base 2094-701 processor, which has an ITR of 1.0. The z196 2817-412 has an average ITR of 4.28, so it is 4.28 times the size of the 2097-701.
The ITR is measured by IBM for a variety of different workloads such as batch, online transaction and web. The idea is that users calculating their mainframe's capacity match their workload to the closest equivalent workload in the LSPR, and use that value. IBM uses the average ITR for calculating MIPS values.
This ITR still isn't perfect. With large differences from workload mixes in the latest processors, there can still be a very big difference between your processor's workload and the ITR workload. To get around this problem, IBM has created a PC-based tool to calculate a system's ITR value from RMF and other data. This tool, called the zPCR (System z Processor Capacity Reference), is by far the best way to calculate a system's capacity. It can be downloaded free from the IBM website.
In a nutshell, use ITR for serious capacity planning, MIPS if you want a nice easy number, and MSUs if you're working with software licensing. All these numbers can be found from IBMs LSPR website, and other publishers such as Hascon, Watson-Walker, Gartner and IDG. However if you need accurate numbers, you need to calculate the capacity using IBMs zPCR tool.