Precision Computing

Somebody is selling their gigantic 30 year vintage computer collection as a single lot on EBay. 

At several hundred collectible computers, and nearly as many manuals, this is a really nice trip down memory lane.  Gotta get me one of those laptops!

In the last article, I introduced a library function to help you invoke inline C# from your scripts.  Since we carefully profiled the burn-console script’s performance, we know exactly where to apply these inline performance optimizations: to the updateBuffer function, and the updateScreen function.

The completed script is included below. The inline optimizations bring us to about 30 - 40 frames per second, easily fast enough to provide smooth animation.

###############################################################################
## burn-console.ps1
##
## Create a fire effect in PowerShell, using the Console text buffer as the 
## rendering surface.
##
## Great overview of the fire effect algorithm here: 
## http://freespace.virgin.net/hugo.elias/models/m_fire.htm
##
###############################################################################

function main
{
    write-debug "ENTER main"
    ## Rather than a simple red fire, we'll introduce oranges and yellows
    ## by including Yellow as one of the base colours
    $colours = "Yellow","Red","DarkRed","Black"
    
    ## The four characters that we use to dither with, along with the 
    ## percentage of the foreground colour that they show
    $dithering = "█","▓","▒","░"
    $ditherFactor = 1,0.75,0.5,0.25
    
    ## Hold the palette.  We actually store each entry as a BufferCell,
    ## since we need to retain a foreground colour, background colour,
    ## and dithering character.
    [System.Management.Automation.Host.BufferCell[]] $palette = `
        new-object System.Management.Automation.Host.BufferCell[] 256
    
    ## Resize the console to 70, 61 so we have a consistent buffer
    ## size for performance comparison.
    # $bufferSize = new-object System.Management.Automation.Host.Size 70,61
    # $host.UI.RawUI.WindowSize = $bufferSize

    ## Retrieve some commonly used dimensions
    $windowWidth = $host.UI.RawUI.WindowSize.Width
    $windowHeight = $host.UI.RawUI.WindowSize.Height
    $origin = `
        new-object System.Management.Automation.Host.Coordinates 0,0
    $dimensions = `
        new-object System.Management.Automation.Host.Rectangle `
            0,0,$windowWidth,$windowHeight
    
    ## Create our random number generator
    $random = new-object Random
    $workingBuffer = new-object System.Int32[] ($windowHeight * $windowWidth)
    $screenBuffer = new-object System.Int32[] ($windowHeight * $windowWidth)

    ## Store a reference to the Invoke-Inline script to save lookup time
    ## since we run it so often.
    $inline = Get-Command Invoke-Inline.ps1
    
    clear-host
    
    ## Generate the palette
    generatePalette
    # displayPalette
    # return;

    ## Update the buffer, then update the screen until the user presses a key.  
    ## Keep track of the total time and frames generated to let us display
    ## performance statistics.
    $frameCount = 0
    $totalTime = measure-command {
        while(! $host.UI.RawUI.KeyAvailable)
        {
            updateBuffer
            updateScreen
            $frameCount++
        }
    }
    
    ## Clean up and exit
    $host.UI.RawUI.ForegroundColor = "Gray"
    $host.UI.RawUI.BackgroundColor = "Black"
    
    write-host
    write-host "$($frameCount / $totalTime.TotalSeconds) frames per second."
    write-debug "EXIT"
}

## Update a back-buffer to hold all of the information we want to display on
## the screen.  To do this, we first re-generate the fire pixels on the bottom 
## row.  With that done, we visit every pixel in the screen buffer, and figure
## out the average heat of its neighbors.  Once we have that average, we move
## that average heat one pixel up.
function updateBuffer
{
    ## This function takes the most of our time, so we'll do it inline.
    ## Inputs:
    ##  Window Height
    ##  Window Width
    ##  Screen Buffer
    ##  Random Number Generator
    ## Output:
    ##  Working Buffer
    
    [System.Collections.ArrayList] $inputs = `
        new-object System.Collections.ArrayList
    [void] $inputs.Add([int] $windowHeight)
    [void] $inputs.Add([int] $windowWidth)
    [void] $inputs.Add([int[]] $screenBuffer)
    [void] $inputs.Add([System.Random] $random)
    
    $code = @"
    // Unpack the inputs from our input object
    int windowHeight = (int) ((System.Collections.ArrayList) arg)[0];
    int windowWidth = (int) ((System.Collections.ArrayList) arg)[1];
    int[] screenBuffer = (int[]) ((System.Collections.ArrayList) arg)[2];
    Random random = (Random) ((System.Collections.ArrayList) arg)[3];
    
    // Start fire on the last row of the screen buffer
    for(int column = 0; column < windowWidth; column++)
    {
        // There is an 80% chance that a pixel on the bottom row will
        // start new fire.
        if(random.NextDouble() >= 0.20)
        {
            // The chosen pixel gets a random amount of heat.  This gives
            // us a lot of nice colour variation.
            screenBuffer[(windowHeight - 2) * (windowWidth) + column] = 
                (int) (random.NextDouble() * 255);
        }
    }
    
    int[] tempWorkingBuffer = (int[]) screenBuffer.Clone();
    
    // Propigate the fire
    int baseOffset = windowWidth + 1;
    for(int row = 1; row < (windowHeight - 1); row++)
    {
        for(int column = 1; column < (windowWidth - 1); column++)
        {
            // Get the average colour from the four pixels surrounding
            // the current pixel
            double colour = 
                (
                    screenBuffer[baseOffset] + 
                    screenBuffer[baseOffset - 1] + 
                    screenBuffer[baseOffset + 1] + 
                    screenBuffer[baseOffset + windowWidth]
                 ) / 4.0;

            // Cool it off a little.  We apply uneven cooling, otherwise
            // the cool dark red tends to stretch up for too long.
            if(colour > 0)
            {
                if(colour > 70)
                { 
                    colour -= 1; 
                }
                else
                {
                    colour -= 3;
                    
                    if(colour < 1)
                    {
                        colour = 0;
                    }
                    else if(colour < 20)
                    {
                        colour -= 1;
                    }
                }
            }

            // Store the result into the previous row -- that is, one buffer 
            // cell up.
            tempWorkingBuffer[baseOffset - windowWidth] = (int) colour;
            baseOffset ++;
        }
        
        baseOffset += 2;
    }

    returnValue = tempWorkingBuffer;
"@

    $returned = & $inline $code $inputs
    $SCRIPT:workingBuffer = $returned
}

## Take the contents of our working buffer and blit it to the screen
## We do this in one highly-efficent step (the SetBufferContents) so that
## users don't see each individial pixel get updated.
function updateScreen
{
    write-debug "ENTER updateScreen"
    
    ## This function takes up a lot of time, so we'll do it inline.
    ## Inputs:
    ##  host.UI.RawUI
    ##  palette
    ##  workingBuffer
    ##  origin
    ##  dimensions
    ##  windowHeight
    ##  windowWidth
    ## Output:
    ##  None
    
    [System.Collections.ArrayList] $inputs = `
        new-object System.Collections.ArrayList
    [void] $inputs.Add([System.Management.Automation.Host.PSHostRawUserInterface] $host.UI.RawUI)
    [void] $inputs.Add([System.Management.Automation.Host.BufferCell[]] $palette)
    [void] $inputs.Add([int[]] $workingBuffer)
    [void] $inputs.Add([System.Management.Automation.Host.Coordinates] $origin)
    [void] $inputs.Add([System.Management.Automation.Host.Rectangle] $dimensions)
    [void] $inputs.Add([int] $windowHeight)
    [void] $inputs.Add([int] $windowWidth)
    
    $code = @"

    System.Management.Automation.Host.PSHostRawUserInterface rawUI = 
        (System.Management.Automation.Host.PSHostRawUserInterface)
            ((System.Collections.ArrayList) arg)[0];
    System.Management.Automation.Host.BufferCell[] palette =
        (System.Management.Automation.Host.BufferCell[]) 
            ((System.Collections.ArrayList) arg)[1];
    int[] workingBuffer = 
        (int[]) ((System.Collections.ArrayList) arg)[2];
    System.Management.Automation.Host.Coordinates origin = 
        (System.Management.Automation.Host.Coordinates)
            ((System.Collections.ArrayList) arg)[3];
    System.Management.Automation.Host.Rectangle dimensions = 
        (System.Management.Automation.Host.Rectangle)
            ((System.Collections.ArrayList) arg)[4];
    int windowHeight = (int) ((System.Collections.ArrayList) arg)[5];
    int windowWidth = (int) ((System.Collections.ArrayList) arg)[6];

    // Create a working buffer to hold the next screen that we want to
    // create.
    System.Management.Automation.Host.BufferCell[,] nextScreen = 
        rawUI.GetBufferContents(dimensions);
    
    // Go through our working buffer (that holds our next animation frame)
    // and place its contents into the buffer that we will soon blast into
    // the real RawUI
    for(int row = 0; row < windowHeight; row++)
    {
        for(int column = 0; column < windowWidth; column++)
        {
            nextScreen[row, column] = palette[workingBuffer[(row * windowWidth) + column]];
        }
    }
    
    // Bulk update the RawUI's buffer with the contents of our next screen
    rawUI.SetBufferContents(origin, nextScreen);
"@
    & $inline $code $inputs
    
    ## And finally update our representation of the screen buffer to hold
    ## what actually is on the screen
    $SCRIPT:screenBuffer = $workingBuffer.Clone()

    write-debug "EXIT"
}

## Generates a palette of 256 colours.  We create every combination of 
## foreground colour, background colour, and dithering character, and then
## order them by their visual intensity.
##
## The visual intensity of a colour can be expressed by the NTSC luminance 
## formula.  That formula depicts the apparent brightness of a colour based on 
## our eyes' sensitivity to different wavelengths that compose that colour.
## http://en.wikipedia.org/wiki/Luminance_%28video%29
function generatePalette
{
    ## The apparent intensities of our four primary colours.
    ## However, the formula under-represents the intensity of our straight
    ## red colour, so we artificially inflate it.
    $luminances = 225.93,106.245,38.272,0
    $apparentBrightnesses = @{}

    ## Cycle through each foreground, background, and dither character
    ## combination.  For each combination, find the apparent intensity of the 
    ## foreground, and the apparent intensity of the background.  Finally,
    ## weight the contribution of each based on how much of each colour the
    ## dithering character shows.
    ## This provides an intensity range between zero and some maximum.
    ## For each apparent intensity, we store the colours and characters
    ## that create that intensity.
    $maxBrightness = 0
    for($fgColour = 0; $fgColour -lt $colours.Count; $fgColour++)
    {
        for($bgColour = 0; $bgColour -lt $colours.Count; $bgColour++)
        {
            for($ditherCharacter = 0; 
                $ditherCharacter -lt $dithering.Count; 
                $ditherCharacter++)
            {
                $apparentBrightness = `
                    $luminances[$fgColour] * $ditherFactor[$ditherCharacter] +
                    $luminances[$bgColour] *
                        (1 - $ditherFactor[$ditherCharacter])
                    
                if($apparentBrightness -gt $maxBrightness) 
                { 
                    $maxBrightness = $apparentBrightness 
                }
                    
                $apparentBrightnesses[$apparentBrightness] = `
                    "$fgColour$bgColour$ditherCharacter"
            }
       }
    }

    ## Finally, we normalize our computed intesities into a pallete of
    ## 0 to 255.  If a given intensity is 30% towards our maximum intensity,
    ## then it should be in the palette at 30% of index 255.
    $paletteIndex = 0
    foreach($key in ($apparentBrightnesses.Keys | sort))
    {
        $keyValue = $apparentBrightnesses[$key]
        do
        {
            $character = $dithering[[Int32]::Parse($keyValue[2])]
            $fgColour = $colours[[Int32]::Parse($keyValue[0])]
            $bgColour = $colours[[Int32]::Parse($keyValue[1])]
            
            $bufferCell = `
                new-object System.Management.Automation.Host.BufferCell `
                    $character,
                    $fgColour,
                    $bgColour,
                    "Complete"
                    
            $palette[$paletteIndex] = $bufferCell
            $paletteIndex++
        } while(($paletteIndex / 256) -lt ($key / $maxBrightness))
    }
}

## Dump the palette to the screen.
function displayPalette
{
    for($paletteIndex = 254; $paletteIndex -ge 0; $paletteIndex--)
    {
        $bufferCell = $palette[$paletteIndex]
        $fgColor = $bufferCell.ForegroundColor
        $bgColor = $bufferCell.BackgroundColor
        $character = $bufferCell.Character

        $host.UI.RawUI.ForegroundColor = $fgColor
        $host.UI.RawUI.BackgroundColor = $bgColor
        write-host -noNewLine $character
    }
    
    write-host
}

. main

 

[Edit: Monad has now been renamed to Windows PowerShell. This script or discussion may require slight adjustments before it applies directly to newer builds.]
[Edit: Updated to work with PowerShell RTM and updated Invoke-Inline.ps1 script]

In the last post, we got nearly as far as we could in improving the performance of our MSH script.  We used the profiler to help target our performance optimizations.  After we were finished, setting variables, incrementing counters, and comparing colour values took up the vast majority of our time.  We can’t make these statements more efficient, nor can we execute them less frequently.

To really push the performance of this script, we’ll write the highly critical sections using inline C#, rather than MSH.

This interop idea is something that many people end implement on their own after playing with .Net (and MSH) for any length of time.  I use it extensively in my C# Performance Comparison tool, MOW wrote it for VB in MSH, Jeffrey Snover wrote it for C# in MSH (as did half of the rest of the Monad team,) and Bruce Payette even wrote one for MSIL in MSH.

Normally, I would just link to an implementation of “C# in MSH,” but I’m going to offer a library function that goes a bit further:

1. The inline C# accepts dynamic arguments, and returns dynamic values.  Other implementations hard-code the parameters, and can’t interact with the rest of the script.
2. The inlining mechanism caches the temporary compiled C# class.  No matter how often you call the same inline code in a script, you will only suffer the (relatively minor) compilation burden once.
3. The inlined code does not require any class definitions, namespace imports, or other template code.

It is commented in excruciating detail below.  Don't worry, you'll have a nice speedy fire warming up your console in no time flat.

[Edit: A better way to get the installation path of PowerShell is $psHome]
[Edit: Updated to work with RTM builds]
[Edit: Added ability to reference other DLLs]

################################################################################ 
## Invoke-Inline.ps1
## Library support for inline C# 
## 
## Usage 
##  1) Define just the body of a C# method, and store it in a string.  "Here 
##     strings" work great for this.  The code can be simple: 
## 
##     $codeToRun = "Console.WriteLine(Math.Sqrt(337));" 
## 
##     or more complex: 
## 
##     $codeToRun = @" 
##         string firstArg = (string) ((System.Collections.ArrayList) arg)[0]; 
##         int secondArg = (int) ((System.Collections.ArrayList) arg)[1]; 
## 
##         Console.WriteLine("Hello {0} {1}", firstArg, secondArg ); 
##      
##         returnValue = secondArg * 3; 
##     "@ 
## 
##  2) (Optionally) Pack any arguments to your function into a single object. 
##     This single object should be strongly-typed, so that PowerShell does
##     not treat  it as a PsObject. 
##     An ArrayList works great for multiple elements.  If you have only one  
##     argument, you can pass it directly. 
##    
##     [System.Collectionts.ArrayList] $arguments =
##         New-Object System.Collections.ArrayList 
##     [void] $arguments.Add("World") 
##     [void] $arguments.Add(337) 
## 
##  3) Invoke the inline code, optionally retrieving the return value.  You can 
##     set the return value in your inline code by assigning it to the 
##     "returnValue" variable as shown above. 
## 
##     $result = Invoke-Inline $codeToRun $arguments 
## 
## 
##     If your code is simple enough, you can even do this entirely inline: 
## 
##     Invoke-Inline "Console.WriteLine(Math.Pow(337,2));" 
##   
################################################################################ 
param(
    [string] $code, 
    [object] $arg,
    [string[]] $reference = @()
    )

## Stores a cache of generated inline objects.  If this library is dot-sourced 
## from a script, these objects go away when the script exits. 
if(-not (Test-Path Variable:\lee.holmes.inlineCache))
{
    ${GLOBAL:lee.holmes.inlineCache} = @{}
}

## The main function to execute inline C#.   
## Pass the argument to the function as a strongly-typed variable.  They will  
## be available from C# code as the Object variable, "arg". 
## Any values assigned to the "returnValue" object by the C# code will be  
## returned to MSH as a return value. 

function main
{
    ## See if the code has already been compiled and cached 
    $cachedObject = ${lee.holmes.inlineCache}[$code] 

    ## The code has not been compiled or cached 
    if($cachedObject -eq $null)
    { 
        $codeToCompile = 
@"
    using System; 

    public class InlineRunner 
    { 
        public Object Invoke(Object arg) 
        { 
            Object returnValue = null; 

            $code 

            return returnValue; 
        } 
    } 
"@

        ## Obtains an ICodeCompiler from a CodeDomProvider class. 
        $provider = New-Object Microsoft.CSharp.CSharpCodeProvider 

        ## Get the location for System.Management.Automation DLL 
        $dllName = [PsObject].Assembly.Location

        ## Configure the compiler parameters 
        $compilerParameters = New-Object System.CodeDom.Compiler.CompilerParameters 

        $assemblies = @("System.dll", $dllName) 
        $compilerParameters.ReferencedAssemblies.AddRange($assemblies) 
        $compilerParameters.ReferencedAssemblies.AddRange($reference)
        $compilerParameters.IncludeDebugInformation = $true 
        $compilerParameters.GenerateInMemory = $true 

        ## Invokes compilation.  
        $compilerResults =
            $provider.CompileAssemblyFromSource($compilerParameters, $codeToCompile) 

        ## Write any errors if generated.         
        if($compilerResults.Errors.Count -gt 0) 
        { 
            $errorLines = "" 
            foreach($error in $compilerResults.Errors) 
            { 
                $errorLines += "`n`t" + $error.Line + ":`t" + $error.ErrorText 
            } 
            Write-Error $errorLines 
        } 
        ## There were no errors.  Store the resulting object in the object 
        ## cache. 
        else 
        { 
            ${lee.holmes.inlineCache}[$code] = 
                $compilerResults.CompiledAssembly.CreateInstance("InlineRunner") 
        } 

        $cachedObject = ${lee.holmes.inlineCache}[$code] 
   } 

   ## Finally invoke the C# code 
   if($cachedObject -ne $null)
   { 
       return $cachedObject.Invoke($arg) 
   } 
} 

. Main

[Edit: Monad has now been renamed to Windows PowerShell. This script or discussion may require slight adjustments before it applies directly to newer builds.]

The scripting guys continue to impart their magic scripting touch, now with a great big dose of MSH.

Their "Scripting with the Microsoft Shell" Script Center went live recently, and it's already chock-full of sample scripts -- most applying the power of WMI interop.

Their first article covers Accessing WMI From the Microsoft Shell -- check it out!

[Edit: Monad has now been renamed to Windows PowerShell. This script or discussion may require slight adjustments before it applies directly to newer builds.]

The question came up on the newsgroup on how to monitor CPU usage in PowerShell.  I wrote a script to demonstrate this some time ago with the intent to write about it – so now is probably an ideal time.

The following poll-process script retrieves the process name, main window title, processor usage, disk activity, and working set.  It continually refreshes the display to give you a task manager-like experience.

One advantage it offers over Task Manager is the disk activity column.  Since total disk activity is actually measured by several separate perf counters, it uses a heuristic to combine them into a single number.

Now, when you hear something drilling holes in your hard drive, you can find out what it is.

Now that we have our script profiler up and running, we instrument our script a little to mark regions we are concerned about.  You can download that starting script here: [burn-console-1.profiler.msh]   After running the script profiler, we get the performance breakdown:

Breakdown by line:
----------------------------
 15%: Line  123 -             if($colour -lt 20) { $colour -= 1 }
 14%: Line  122 -             if($colour -le 70) { $colour -= 3 }
 11%: Line  124 -             if($colour -lt 0) { $colour = 0 }
 10%: Line  128 -             $tempWorkingBuffer[$baseOffset -
  8%: Line  117 -             $colour /= 4.0
  7%: Line  121 -             if($colour -gt 70) { $colour -= 1 }
  6%: Line  154 -             $nextScreen[$row, $column] = `
  6%: Line  113 -             $colour = $screenBuffer[$baseOffset]
  6%: Line  115 -             $colour += $screenBuffer[$baseOffset + 1]
  6%: Line  116 -             $colour += $screenBuffer[$baseOffset +
  5%: Line  114 -             $colour += $screenBuffer[$baseOffset - 1]
  5%: Line  109 -             $baseOffset = ($windowWidth * $row) +
  0%: Line   90 -         if($random.NextDouble() -ge 0.20)
  0%: Line  152 -         for($column = 0; $column -lt $windowWidth;
  0%: Line   94 -             $screenBuffer[($windowHeight - 2) *

Breakdown by marked regions:
----------------------------
  6%: updateScreen
  0%: startFireLastRow
 93%: propigate
  0%: Unmarked
  0%: main

It looks like we’re spending 93% of our time propagating the fire.  When we investigate how we’re spending the time, none of the hot spots are individually egregious.  Since we’re in such a tight loop, we’re spending most of the time comparing colours.  We can be a little smarter with our ‘if’ statements, attempting to minimize the number of comparisons and variable assignments.  Before optimization, we have 4 checks per loop, and (a weighted average of) just over 1 assignment per loop.  If we write it as below, we reduce that to (a weighted average of) 1 check per loop, and (a weighted average even closer to) 1 assignment per loop.

if($colour -gt 70)
{ 
    $colour -= 1 
}
else
{
    $colour -= 3
    
    if($colour -lt 1)
    { 
        $colour = 0 
    }
    elseif($colour -lt 20)
    { 
        $colour -= 1 
    }
}

This brings us up to 0.57 frames per second.  A great improvement, but we’re obviously not done yet.  We run the profiler again, and see that the hotspots have moved:

Breakdown by line:
----------------------------
 13%: Line  141 -             $tempWorkingBuffer[$baseOffset -
  9%: Line  113 -             $colour = $screenBuffer[$baseOffset]
  9%: Line  117 -             $colour /= 4.0
  9%: Line  115 -             $colour += $screenBuffer[$baseOffset + 1]
  9%: Line  131 -                     $colour = 0
  8%: Line  129 -                 if($colour -lt 1)
  8%: Line  127 -                 $colour -= 3
  7%: Line  121 -             if($colour -gt 70)
  7%: Line  116 -             $colour += $screenBuffer[$baseOffset +
  7%: Line  114 -             $colour += $screenBuffer[$baseOffset - 1]
  5%: Line  109 -             $baseOffset = ($windowWidth * $row) +
  5%: Line  167 -             $nextScreen[$row, $column] = `
  3%: Line  244 -             $bufferCell = `
  1%: Line  240 -             $character =
  0%: Line  252 -             $paletteIndex++
  0%: Line  241 -             $fgColour =
  0%: Line  242 -             $bgColour =
  0%: Line  165 -         for($column = 0; $column -lt $windowWidth;

Breakdown by marked region:
----------------------------
  5%: updateScreen
  0%: startFireLastRow
 90%: propigate
  0%: Unmarked
  5%: main

There’s not too much we can do, but there are a few lines representing access and manipulation of the $colour variable as we compute the average.  So we’ll put those into one line:

$colour = ($screenBuffer[$baseOffset] +
    $screenBuffer[$baseOffset - 1] +
    $screenBuffer[$baseOffset + 1] +
    $screenBuffer[$baseOffset + $windowWidth]) / 4.0

The frame rate barely changes, so let’s see what the new hot spots are:

Breakdown by line:
----------------------------
 19%: Line  140 -             $tempWorkingBuffer[$baseOffset -
 13%: Line  113 -             $colour = ($screenBuffer[$baseOffset] +
 12%: Line  109 -             $baseOffset = ($windowWidth * $row) +
 11%: Line  126 -                 $colour -= 3
 11%: Line  128 -                 if($colour -lt 1)
 11%: Line  120 -             if($colour -gt 70)
 10%: Line  130 -                     $colour = 0
  9%: Line  166 -             $nextScreen[$row, $column] = `
  1%: Line  240 -             $fgColour =
  1%: Line  243 -             $bufferCell = `
  0%: Line  239 -             $character =
  0%: Line  122 -                 $colour -= 1
  0%: Line  251 -             $paletteIndex++
  0%: Line  106 -         for($column = 1; $column -lt ($windowWidth - 1);
  0%: Line  219 -                 if($apparentBrightness -gt

Breakdown by marked region:
----------------------------
  9%: updateScreen
  0%: startFireLastRow
 87%: propigate
  0%: Unmarked
  4%: main

There’s really not much left for us to optimize.  We seem to be spending a lot of time computing the $baseOffset variable, though.  Although we can’t improve the efficiency of the statement, we can execute it less frequently.   Rather than compute it from scratch each time via multiplication, we’ll simply increment it once per column.

We can continue with this iterative refinement, giving an end result of about 0.68 frames per second – 70% faster than when we started.  You can download the optimized version here: [burn-console-2.working.msh].  The problems have now shifted to things we have no control over:

Breakdown by line:
----------------------------
 20%: Line  171 -             $nextScreen[$row, $column] = `
 20%: Line  111 -             $colour = ($screenBuffer[$baseOffset] +
 18%: Line  141 -             $tempWorkingBuffer[$baseOffset -
 17%: Line  144 -             $baseOffset++
 17%: Line  118 -             if($colour -gt 0)
  1%: Line  120 -                 if($colour -gt 70)
  1%: Line  248 -             $bufferCell = `
  1%: Line  126 -                     $colour -= 3
  1%: Line  122 -                     $colour -= 1
  0%: Line  134 -                         $colour -= 1
  0%: Line  128 -                     if($colour -lt 1)
  0%: Line  246 -             $bgColour =
  0%: Line   94 -             $screenBuffer[($windowHeight - 2) *
  0%: Line  130 -                         $colour = 0
  0%: Line  162 -     $nextScreen =

Breakdown by marked region:
----------------------------
 20%: updateScreen
  1%: startFireLastRow
 77%: propigate
  0%: Unmarked
  3%: main

To solve this problem, we’ll delve into a trick from the Demo Scene.  Did you ever use inline assembler in C?  We’ll do something similar, but with inline C# in MSH.

[Edit: Monad has now been renamed to Windows PowerShell. This script or discussion may require slight adjustments before it applies directly to newer builds.]

In the last article, we talked about the theory behind a sampling profiler.  Let’s go over the code to implement one.  We’ll use this to guide our future optimizations.  You can also download the script here: profile-transcript.msh.