Suresh Nageswaran's blog

New blog at http://blog.sureshnageswaran.com/

Sun, 11 May 2008 06:38:24 -0500

This blog will remain my performance testing blog. In the meantime, I've created a new blog at http://blog.sureshnageswaran.com/

This is to cover newer topics like offshorability of testing, the service provider's view, building a Testing Centre of Excellence (TCoE) and general testing research I've been running over the years.

See you there!

Email account hacked: Do not use punekar@yahoo to contact me anymore

Sat, 26 Nov 2005 09:55:01 -0600

My punekar@yahoo.com account has been hacked and is unusable. I am discontinuing it.

Henceforth please contact me at sureshnageswaran@yahoo.com only.

LoadRunner and the GPL license: MI a potential victim to Stallmanism?

Thu, 24 Mar 2005 02:40:07 -0600

[textile]

Saturday afternoon, I spent listening to the monthly SPIN lecture here at Pune. The speaker was *Prakash Khot*, a senior architect from *CA* (Hyderabad). The topic was the *Eclipse TPTP* (Hyades) project and open source in general.

One of the more interesting things Prakash mentioned was that CA consciously does not use GNU/products covered by the GPL copyleft license, preferring instead, their home-baked TOSL. What then are the implications for Mercury LoadRunner, which is based on the GNU *LCC*, GNU *Regex* engine and the GNU *GCPP*?

Performance Tool Comparison: How LoadRunner,OpenSTA and JMeter stack up at runtime - 2

Mon, 28 Feb 2005 06:04:29 -0600

[textile]

In _*The Republic*_, _Plato_ conjectured on the idea of the dual level reality. One of these is known as the divided line:

!http://oregonstate.edu/instruct/phl201/images/philosophers/plato/divided_line.gif!

Above the line are the attributes of objective reality; below the line are the attributes of relative reality. This is not very different from user experienced times and response times measured from engineered tests. The problem, then, is to know whether a tool, even a favourite one, tells an objective truth or a relative truth! :)

Performance Tool Comparison: How LoadRunner,OpenSTA and JMeter stack up at runtime -1

Mon, 28 Feb 2005 06:30:15 -0600

[textile]

Comparing features among tools, especially performance testing tools, brings another dimension of complexity. The basic premise behind a performance test is to understand what response times can be expected by simulation of user traffic modeled along user actions. These response times may be TTLB (Time to Last Byte) measurements - and usually exclude browser render time. It is merely the time since the request was issued to the time the last byte of the response flowed into the network card on the machine. From the wire to a nicely formatted page on a browser is something not factored into the test.

Performance Testing: Getting freeware to stack up to commercial tools

Fri, 11 Feb 2005 23:23:09 -0600

[textile]
The most popular content on this site seems to be Anthony's comparison between *OpenSTA* and *LoadRunner*. I'm not surprised - Mercury's *LoadRunner* is the most popular tool in this space, but no company is hated more by it's user base. The first and prime responsibility for this anomalous situation must be borne by Mercury's corporate licensing department. A more hostile consumer licensing policy does not exist.

Undocumented LoadRunner Series: Using Micexec to record from multiple sources

Mon, 17 Oct 2005 20:38:05 -0500

[textile]

That LoadRunner's recording engine hooks into browsers is a fact known to all those who've worked with the tool. What's not known is that the recording engine can also hook into non-browser applications at the same time it is hooked into a browser. As a result, the generated LR script will contain calls made by one browser and one external application.

Why is this of interest ?

Perhaps you have some VB/JScript code running in your browser that invokes a local DCOM server. This DCOM server in turn, makes some HTTP calls and you'd like that to be part of the generated script as well. But how do you trap that HTTP traffic in addition to what you're already doing?

LR documentation of the Record/Replay process

Wed, 02 Feb 2005 09:30:59 -0600

A lot of documentation about the record/replay drivers has been included in the new Virtual User Generator User's Guide in 8.0. A separate chapter titled Information for Advanced Users documents much of this.

What is interesting is that the Binary VUser has also made it to the world of documented stuff. Another very interesting thing is the procedure to add newer protocols.

On introducing Parameterization and Correlation concepts differently in LR trainings

Thu, 17 Feb 2005 23:32:56 -0600

[textile]

Two things that confuse the hell out of LoadRunner newbies are the concepts of parameterization and correlation. Most training programs introduce these concepts from the perspectives of file-based input and server-related inputs and talk about the API functions that support them much later.

Here's something that worked on one of my training programs. I look at variables from an ANSI C perspective. For folks with a C programming background, this context tends to maker introduction to these concepts that much easier.

LoadRunner: Compilation and Runtime - 2

Wed, 02 Feb 2005 09:31:59 -0600

So now that we have a little more insight into the compilation process, let's look at what we start with and what we end with. To do this, like I mentioned earlier, we need Dep Walk.

Dependency Walker 2.0 comes with a rather nifty feature called Application Profiling. This is a technique used to watch a running application to see what modules it loads. Dynamically loaded modules that are not necessarily reported in any on the import tables of other modules can be detected this way.

LoadRunner: Compilation and Runtime - 1

Wed, 02 Feb 2005 09:43:28 -0600

We start from our friend MDRV.exe who sits smugly in the bin folder. This process does a whole bunch of things including:
* Invoking the compiler to compile LR code
* Invoking the interpreter (effectively acting a runtime)
* Actually running on a generator host
* Debugging

To understand MDRV from a runtime perspective is to compare it to the Win32 and Java platforms. Here's a simple comparison.

Innards of LoadRunner - the compilation process

Wed, 02 Feb 2005 09:32:27 -0600

Compilers and interpreters have always interested me. I can't remember when or how I started tinkering with Mercury LoadRunner's implementation. It seems clear that it compiler ANSI C - the actual stuff behind remained hidden and undocumented. In fact, it still is.

MI is a company run by rather smart people. Well, they wouldn't be worth close to a billion dollars if they hadn't! They took two disparate opensource tools and stuck them together and created an interpreter interface as a front end. The tools I'm talking about are: