Recently, SMBC Comics made the comment that, “In Britain, they have whilst loops, which do not terminate until the Queen says it's appropriate.”

If you are a programming language aficionado, you may recognize this keyword chiefly from languages of P-Celtic (especially Common Brythonic) origin.

One thing you may not know is that the PowerShell team has a huge Canadian contingent. There have been many Canadians responsible for PowerShell’s success, and early tab completion implementations automatically expanded “o” to “ou”. For example, Set-ConsoleColo<TAB>.

Those never made it into the product, but the official pronunciation of the about_* help topics continues to be (IPA əbʌʊt).

That said, how do you get the well-known ‘whilst’ keyword in PowerShell? With the new Invoke-WebRequest cmdlet in PowerShell version three, this is a breeze!

Will Steele asked today on Twitter how we did the analysis to come up with this post on the PowerShell blog in 2009. In brief, it’s a blog post that addressed some performance issues in the .NET framework that were causing Get-ChildItem to be slow. How did we know it was the .NET APIs slowing us down?

The answer came from Visual Studio by way of Software Profiling. Surprisingly, there aren’t many resources for this on the Internet – but here’s a good one: http://msdn.microsoft.com/en-us/magazine/cc337887.aspx.

(Aside: we worked with the .NET team to make some higher-performance APIs after we discovered this issue, and we were able to start using them in PowerShell version three.)

At it’s core, software performance profiling takes one of two approaches:

• Instrumented. While compiling (or as a separate stage), a tool injects markers into the beginning and end of every function in your program. These markers measure how much time each function takes, and then you can do fancy reports based on this data. This approach is very accurate, but also very invasive. It significantly slows down the target application, and requires code injection into potentially off-limits binaries.
• Sampled. This type of profiler runs a program, but then pauses it every once in a while to investigate what it’s doing. If it answers “Filling directory attributes” 50% of the time, then it is statistically spending about 50% of its time filling directory attributes. This approach is not as accurate as instrumentation-based profiles, but has far less system impact. There are many great tools out there for software profiling, and most of them offer both of these approaches. However, if you don’t have one handy, what is an alternative?

The answer is commonly called a “poor man’s profiler”.

Most systems have a debugger installed, or can get one installed easily. Microsoft ships a few in an excellent kit called the “Debugging Tools for Windows”.

In a poor man’s profiler, you attach to the process in question, extract a stack trace, and then detach. A stack trace tells you you what internal function the program is executing, and which functions were called along the way. For example, attaching the WinDbg debugger to PowerShell during a directory listing shows something like this:

0:008> !loadby sos mscorwks
0:002> ~*e !CLRStack

OS Thread Id: 0x2c78 (8)
Child-SP         RetAddr          Call Site
000000ea3753d830 000007fe0a45cc5c DomainNeutralILStubClass.IL_STUB(System....
000000ea3753d9b0 000007fe0a46603b System.IO.File.FillAttributeInfo(System....
000000ea3753dae0 000007fe0aae86fd System.IO.FileSystemInfo.Refresh()   
000000ea3753db10 000007fe093633b2 System.IO.FileSystemInfo.get_Attributes()
000000ea3753db40 000007fe09363585 Microsoft.PowerShell.Commands.FileSystemProvider.Dir(...)
(...)

Now, you can’t really get a good answer from doing this just once. Doing this hundreds of times is the secret, but doing that by hand gets old pretty quick.

When automation is the question, PowerShell is the answer, of course. Here’s an example of profiling Internet Explorer as it chews up my CPU using HTML5 to emulate fire:

PS C:\Windows\system32> $frames = C:\temp\Get-ProcessProfile.ps1 -ProcessId 126
56 -UseNativeDebugging
PS C:\Windows\system32> $frames | % { $_[0] } | group | sort Count | Select Cou
nt,Name | ft -auto

Count Name
----- ----
    1 JSCRIPT9!JsVarRelease
    1 ntdll!ZwFreeVirtualMemory
    1 ntdll!NtAlpcSendWaitReceivePort
    1 msvcrt!ftol2_sse
    1 msvcrt!isatty
    2 msvcrt!memcmp
    2 nvwgf2um!NVAPI_Thunk
    2 MSHTML!RunHTMLApplication
    7 JSCRIPT9!DllCanUnloadNow
   15 JSCRIPT9!DllGetClassObject
   27 JSCRIPT9!JsVarToScriptDirect
  100 ntdll!DbgBreakPoint
  200 wow64!Wow64SystemServiceEx
  799 ntdll!NtWaitForWorkViaWorkerFactory
 1487 wow64cpu!TurboDispatchJumpAddressEnd

And the script: