Calvin Hsia's WebLog

Create a simple File Watcher to monitor folder changes: Windows Prefetcher

CalvinH — Fri, 30 Nov 2018 02:19:26 GMT

There’s a folder like c:\Windows\Prefetch on your machine, probably with a few hundred files and a few megabytes. If you search the web, you’ll find a few comments about Prefetch (enhanced by SuperFetch and ReadyBoost: https://en.wikipedia.org/wiki/Prefetcher ).
Below is sample code you can run to monitor the activity of this folder. The program shows a window that displays any changes to the folder as they occur. Start a few programs on your computer and you’ll see some action.
The sample code uses the FileSystemWatcher which makes it easy to write such a program.

When your computer starts to run a program, the program and its dependencies need to be loaded into primary memory for execution. The data being read is stored in some sort of slower memory like disk or SSD (see https://blogs.msdn.microsoft.com/calvin_hsia/2012/08/10/performance-of-memory-vs-disk/ )
For example, you start Outlook. The computer then may have to access hundreds or thousands of various pieces of data scattered on the slower memory.
Suppose you start Outlook every day. The prefetcher could have already fetched all that data into faster memory before its needed, so Outlook starts much faster. Similarly, rebooting a system causes lots of programs to load. A prefetcher can fetch the data before its actually required.
Additionally, the prefetched data can be retrieved in an optimum sequence: accounting for data locality can improve fetch times.

If you were working on the Windows team and were given a task to write a Prefetch feature that makes the computer seem faster to most users, how would you approach it? Hmm… a computer is very good at recording information. A folder is a very convenient place to put recorded information. You’d probably need some way to cap the size of the collected data so it doesn’t eat too much user space. You could record all slow memory accesses and how often the program was accessed. When the OS starts a program it could consult the Prefetch data to see if it’s already been “fetched” and thus seem faster to the user.

For example, I start and old and a new app Visual Foxpro and Paint 3D on my Windows 10 machine, and I see
[03:16:42:331],31,Changed VFP9.EXE-F6167E92.pf
[03:16:42:331],32,Changed VFP9.EXE-F6167E92.pf
[03:17:03:769],33,Created PAINTSTUDIO.VIEW.EXE-8DC0D32B.pf
[03:17:03:770],33,Changed PAINTSTUDIO.VIEW.EXE-8DC0D32B.pf

 
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;

/*
File->new->Project->C#->WPF App "PreFetchWatcher"
*/

namespace PrefetchWatcher
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {
        TextBox _txtStatus;
        public string FileFilter { get; set; }
        public bool ShowFileChanges { get; set; } = true;

        public MainWindow()
        {
            InitializeComponent();
            this.Loaded += MainWindow_Loaded;
        }

        private async void MainWindow_Loaded(object sender, RoutedEventArgs ee)
        {
            try
            {
                this.DataContext = this;
                this.Height = 600;
                this.Width = 1000;
                var sp = new StackPanel() { Orientation = Orientation.Vertical };
                var spControls = new StackPanel() { Orientation = Orientation.Horizontal };
                sp.Children.Add(spControls);

                spControls.Children.Add(new Label() { Content = "FileFilter", ToolTip = "if not empty, will filter file change events  (case insensitive)" });
                var txtfileFilter = new TextBox() { Width = 100, Height = 20, VerticalAlignment = VerticalAlignment.Top };
                txtfileFilter.SetBinding(TextBox.TextProperty, nameof(FileFilter));
                spControls.Children.Add(txtfileFilter);


                var chkShowFileChanges = new CheckBox()
                {
                    Content = "ShowFileChanges",
                    Height = 20,
                    VerticalAlignment = VerticalAlignment.Top,
                    Margin = new Thickness(10, 0, 10, 0)
                };
                chkShowFileChanges.SetBinding(CheckBox.IsCheckedProperty, nameof(ShowFileChanges));
                spControls.Children.Add(chkShowFileChanges);


                _txtStatus = new TextBox()
                {
                    IsReadOnly = true,
                    VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
                    HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,
                    IsUndoEnabled = false,
                    FontFamily = new FontFamily("Courier New"),
                    FontSize = 10,
                    Height = 200,
                    MaxHeight = 200,
                    HorizontalContentAlignment = HorizontalAlignment.Left
                };
                sp.Children.Add(_txtStatus);
                this.Content = sp;
                var folderPreFetch = System.IO.Path.Combine(Environment.GetEnvironmentVariable("SystemRoot"), "Prefetch");
                AddStatusMsg($"Started watching {folderPreFetch}");
                await Task.Run(() =>
                {
                    var watcher = new FileSystemWatcher(folderPreFetch);
                    var hndler = new FileSystemEventHandler((o, e) =>
                    {
                        bool showit = true;
                        if (!string.IsNullOrEmpty(FileFilter))
                        {
                            if (e.Name.ToLower().IndexOf(FileFilter.Trim().ToLower()) < 0)
                            {
                                showit = false;
                            }
                        }
                        if (e.ChangeType == WatcherChangeTypes.Changed && !this.ShowFileChanges)
                        {
                            showit = false;
                        }
                        if (showit)
                        {
                            AddStatusMsg($"{e.ChangeType} {e.Name}");
                            //switch (e.ChangeType)
                            //{
                            //    case WatcherChangeTypes.Created:
                            //        break;
                            //    case WatcherChangeTypes.Changed:
                            //        break;
                            //    case WatcherChangeTypes.Deleted:
                            //        break;
                            //    case WatcherChangeTypes.Renamed:
                            //        break;
                            //}
                        }
                    });
                    watcher.Created += hndler;
                    watcher.Deleted += hndler;
                    watcher.Changed += hndler;
                    //watcher.Renamed += hndler;
                    watcher.EnableRaisingEvents = true;
                });

            }
            catch (Exception ex)
            {
                this.Content = ex.ToString();
            }
        }


        void AddStatusMsg(string msg, params object[] args)
        {
            if (_txtStatus != null)
            {
                // we want to read the threadid 
                //and time immediately on current thread
                var dt = string.Format("[{0}],{1,2},",
                    DateTime.Now.ToString("hh:mm:ss:fff"),
                    Thread.CurrentThread.ManagedThreadId);
                _txtStatus.Dispatcher.BeginInvoke(
                    new Action(() =>
                    {
                        // this action executes on main thread
                        var str = string.Format(dt + msg + "\r\n", args);
                        // note: this is a memory leak: can clear periodically
                        _txtStatus.AppendText(str);
                        _txtStatus.ScrollToEnd();
                    }));
            }
        }
    }
}

How to stress and measure the Garbage Collector

CalvinH — Tue, 30 Oct 2018 23:50:46 GMT

Many years ago, I was writing real time applications for monitoring sound signals bouncing off submarines. That code (written in Fortran and PDP-11 assembly code) had to process the incoming sound at the rate of thousands of data points per second, doing real-time Fast Fourier Transforms and analyzing the results, printing graphs. Using a managed language, with unpredictable garbage collection can make this much more problematic. The CLR needs to suspend managed threads for garbage collection, which can cause slowdowns in user code, causing interruptions in the timing, perhaps causing missed data points.
How can one write very little simple code with a huge impact on the .Net garbage collector?
You’d think one way to do this is to consume large amounts of memory. That’s one way, but here’s another:

Thinking about GC, here’s a simple model of how it could work. Imagine every object is a person in a room:

1.    Suspend all threads, so that object references are constant
2.    Tell every person to raise a hand
3.    Define a “GC Root” person: one who cannot be freed. Examples are
    a.    static vars, globals
    b.    Variables on a stack
    c.    Interop wrappers
4.    For each “GC Root”:
    a.    Recursive step:
        i.    Put your hand down (I still need you as non-garbage)
        ii.    Tell each object that you reference (point to) to
            1.    Do the recursive step
5.    Those with their hands still up are “garbage” and can be collected
6.    Optionally compress/consolidate free space in the room by moving objects
    a.    Moving an object changes its objectId, so all references need to be patched too.

So creating an example that takes a while might be to create a long chain of references: A=>B=>C=>D

Here’s some code to generate a long object reference chain.

        class MyLinklist
        {
            public MyLinklist _next;
        }
        MyLinklist _root = null; // static root

                    for (int i = 0; i < nIter; i++)
                    {
                        var x = new MyLinklist
                        {
                            _next = _root
                        };
                        _root = x;
                    }
                    _root = null;

How do I measure the effectiveness of this code on GC? I need some way of determining the performance impact of the code.

I wrote a post https://blogs.msdn.microsoft.com/calvin_hsia/2014/05/29/how-to-monitor-and-respond-to-memory-use/ a few years ago, which showed how to get performance counter numbers.

I combined that with the graphing code in https://blogs.msdn.microsoft.com/calvin_hsia/2017/08/31/graph-poker-hand-distributions/, resulting in the sample code below.

File->new->Project->C#->WPF App "GCStress"
Project->Add Reference to System.Drawing, WindowsFormsIntegration, System.Windows.Forms, System.Windows.Forms.DataVisualizetion
Paste in the code below to replace the code in MainWindow.xaml.cs

The perf counter monitoring code runs and samples the perf counters periodically and updates a moving graph. The GC Stress code can be turned on/off with the button.

When you run the code, it starts monitoring the selected performance counters. Of course, you can use the PerfMon application built into Windows already https://msdn.microsoft.com/en-us/library/aa266946%28v=vs.60%29.aspx?f=255&MSPPError=-2147217396 , but that is quite general purpose and not easily customizable.

Click the Go button to start stressing the GC. From the graphs, the % of time spent in GC is > 60%

You can choose various performance counters to monitor, and you can specify various parameters for the performance graph

Try running the code, and just move the window around, or resize, monitoring how ProcessorPctTime changes.
Try increasing the NumIterations, watching the ProcessorVirtualBytes. Eventually the program will slow down and crash Out of Memory.

 using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Forms.DataVisualization.Charting;
using System.Windows.Forms.Integration;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;

/*
 File->new->Project->C#->WPF App "GCStress"
 Project->Add Reference to System.Drawing, WindowsFormsIntegration, System.Windows.Forms, System.Windows.Forms.DataVisualizetion
*/

namespace GCStress
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {
        TextBox _txtStatus;
        Chart _chart;

        /// 
        /// PerfCounters updated periodically. Safe to change without stopping the monitoring
        /// 
        public int UpdateInterval { get; set; } = 200;
        public int NumIterations { get; set; } = 3000;
        public int NumDataPoints { get; set; } = 100;

        public bool ScaleByteCounters { get; set; } = true;
        public bool SetMaxGraphTo100 { get; set; } = true;

        public PerfCounterType PerfCounterTypesToShow { get; set; } = PerfCounterType.ProcessorPctTime;

        [Flags] // user can select multiple items. (beware scaling: pct => 0-100, Bytes => 0-4G)
        public enum PerfCounterType
        {
            None,
            ProcessorPctTime = 0x1,
            ProcessorPrivateBytes = 0x2,
            ProcessorVirtualBytes = 0x4,
            GCPctTime = 0x8,
            GCBytesInAllHeaps = 0x10,
            GCAllocatedBytesPerSec = 0x20,
        }

        Dictionarystring> _dictPerfCounterDefinitions = new Dictionarystring>
        {
            {PerfCounterType.ProcessorPctTime,"Process|% Processor Time|ID Process" },
            {PerfCounterType.ProcessorPrivateBytes,"Process|Private Bytes|ID Process" },
            {PerfCounterType.ProcessorVirtualBytes,"Process|Virtual Bytes|ID Process" },
            {PerfCounterType.GCPctTime,".NET CLR Memory|% Time in GC|Process ID" },
            {PerfCounterType.GCBytesInAllHeaps,".NET CLR Memory|# Bytes in all Heaps|Process ID" },
            {PerfCounterType.GCAllocatedBytesPerSec,".NET CLR Memory|Allocated Bytes/sec|Process ID" },
        };

        CancellationTokenSource _ctsGCStress;
        CancellationTokenSource _ctsPcounter;
        Task _tskDoPerfMonitoring;
        public MainWindow()
        {
            InitializeComponent();
            this.Loaded += MainWindow_Loaded;
        }

        private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            try
            {
                this.DataContext = this;
                this.Title = "GCStress";
                this.Height = 600;
                this.Width = 1000;
                var sp = new StackPanel() { Orientation = Orientation.Vertical };
                var spControls = new StackPanel() { Orientation = Orientation.Horizontal };
                sp.Children.Add(spControls);

                spControls.Children.Add(new Label() { Content = "Update Interval", ToolTip = "MilliSeconds" });
                var txtUpdateInterval = new TextBox() { Width = 50, Height = 20, VerticalAlignment = VerticalAlignment.Top };
                txtUpdateInterval.SetBinding(TextBox.TextProperty, nameof(UpdateInterval));
                spControls.Children.Add(txtUpdateInterval);

                var lbPCounters = new ListBox()
                {
                    Width = 150,
                    SelectionMode = SelectionMode.Multiple,
                    Margin = new Thickness(10, 0, 0, 0)
                };
                lbPCounters.ItemsSource = ((PerfCounterType[])Enum.GetValues(typeof(PerfCounterType))).Skip(1); // skip the "None"
                lbPCounters.SelectedIndex = 0;
                lbPCounters.SelectionChanged += async (ol, el) =>
                {
                    lbPCounters.IsEnabled = false;
                    AddStatusMsg($"Setting counters to {this.PerfCounterTypesToShow.ToString()}");
                    // cancel the perf monitoring
                    _ctsPcounter?.Cancel();
                    // before we wait for cancel to finish we can do some work
                    PerfCounterType pcEnum = PerfCounterType.None;
                    foreach (var itm in lbPCounters.SelectedItems)
                    {
                        pcEnum |= (PerfCounterType)Enum.Parse(typeof(PerfCounterType), itm.ToString());
                    }
                    // wait for it to be done cancelling
                    if (_tskDoPerfMonitoring != null)
                    {
                        await _tskDoPerfMonitoring;
                    }
                    await Task.Run(() =>
                    {
                        // run on threadpool thread
                        lock (_lstPerfCounterData)
                        {
                            this.PerfCounterTypesToShow = pcEnum;
                            ResetPerfCounterMonitor();
                        }
                    });
                    AddStatusMsg($"SelectionChanged done");
                    lbPCounters.IsEnabled = true;
                };
                spControls.Children.Add(lbPCounters);

                var chkSetMaxGraphTo100 = new CheckBox()
                {
                    Content = "SetMaxGraphTo100",
                    ToolTip = "Set Max Y axis to 100. Else will dynamically rescale Y axis",
                    Height = 20,
                    VerticalAlignment = VerticalAlignment.Top,
                    Margin = new Thickness(10, 0, 10, 0)
                };
                chkSetMaxGraphTo100.SetBinding(CheckBox.IsCheckedProperty, nameof(SetMaxGraphTo100));
                spControls.Children.Add(chkSetMaxGraphTo100);

                var chkScaleByteCtrs = new CheckBox()
                {
                    Content = "Scale 'Byte' counters",
                    ToolTip = "for Byte counters, scale to be a percent of 4Gigs",
                    Height = 20,
                    VerticalAlignment = VerticalAlignment.Top
                };
                chkScaleByteCtrs.SetBinding(CheckBox.IsCheckedProperty, nameof(ScaleByteCounters));
                spControls.Children.Add(chkScaleByteCtrs);

                spControls.Children.Add(new Label()
                {
                    Content = "NumDataPoints",
                    ToolTip = "Number of Data points (x axis). Will change on next Reset"
                });
                var txtNumDataPoints = new TextBox() { Width = 50, Height = 20, VerticalAlignment = VerticalAlignment.Top };
                txtNumDataPoints.SetBinding(TextBox.TextProperty, nameof(NumDataPoints));
                spControls.Children.Add(txtNumDataPoints);

                spControls.Children.Add(new Label()
                {
                    Content = "NumIterations",
                    ToolTip = "Number of linklist items (will be multiplied by 1000)"
                });
                var txtNumIter = new TextBox() { Width = 50, Height = 20, VerticalAlignment = VerticalAlignment.Top };
                txtNumIter.SetBinding(TextBox.TextProperty, nameof(NumIterations));
                spControls.Children.Add(txtNumIter);

                var btnGo = new Button()
                {
                    Content = "_Go",
                    ToolTip = "Stress GC",
                    Width = 30,
                    Height = 20,
                    VerticalAlignment = VerticalAlignment.Top
                };
                spControls.Children.Add(btnGo);

                _chart = new Chart()
                {
                    Width = 200,
                    Height = 100,
                    Dock = System.Windows.Forms.DockStyle.Fill
                };
                var wfh = new WindowsFormsHost()
                {
                    Child = _chart
                };
                sp.Children.Add(wfh);
                _txtStatus = new TextBox()
                {
                    IsReadOnly = true,
                    VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
                    HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,
                    IsUndoEnabled = false,
                    FontFamily = new FontFamily("Courier New"),
                    FontSize = 10,
                    Height = 200,
                    MaxHeight = 200,
                    HorizontalContentAlignment = HorizontalAlignment.Left
                };
                sp.Children.Add(_txtStatus);
                this.Content = sp;

                var isGoing = false;
                btnGo.Click += async (ob, eb) =>
                {
                    isGoing = !isGoing;
                    if (isGoing)
                    {
                        btnGo.Content = "_Stop";
                        AddStatusMsg("Starting");
                        _ctsGCStress = new CancellationTokenSource();
                        await DoGCStressAsync();
                        // when the task finishes, then we're stopping
                        isGoing = false;
                    }
                    AddStatusMsg("Stopping");
                    _ctsGCStress.Cancel();
                    btnGo.Content = "_Go";
                };
                await Task.Run(() =>
                {
                    ResetPerfCounterMonitor();
                });

                //        btnGo.RaiseEvent(new RoutedEventArgs(Button.ClickEvent, this));
            }
            catch (Exception ex)
            {
                this.Content = ex.ToString();
            }
        }

        class MyLinklist
        {
            public MyLinklist _next;
            //public int[] _array;
            //public MyLinklist()
            //{
            //    _array = new int[100];
            //}
        }
        MyLinklist _root = null; // static root

        private async Task DoGCStressAsync()
        {
            await Task.Run(() =>
            {
                AddStatusMsg($"starting {nameof(DoGCStressAsync)}");
                try
                {
                    while (!_ctsGCStress.Token.IsCancellationRequested)
                    {
                        int nIter = 1000 * NumIterations;
                        for (int i = 0; i < nIter; i++)
                        {
                            var x = new MyLinklist
                            {
                                _next = _root
                            };
                            _root = x;
                        }
                        _root = null;
                    }
                }
                catch (OutOfMemoryException ex)
                {
                    _root = null;
                    AddStatusMsg($"{nameof(DoGCStressAsync)} {ex.ToString()}");
                }
                AddStatusMsg($"cancelling {nameof(DoGCStressAsync)}");
            });
        }


        // list of current set of perfcounters we're monitoring
        List _lstPerfCounterData = new List();

        // use a circular buffer to store samples. 
        // dictionary of sample # (int from 0 to NumDataPoints) =>( List (PerfCtrValues in order)
        public Dictionary<int, List<uint>> _dataPoints = new Dictionary<int, List<uint>>();
        int _bufferIndex = 0;
        public class PerfCounterData
        {
            public PerfCounterType pcntrType;
            public PerformanceCounter performanceCounter;
            public PerfCounterData(PerfCounterType pcntrType, PerformanceCounter performanceCounter)
            {
                this.pcntrType = pcntrType;
                this.performanceCounter = performanceCounter;
            }
        }
        void ResetPerfCounterMonitor()
        {
            var pid = Process.GetCurrentProcess().Id;
            lock (_lstPerfCounterData)
            {
                AddStatusMsg($"{nameof(ResetPerfCounterMonitor)} {PerfCounterTypesToShow.ToString()} ");
                _lstPerfCounterData.Clear();
                _dataPoints.Clear();
                _bufferIndex = 0;
                foreach (PerfCounterType pcntrType in Enum.GetValues(typeof(PerfCounterType)))
                {
                    if (pcntrType != PerfCounterType.None)
                    {
                        if (PerfCounterTypesToShow.HasFlag(pcntrType))
                        {
                            var pcounter = GetPerfCounter(pcntrType, pid);
                            var pcntrData = new PerfCounterData(pcntrType, pcounter);
                            _lstPerfCounterData.Add(pcntrData);
                        }
                    }
                }

                for (int i = 0; i < NumDataPoints; i++)
                {
                    var emptyList = new List<uint>();
                    _lstPerfCounterData.ForEach((s) => emptyList.Add(0));
                    _dataPoints[i] = emptyList;
                }
            }
            DoPerfCounterMonitoring();
        }
        void AddDataPoints(List<uint> lstNewestSample)
        {
            _dataPoints[_bufferIndex++] = lstNewestSample;
            if (_bufferIndex == _dataPoints.Count)
            {
                _bufferIndex = 0;
            }
            var task = this.Dispatcher.BeginInvoke(
                new Action(() =>
                {
                    // this needs to be done on UI thread
                    _chart.Series.Clear();
                    _chart.ChartAreas.Clear();
                    var chartArea = new ChartArea("ChartArea");
                    _chart.ChartAreas.Add(chartArea);
                    int ndxSeries = 0;
                    foreach (var entry in lstNewestSample)
                    {
                        var series = new Series
                        {
                            ChartType = SeriesChartType.Line
                        };
                        _chart.Series.Add(series);
                        for (int i = 0; i < _dataPoints.Count; i++)
                        {
                            var ndx = _bufferIndex + i;
                            if (ndx >= _dataPoints.Count)
                            {
                                ndx -= _dataPoints.Count;
                            }
                            var dp = new DataPoint(i + 1, _dataPoints[ndx][ndxSeries]);
                            series.Points.Add(dp);
                        }
                        ndxSeries++;
                        if (SetMaxGraphTo100)
                        {
                            _chart.ChartAreas[0].AxisY.Maximum = 100;
                        }
                    }
                    _chart.DataBind();
                }));
        }


        void DoPerfCounterMonitoring()
        {
            _ctsPcounter = new CancellationTokenSource();
            _tskDoPerfMonitoring = Task.Run(async () =>
            {
                try
                {
                    while (!_ctsPcounter.Token.IsCancellationRequested)
                    {
                        var sBuilder = new StringBuilder();
                        var lstPCData = new List<uint>();
                        lock (_lstPerfCounterData)
                        {
                            foreach (var ctr in _lstPerfCounterData)
                            {
                                var pcntr = ctr.performanceCounter;
                                var pcValueAsFloat = pcntr.NextValue();
                                uint pcValue = 0;
                                if (ctr.pcntrType.ToString().Contains("Bytes") && !ctr.pcntrType.ToString().Contains("PerSec") && this.ScaleByteCounters)
                                {
                                    pcValue = (uint)(pcValueAsFloat * 100 / uint.MaxValue); // '% of 4G
                                }
                                else
                                {
                                    pcValue = (uint)pcValueAsFloat;
                                }
                                sBuilder.Append($"{pcntr.CounterName}={pcValue:n0}  ");
                                lstPCData.Add(pcValue);
                            }
                            AddDataPoints(lstPCData);
                        }
                        AddStatusMsg($"Sampling {sBuilder.ToString()}");
                        await Task.Delay(UpdateInterval, _ctsPcounter.Token);
                    }
                }
                catch (TaskCanceledException)
                {
                }
                AddStatusMsg($"cancelling {nameof(DoPerfCounterMonitoring)}");
            });
        }

        public PerformanceCounter GetPerfCounter(PerfCounterType pcntr, int vspid)
        {
            var strvalues = _dictPerfCounterDefinitions[pcntr].Split("|".ToCharArray());
            var perfcountCat = strvalues[0];
            var perfcountName = strvalues[1];
            var pidstr = strvalues[2];
            PerformanceCounter pc = null;
            var category = new PerformanceCounterCategory(perfcountCat);

            foreach (var instanceName in category.GetInstanceNames()) // exception if you're not admin or "Performance Monitor Users" group (must re-login)
            {
                using (var cntr = new PerformanceCounter(category.CategoryName, pidstr, instanceName, readOnly: true))
                {
                    try
                    {
                        var val = (int)cntr.NextValue();
                        if (val == vspid)
                        {
                            pc = new PerformanceCounter(perfcountCat, perfcountName, instanceName);
                            break;
                        }
                    }
                    catch (Exception)
                    {
                        // System.InvalidOperationException: Instance 'IntelliTrace' does not exist in the specified Category.
                    }
                }
            }
            return pc;
        }

        void AddStatusMsg(string msg, params object[] args)
        {
            if (_txtStatus != null)
            {
                // we want to read the threadid 
                //and time immediately on current thread
                var dt = string.Format("[{0}],{1,2},",
                    DateTime.Now.ToString("hh:mm:ss:fff"),
                    Thread.CurrentThread.ManagedThreadId);
                _txtStatus.Dispatcher.BeginInvoke(
                    new Action(() =>
                    {
                        // this action executes on main thread
                        var str = string.Format(dt + msg + "\r\n", args);
                        // note: this is a memory leak: can clear periodically
                        _txtStatus.AppendText(str);
                        _txtStatus.ScrollToEnd();
                    }));
            }
        }
    }
}

Using Async with ManualResetEventSlim

CalvinH — Sat, 29 Sep 2018 01:06:35 GMT

When I first started writing programs many years ago, my computer had only one processor and no notion of thread, because there was only one. Understanding code for it just meant following one “thread” of execution.

I was trying to create a way to queue items to work on in a different thread than the UI thread. I wanted the client thread to be very fast, allowing the expensive processing to be done in the background.
It’s easy to create your own dedicated thread, and ThreadPool threads are quite handy.
I have some old code that would do this by adding items to a queue and then set a ManualResetEventSlim to Signaled. A background thread waits for this event, and upon signaling, would go to work on the items in the queue.
However, this pattern consumes a dedicated or ThreadPool Thread to process the incoming events. That particular application was an automatically run test app, so nobody complained about its performance.

This can easily be shown by looking at the call stack in the debugger:
Using WatiHandle.WaitOne, or similar waits on a thread pool thread causes that thread to be busy waiting and thus consuming one ThreadPool Thread as seen in the debugger.
Here, even when using await, the background task says WaitOne, causing the entire thread to block:

var x = new ManualResetEventSlim();
await Task.Run(() => x.WaitHandle.WaitOne());

mscorlib.dll!System.Threading.WaitHandle.InternalWaitOne(System.Runtime.InteropServices.SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext)    Unknown
mscorlib.dll!System.Threading.WaitHandle.WaitOne(int millisecondsTimeout, bool exitContext)    Unknown
mscorlib.dll!System.Threading.WaitHandle.WaitOne()    Unknown
QueueTest.exe!QueueTest.MainWindow.MainWindow_Loaded.AnonymousMethod__5() Line 89    C#
mscorlib.dll!System.Threading.Tasks.Task.InnerInvoke()    Unknown
mscorlib.dll!System.Threading.Tasks.Task.Execute()    Unknown
mscorlib.dll!System.Threading.Tasks.Task.ExecutionContextCallback(object obj)    Unknown
mscorlib.dll!System.Threading.ExecutionContext.RunInternal(System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, object state, bool preserveSyncCtx)    Unknown
mscorlib.dll!System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, object state, bool preserveSyncCtx)    Unknown
mscorlib.dll!System.Threading.Tasks.Task.ExecuteWithThreadLocal(ref System.Threading.Tasks.Task currentTaskSlot)    Unknown
mscorlib.dll!System.Threading.Tasks.Task.ExecuteEntry(bool bPreventDoubleExecution)    Unknown
mscorlib.dll!System.Threading.Tasks.Task.System.Threading.IThreadPoolWorkItem.ExecuteWorkItem()    Unknown
mscorlib.dll!System.Threading.ThreadPoolWorkQueue.Dispatch()    Unknown
mscorlib.dll!System.Threading._ThreadPoolWaitCallback.PerformWaitCallback()    Unknown

Consuming a thread includes the entire thread stack (1 Meg by default). Each time a thread is created, every DLL in the process (that doesn’t call DisableThreadLibraryCalls) will have its DLLMain called, which means a lot of processing just to initialize a thread.
A glance at Task Manager or Process Explorer shows many applications with dozens of threads, include Microsoft Edge and Visual Studio.

The number of simultaneous threads that can run at a time is limited to the number of logical processors. All the other threads are dormant. There are perhaps thousands of thread switches at any time on a machine, swapping one thread for another.

Using async and await without the WaitOne() and the ilk, a thread can be freed to do other work.

Threads should be thought of as a shared resource. Using one dedicated to a particular task can be inefficient.

Below is a sample using AyncManualResetEvent, which does not consume any dedicated threads for background processing.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
 
namespace QueueTest
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            this.Loaded += MainWindow_Loaded;
        }
        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            try
            {
                var dp = new DockPanel();
                this.Content = dp;
                var spControls = new StackPanel()
                {
                    Orientation = Orientation.Vertical
                };
                dp.Children.Add(spControls);
                var btnGo = new Button()
                {
                    Content = "_Go",
                    HorizontalAlignment = HorizontalAlignment.Left,
                    Width = 100
                };
                spControls.Children.Add(btnGo);
 
                var txtStatus = new TextBox()
                {
                    Margin = new Thickness(10, 0, 0, 0),
                    IsReadOnly = true,
                    //                    Width = 900,
                    //Height = 100,
                    MaxHeight = 800,
                    VerticalScrollBarVisibility = ScrollBarVisibility.Auto
                };
                Action<string> addStatusMsg = (str) =>
                {
                    str = DateTime.Now.ToString("hh:mm:ss.fff") + $" tid= {Thread.CurrentThread.ManagedThreadId} {str}";
                    Dispatcher.BeginInvoke(new Action(
                        () =>
                        {
                            txtStatus.AppendText($"{str}\r\n");
                            txtStatus.ScrollToEnd();
                        }
                        ));
                };
                dp.LastChildFill = true;
                dp.Children.Add(txtStatus);
                addStatusMsg("We have 2 queues: one for normal telemetry and one for notification service");
                var queueNotifications = new ConcurrentQueue<string>();
                CancellationTokenSource tks = null;
                bool fIsRunning = false;
                int itemToQueue = 0;
                var evntNewItemAvailable = new AsyncManualResetEvent();
 
                btnGo.Click += (ob, eb) =>
                {
                    if (!fIsRunning)
                    {
                        tks = new CancellationTokenSource();
                        Task.Run(async () =>
                        {
                            while (!tks.Token.IsCancellationRequested)
                            {
                                addStatusMsg($"awaiting notification");
                                await evntNewItemAvailable.WaitAsync();
                                while (queueNotifications.Count() > 0)
                                {
                                    if (queueNotifications.TryDequeue(out var result))
                                    {
                                        addStatusMsg($"notification processed {result} ");
                                    }
                                }
                                evntNewItemAvailable.Reset();
                            }
                            addStatusMsg("end task notification");
                        });
                        Task.Run(async () =>
                        {
                            // simulate incoming notifications by putting them into the queue periodically
                            while (!tks.Token.IsCancellationRequested)
                            {
                                await Task.Delay(TimeSpan.FromMilliseconds(1), tks.Token);
                                if (!tks.IsCancellationRequested)
                                {
                                    var newitem = ++itemToQueue;
                                    addStatusMsg($"Queuing new notification {newitem}");
                                    // we add the item to 2 queues
                                    queueNotifications.Enqueue(newitem.ToString());
                                    evntNewItemAvailable.Set();
                                }
                            }
                        });
                    }
                    else
                    {
                        evntNewItemAvailable.Set();
                        tks.Cancel();
                        addStatusMsg("Canceling");
                    }
                    fIsRunning = !fIsRunning;
 
                };
            }
            catch (Exception ex)
            {
                this.Content = ex.ToString();
            }
        }
    }
    // https://blogs.msdn.microsoft.com/pfxteam/2012/02/11/building-async-coordination-primitives-part-1-asyncmanualresetevent/
    internal class AsyncManualResetEvent
    {
        private volatile TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
 
        public Task WaitAsync() => this.tcs.Task;
 
        public void Set()
        {
            // https://stackoverflow.com/questions/12693046/configuring-the-continuation-behaviour-of-a-taskcompletionsources-task
            Task.Run(() =>
            this.tcs.TrySetResult(true));
        }
 
        public void Reset()
        {
            while (true)
            {
                var tcs = this.tcs;
                if (!tcs.Task.IsCompleted ||
                    Interlocked.CompareExchange(ref this.tcs, new TaskCompletionSource<bool>(), tcs) == tcs)
                {
                    return;
                }
            }
        }
    }
}

Use reflection to get assembly type and method sizes for comparison

CalvinH — Fri, 31 Aug 2018 00:06:04 GMT

I wanted to know what changed between two versions of a managed assembly. Software changes over time, and seeing what changed can be important in understanding behavior.
So I wrote a little program to show the assembly contents, sorted by size, showing the size of various components such as classes and methods.

Because it doesn’t look at things like static members, manifests, etc. It’s not complete, and left as an exercise to the reader.

Note how it calculates each node’s cost by summing it’s children, then uses the size as a sort description.

 using System;
using System.Reflection;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Runtime.InteropServices;
using System.Diagnostics;
 
// Start Visual Studio, File->New->Project->C#, WPF Application. call it "MgdCodeSize"
// Replace MainWindow.xaml.cs wtih this content
 
namespace MgdCodeSize
{
	/// <summary>
	/// Interaction logic for MainWindow.xaml
	/// summary>
	public partial class MainWindow : Window
	{
		public MainWindow()
		{
			InitializeComponent();
			this.Loaded += MainWindow_Loaded;
			this.WindowState = WindowState.Maximized;
		}
 
		public class MyTreeViewItem : TreeViewItem
		{
			public int size { get; set; }
			string _name;
			public MyTreeViewItem(string name)
			{
				this._name = name;
			}
			public void CalcHeader(bool expand = true)
			{
				foreach (MyTreeViewItem child in this.Items)
				{
					this.size += child.size;
				}
				var sp = new StackPanel()
				{
					Orientation = Orientation.Horizontal
				};
				sp.Children.Add(new TextBox()
				{
					Text = size.ToString()
				});
				sp.Children.Add(new TextBox()
				{
					Text = _name
				});
				this.Header = sp;
				this.Items.SortDescriptions.Add(new System.ComponentModel.SortDescription("size", System.ComponentModel.ListSortDirection.Descending));
				if (expand)
				{
					this.IsExpanded = true;
				}
			}
			public override string ToString()
			{
				return $"{this.size} {this._name}";
			}
		}
		private void MainWindow_Loaded(object sender, RoutedEventArgs e)
		{
			try
			{
				var filename = @"C:\Program Files (x86)\Microsoft Visual Studio\Preview\Enterprise\Common7\IDE\EntityFramework.dll";
				var asm = Assembly.LoadFrom(filename);
				var tv = new TreeView();
				this.Content = tv;
				var tvFileNode = new MyTreeViewItem(filename);
				tv.Items.Add(tvFileNode);
				foreach (var module in asm.Modules)
				{
					var tvModuleNode = new MyTreeViewItem(module.Name);
					tvFileNode.Items.Add(tvModuleNode);
 
					foreach (var type in module.GetTypes())
					{
						var tvTypeNode = new MyTreeViewItem(type.Name);
						tvModuleNode.Items.Add(tvTypeNode);
						var methods = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
						foreach (var method in methods)
						{
							var methodBody = method.GetMethodBody();
							var bytes = methodBody?.GetILAsByteArray();
							var tvMethodNode = new MyTreeViewItem(method.Name);
							if (bytes != null)
							{
								var numbytes = bytes.Length;
								tvMethodNode.size = numbytes;
								tvTypeNode.Items.Add(tvMethodNode);
							}
							tvMethodNode.CalcHeader(expand: false);
						}
						tvTypeNode.CalcHeader(expand: false);
					}
					tvModuleNode.CalcHeader();
				}
				tvFileNode.CalcHeader();
 
			}
			catch (Exception ex)
			{
				this.Content = ex.ToString();
			}
		}
	}
}

Detouring code

CalvinH — Thu, 26 Jul 2018 22:49:13 GMT

Microsoft Detours from Microsoft Research is a powerful technology to intercept operating system function calls and detour the call to your own code. This enables:
1.    Diagnostics: you can log callers, parameters
2.    Replace functionality completely: the caller calls the WinAPI “MessageBox”, but it calls your version instead.
3.    Modify functionality: perhaps change some parameters to the call to change behavior.

The source code for Detours is https://github.com/Microsoft/Detours
Sample code below shows a window with a Button to invoke MessageBox, and a checkbox to toggle Detouring to a private implementation of MessageBox:
Start Visual Studio
File->New->Project->C++ Desktop Application. Call it "DetourSample"
Replace the entire DetourSample.cpp with this code.

Set a breakpoint on the call to MessageBoxA. Hit F5 to build and run, and don’t click the Detour Checkbox yet.
Click on the MessageBox button to reach the breakpoint.
Then hit Ctrl-F11 (Show Disassembly) to see the disassembly of the code in a few columns: First the address, then the machine code bytes (you may need to right-click->Show Code Bytes), then the Assembly code instructions and lastly the operands.

Notice that there are 4 push instructions, corresponding to the 4 parameters of MessageBoxA, in right to left order. Then comes the call to __imp__MessageBoxA@16
You can single step the assembly code and watch how the registers change values (Debug->Windows->Registers) (You may have to disable Tools->Options->Debugging->General->Just My Code)

                                  MessageBoxA(_hWnd, "Some Text", g_szArch, MB_OK);
013B9710 8B F4                mov         esi,esp
013B9712 6A 00                push        0
013B9714 68 44 D0 3C 01       push        offset g_szArch (013CD044h)
013B9719 68 60 A1 3C 01       push        offset string "Some Text" (013CA160h)
013B971E 8B 45 08             mov         eax,dword ptr [this]
013B9721 8B 88 94 01 00 00    mov         ecx,dword ptr [eax+194h]
013B9727 51                   push        ecx
013B9728 FF 15 68 E1 3C 01    call        dword ptr [__imp__MessageBoxA@16 (013CE168h)]

Notice how the address of __imp_MessageBoxA@16 is 013CE168, and that the code bytes for that instruction are “FF 15” + “68 E1 3C 01” and the 2nd part is the address in Little Endian order (68 E1 3C 01 == 013CE168).
Debug->Windows->view->Memory 1 to show the memory window, then drag the “0x013CE168” to the Address of the window (you’ll need to right-click on the Memory Window and show as 4-byte integer)
This shows a portion of the import address table and the content of 013CE168 is 75b58830

Debug->Windows->Modules, and look for User32.dll. It shows the Address as 75AD0000-75C2F000, which includes our 75b58830,which is the entry point to User32!MessageBoxA

Another way to see this: from a Command prompt, run this to create a VS Developer prompt (adjust the path to your install path):
“C:\Program Files (x86)\Microsoft Visual Studio\Preview\Enterprise\vc\Auxiliary\Build\vcvars32.bat”
Then type: link /dump /exports c:\windows\SysWow64\user32.dll | find “MessageBoxA”
This shows the user32.dll export of MessageBoxA , and the relative address. The last few hex digits of the result are “8830”
(Note: due to Windows Updates and different versions of windows, your numbers will probably be different from mine.)

When you step into the MessageBoxA function, you see the entire MessageBoxA function from User32.dll (it’s small because it just re-pushes the parameters and forwards to another function (notice the addition of a new parameter, 0)
Extra points if you can name that function

75B58830 8B FF                mov         edi,edi
75B58832 55                   push        ebp
75B58833 8B EC                mov         ebp,esp
75B58835 6A 00                push        0
75B58837 FF 75 14             push        dword ptr [ebp+14h]
75B5883A FF 75 10             push        dword ptr [ebp+10h]
75B5883D FF 75 0C             push        dword ptr [ebp+0Ch]
75B58840 FF 75 08             push        dword ptr [ebp+8]
75B58843 E8 18 00 00 00       call        75B58860
75B58848 5D                   pop         ebp
75B58849 C2 10 00             ret         10h

For detours to work, the beginning of the MessageBoxA function must be replaced with a jmp instruction to the detoured function.
We can’t just replace instructions and expect the function to continue working: we need to still execute the replaced instructions. Where do we put them? User32.dll is laid out in memory exactly, and we can’t just squeeze in a few bytes. So we need to allocate some memory.

Click the Detour checkbox, then do the MessageBox again. The import address table hasn’t changed, so we still go to 75b58830:

75B58830 E9 43 88 85 8B       jmp         MyMessageBoxA (013B1078h)
75B58835 6A 00                push        0
75B58837 FF 75 14             push        dword ptr [ebp+14h]
75B5883A FF 75 10             push        dword ptr [ebp+10h]
75B5883D FF 75 0C             push        dword ptr [ebp+0Ch]
75B58840 FF 75 08             push        dword ptr [ebp+8]
75B58843 E8 18 00 00 00       call        75B58860
75B58848 5D                   pop         ebp
75B58849 C2 10 00             ret         10h

Notice that there are 5 new bytes: a Long jmp instruction to the detoured version of MessageBoxA called MyMessageBoxA. The rest of the function is unchanged.
Those 5 new bytes replaced the first 3 original instructions:
75B58830 8B FF                mov         edi,edi
75B58832 55                   push        ebp
75B58833 8B EC                mov         ebp,esp

The detoured version does its thing, then calls the real version via g_real_MessageBoxA, which now points to the memory allocated for the detour, which contains this:

And at the 6DB400D8 address we find the instructions that were replaced, plus a long jmp back to where we left off at 75B58835: (which is the instruction right after the detour jump)

6DB400D8 8B FF                mov         edi,edi
6DB400DA 55                   push        ebp
6DB400DB 8B EC                mov         ebp,esp
6DB400DD E9 53 87 01 08       jmp         75B58835

So now we see why it’s called a detour: we took a side trip and came back to where we’re supposed to be.
Of course the detoured function can do all sorts of things, like:
1.    Change the parameters or return value before or after the call
2.    Not call the original function at all (could cause a crash)
3.    Record information about the function call.

Possible Problems:
1.    Suppose you’re in the middle of replacing the 5 bytes of a function, when another thread tries to execute that function when only 4 bytes have been replaced? It goes off into random memory somewhere and crashes. You could suspend threads and then patch the thread stacks for each detour. (VS used to do this)
2.    If the API you want to detour isn’t loaded in memory yet, it can still be detoured. You can detour any function for which you know the function signature and address. You can get the address via calling LoadLibrary, GetProcAddress. Even if you don’t know the signature, if you know the parameter sizes, and calling convention, you can detour the function successfully.
3.    Suppose you want to detour from various component DLLs in a single app. Each detour will allocate its own memory to store the detours. Because each memory region needs to have certain rights, each region is allocated via VirtualAlloc, which uses a minimum 64k for a 32 bit process. That means if 3 DLLs are detouring, that’s using 3 * 64K = 192K Virtual Address space. Visual Studio used to do this.

Possible Expansions:
1.    Put your detour code into a DLL, then inject that DLL into another process. MemSpect does this.
2.    Have your detoured functions collect information and communicate that data to another process so you can “spy” on the target process. MemSpect does this.
3.    Combine detours with CLR Profiler APIs. Guess what? MemSpect does this too.

 // DetourSample.cpp : Defines the entry point for the application.
//
 
#include "stdafx.h"
#include "DetourSample.h"
#include 
/*
Start Visual Studio
File->New->Project->C++ Desktop Application. Call it "DetourSample"
Replace the entire DetourSample.cpp with this code.
 
From https://github.com/Microsoft/Detours copy 4 files: detours.h, detours.cpp, disasm.cpp, Modules.cpp next to this file
Include the 3 .cpp files in the project (Solution Explorer->Show all files->Right click->Include in Project)
Need to turn off precompiled headers for all configurations (both debug/release, 32 bit, 64 bit). Project->Properties->Configuration->C/C++->PrecompiledHeaders->Not using PrecompiledHeaders
Many C++ projects consist of lots of C++ files, which have many #include at the top. Each #include file needs to be expanded and compiled for each C++ file.
The PrecompiledHeaders option specifies an included file name like "windows.h". Every C++ file is assumed to be identical up to the line that includes "windows.h"
This allows that identical part to be precompiled into a .pch file on disk, which is only needed to be done once for all the C++ files.
Works in 64 bit and 32 bit: Build->Configuration->Active Solution Platform->x86 or x64
 
 
*/
#ifdef _WIN64
char g_szArch[] = "x64 64 bit";
#define _X86_
#else
char g_szArch[] = "x86 32 bit";
#endif
#include "detours.h"
 
using namespace std;
 
#define MAX_LOADSTRING 100
 
class CMyApplication;
CMyApplication * g_CMyApplication;
 
// Forward declarations of functions included in this code module:
LRESULT CALLBACK WindowProcedure(HWND, UINT, WPARAM, LPARAM);
 
/*
Many windows API functions that require a string parameter have 2 versions: an A (for ANSI) and W (for Wide Unicode) strings.
For example, MessageBoxA and MessageBoxW.
If you just call MessageBox, the relevant header (WinUser.h) contains:
#ifdef UNICODE
#define MessageBox  MessageBoxW
#else
#define MessageBox  MessageBoxA
#endif // !UNICODE
 
Detouring the W version might detour both the W and the A version because the A version might just convert to W and call the W version.
That's not true with MessageBoxA and MessageBoxW. MessageBoxA on Win10 converts to unicode and then calls (undocumented) MessageBoxTimeOutW
We can look at the exports of user32.dll from a VS command prompt:
C:\>link /dump /exports \Windows\System32\user32.dll | find /i "messagebo"
2149  282 0006F000 MessageBoxA
2150  283 0006F060 MessageBoxExA
2151  284 0006F090 MessageBoxExW
2152  285 0006F0C0 MessageBoxIndirectA
2153  286 0006F260 MessageBoxIndirectW
2154  287 0006F320 MessageBoxTimeoutA
2155  288 0006F470 MessageBoxTimeoutW
2156  289 0006F640 MessageBoxW
2408  387 0006F6A0 SoftModalMessageBox
*/
 
 
// decltype is like typeof()
// initialize a pointer to the real version of the API
decltype(&MessageBoxA) g_real_MessageBoxA = &MessageBoxA;
decltype(&MessageBoxW) g_real_MessageBoxW = &MessageBoxW;
 
// here is my implementation that will be called when detoured.
int WINAPI MyMessageBoxA(
	_In_opt_ HWND hWnd,
	_In_opt_ LPCSTR lpText,
	_In_opt_ LPCSTR lpCaption,
	_In_ UINT uType)
{
	string caption(lpCaption);
	caption += " The detoured version of MessageboxA";
	string text(lpText);
	text += " hi from detoured version";
	// we now call the real implementation of MessageBox.
	// (we could log various things about detoured API calls, such as
	//   the callstack and the return value)
	return g_real_MessageBoxA(hWnd, text.c_str(), caption.c_str(), uType);
}
 
int WINAPI MyMessageBoxW(
	_In_opt_ HWND hWnd,
	_In_opt_ LPCWSTR lpText,
	_In_opt_ LPCWSTR lpCaption,
	_In_ UINT uType)
{
	wstring caption(lpCaption);
	caption += L" The unicode detoured version of MessageboxA";
	wstring text(lpText);
	text += L" hi from unicode detoured version";
	return g_real_MessageBoxW(hWnd, text.c_str(), caption.c_str(), uType);
}
 
 
class CMyApplication
{
	WCHAR _szTitle[MAX_LOADSTRING];                  // The title bar text
	WCHAR _szWindowClass[MAX_LOADSTRING];            // the main window class name
	HINSTANCE _hInstance;                                // current instance
	HWND _hWnd;
	HWND _hwndBtnMsgBox;
	HWND _hwndChkDetour;
	POINTS _size;
public:
	CMyApplication(HINSTANCE hInstance)
	{
		_hInstance = hInstance;
		// Initialize global strings
		LoadStringW(_hInstance, IDS_APP_TITLE, _szTitle, MAX_LOADSTRING);
		LoadStringW(_hInstance, IDC_DETOURSAMPLE, _szWindowClass, MAX_LOADSTRING);
 
		WNDCLASSEXW wcex;
		wcex.cbSize = sizeof(WNDCLASSEX);
 
		wcex.style = CS_HREDRAW | CS_VREDRAW;
		wcex.lpfnWndProc = WindowProcedure;
		wcex.cbClsExtra = 0;
		wcex.cbWndExtra = 0;
		wcex.hInstance = hInstance;
		wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_DETOURSAMPLE));
		wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
		wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
		wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_DETOURSAMPLE);
		wcex.lpszClassName = _szWindowClass;
		wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
		RegisterClassExW(&wcex);
	}
 
	void Initialize()
	{
		_hWnd = CreateWindowW(_szWindowClass, _szTitle, WS_OVERLAPPEDWINDOW,
			CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, _hInstance, nullptr);
 
		MoveWindow(_hWnd, 400, 400, 700, 400, /*bRepaint*/ false);
		ShowWindow(_hWnd, SW_NORMAL);
		UpdateWindow(_hWnd);
		ShowStatusMsg(L"Click to show MessageBox, RightClick to toggle detours (%S)", g_szArch);
		_hwndBtnMsgBox = CreateWindow(
			L"BUTTON",  // Predefined class; Unicode assumed 
			L"MsgBox",      // Button text 
			WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,  // Styles 
			0,         // x position 
			0,         // y position 
			100,        // Button width
			20,        // Button height
			_hWnd,     // Parent window
			NULL,       // No menu.
			_hInstance,
			NULL);      // Pointer not needed.
 
		_hwndChkDetour = CreateWindow(
			L"BUTTON",  // Predefined class; Unicode assumed 
			L"Detour",      // Button text 
			WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_AUTOCHECKBOX,  // Styles 
			130,         // x position 
			0,         // y position 
			100,        // Button width
			20,        // Button height
			_hWnd,     // Parent window
			NULL,       // No menu.
			_hInstance,
			NULL);      // Pointer not needed.
	}
 
	int _topStatline = 25;
	int _statLine = _topStatline;
	void ShowStatusMsg(LPCWSTR pText, ...)
	{
		if (_hWnd != NULL)
		{
			va_list args;
			va_start(args, pText);
			wstring strtemp(1000, '\0');
			_vsnwprintf_s(&strtemp[0], 1000, _TRUNCATE, pText, args);
			va_end(args);
			auto len = wcslen(strtemp.c_str());
			strtemp.resize(len);
			HDC hDC = GetDC(_hWnd);
			HFONT hFont = (HFONT)GetStockObject(ANSI_FIXED_FONT);
			HFONT hOldFont = (HFONT)SelectObject(hDC, hFont);
			TEXTMETRIC textMetric;
			if (GetTextMetrics(hDC, &textMetric) && textMetric.tmAveCharWidth > 0)
			{
				// pad to full line to erase any prior content
				auto nCharsOnLine = _size.x / textMetric.tmAveCharWidth;
				if (nCharsOnLine > 0 && nCharsOnLine >= (int)strtemp.size())
				{
					auto nCharsToPad = nCharsOnLine - strtemp.size();
					if (nCharsToPad > 0)
					{
						strtemp.insert(strtemp.size(), nCharsToPad, ' ');
					}
					TextOut(hDC, 0, _statLine, strtemp.c_str(), (int)strtemp.size());
					_statLine += textMetric.tmHeight;
					if (_statLine > _size.y)
					{
						_statLine = _topStatline;
					}
				}
			}
			SelectObject(hDC, hOldFont);
			ReleaseDC(_hWnd, hDC);
		}
	}
 
	bool _fIsDetouring = false;
	// Macro to show error. The expression is Stringized using the "#" operator.
	// the "%S" is used (upper case S) to convert to Unicode
#define IFFAILSHOWERROR(expr) \
	if ((err = expr) != NO_ERROR) \
	{\
		g_CMyApplication->ShowStatusMsg(L"Error %d %S", err, #expr); \
	}\
 
	void DoDetours()
	{
		int err;
		IFFAILSHOWERROR(DetourTransactionBegin());
		if (!_fIsDetouring)
		{
			ShowStatusMsg(L"Start Detouring");
			IFFAILSHOWERROR(DetourAttach((PVOID *)&g_real_MessageBoxA, MyMessageBoxA));
			IFFAILSHOWERROR(DetourAttach((PVOID *)&g_real_MessageBoxW, MyMessageBoxW));
		}
		else
		{
			ShowStatusMsg(L"Stop  Detouring");
			IFFAILSHOWERROR(DetourDetach((PVOID *)&g_real_MessageBoxA, MyMessageBoxA));
			IFFAILSHOWERROR(DetourDetach((PVOID *)&g_real_MessageBoxW, MyMessageBoxW));
		}
		IFFAILSHOWERROR(DetourTransactionCommit());
		_fIsDetouring = !_fIsDetouring;
	}
	LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
	{
		switch (message)
		{
		case WM_COMMAND:
		{
			int wmId = LOWORD(wParam);
			// Parse the menu selections:
			switch (wmId)
			{
			case BN_CLICKED:
				if ((HWND)lParam == _hwndBtnMsgBox)
				{
					MessageBoxA(_hWnd, "Some Text", g_szArch, MB_OK);
					//			MessageBoxW(_hWnd, _T("Some Unicode Text"), _T("Caption"), MB_OK);
				}
				else if ((HWND)lParam == _hwndChkDetour)
				{
					DoDetours();
				}
				break;
			case IDM_EXIT:
				DestroyWindow(hWnd);
				break;
			default:
				return DefWindowProc(hWnd, message, wParam, lParam);
			}
		}
		break;
		case WM_SIZE:
		{
			auto pts = MAKEPOINTS(lParam);
			ShowStatusMsg(L"Size  %5d %5d", pts.x, pts.y);
			_size = pts;
		}
		break;
		case WM_PAINT:
		{
			PAINTSTRUCT ps;
			HDC hdc = BeginPaint(hWnd, &ps);
			EndPaint(hWnd, &ps);
		}
		break;
		case WM_DESTROY:
			PostQuitMessage(0);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		return 0;
	}
 
	int DoMessageLoop()
	{
		HACCEL hAccelTable = LoadAccelerators(_hInstance, MAKEINTRESOURCE(IDC_DETOURSAMPLE));
		MSG msg;
		// Main message loop:
		while (GetMessage(&msg, nullptr, 0, 0))
		{
			if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
		return (int)msg.wParam;
	}
};
 
LRESULT CALLBACK WindowProcedure(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	return g_CMyApplication->WndProc(hWnd, message, wParam, lParam);
}
 
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
	_In_opt_ HINSTANCE hPrevInstance,
	_In_ LPWSTR    lpCmdLine,
	_In_ int       nCmdShow)
{
	// create an instance of CMyApplication  on stack
	CMyApplication aCMyApplication(hInstance);
	g_CMyApplication = &aCMyApplication;
	g_CMyApplication->Initialize();
 
	return g_CMyApplication->DoMessageLoop();
}

Visual Studio slowdown because Virus & Threat protection Windows Defender Antivirus is scanning this file

CalvinH — Wed, 27 Jun 2018 22:32:09 GMT

I noticed that if I hit F5 to build and debug some code for a very small solution (1-5 small projects), there was a long delay of about 10-15 seconds. This seemed very unusual: I was expecting near instantaneous response.
If I change a single file and do a Build (without running), the build completes quickly, taking advantage of incremental build in managed and native compilers.

If I hit F5 to run the app (the first time after build, the delay occurs), stop debugging, and hit F5 again (without changing any code and thus no change in the running binary), the 2nd time is much faster (2-3 seconds).

So… the long delay occurred only the first time a build changes the binary.

I tried to see what was going on and learned that if I disabled Real time Virus protection for the folder into which my binaries are built, then the delay is gone.

Once the file has been scanned and deemed without a virus, the 2nd time running “remembers” the result and is much faster.

While writing code, many developers repeat a few steps:
1.    Make a code change,
2.    Build and run the code
3.    Ensure the code runs as expected
4.    Repeat

For some smaller projects, sometimes that loop takes 1-2 seconds. If there’s a 12 second delay for virus scanning the newly built executable code, then that’s a significant productivity slowdown.

I’ve observed these delays on other folk’s machines too.

Slowdowns due to AntiVirus are probably in many AV products. Thankfully, there’s a workaround: you can add a folder to an “Exclusion List”

Once I did that, the long delay was gone.

BTW, Edit and Continue (even in C++) is a really good feature to avoid stopping/starting debugging). When you reach a break point you can modify your code, Set Next Statement (change the next statement that gets executed) if necessary, and continue running the newly modified code.

I’m a big fan of Test Driven Development (TDD). One of my favorite shortcut keys is Ctrl-R L, which repeats the last run unit test.

Virus & threat protection Windows defender antivirus is scanning this file

visual studio virus & threat protection windows defender antivirus is scanning this file your it administrator requires a security scan of this item. The scan could take up to 10 seconds

Getting more disk space, Symbolic Links and Azure Virtual Machines

CalvinH — Wed, 30 May 2018 23:46:01 GMT

AzureAzure lets you get free virtual machines.
What does this mean? You can use a free Azure account to create a new machine that only you can access, and can manipulate it as you see fit, almost as if you had a brand new computer to use (you can’t spill coffee on it). It can be configured with various amounts of memory, computing power.

You can use Remote Desktop Connection to connect to the new machine and use it as if you were right in front of it. Your monitor will show the Virtual Machine and the keyboard and mouse will be attached to the VM. It’s a “virtual” machine, so it doesn’t really exist as a physical computer, but it is hosted on a real computer.

The host machine can host many virtual machines simultaneously, each independent of the other, yielding huge economies of scale: think how often you use your computer, or more precisely, how often you don’t use your computer.

Unless you are a BlockChain miner (currently in the news a lot because of the huge computation power required), your machine will likely be unused much of the time, and thus the actual cost is just a few files on the disk of the host computer. As you use your virtual machine, parts of the file are swapped into the host, while others may be swapped out.

Virtual Machines have been around for a while: I’ve been hosting them in various Windows versions for over a decade. HyperVisor manager in Windows Server is a control center for managing VMs
I like to say that the 2 best inventions in computing are Cut/Paste, then Virtual Machines.

Here you can see one of my physical machines “CalvinH1” hosting 4 Virtual Machines:

Not only are there Virtual Machines, but you can create Virtual Disks for the VMs in both HyperVisor and Azure. These are stored on the host machine as files, which are pretty inexpensive to store these days. I remember getting a 5 Megabyte hard disk for several hundred dollars.
Once you create and associate a new Virtual Disk to a Virtual Machine via HyperVisor or Azure, you need to attach the disk to the machine. You then connect to the VM via Remote Desktop, open File Explorer, right click on “This PC”, choose Computer Management->Storage->Disk Management to see your new uninitialized disk (just as if attaching a real physical disk to a real physical machine).

You can format newly attached drives, create new volumes, and even mount a volume into a folder.
I have an enlistment for a very large GIT Repo on one of my Azure machines, which had a 127G initial drive size for volume C:. I ran out of space, so I created a couple volumes and mounted them to folders, like “c:\Nugetcache” and “c:\vs\VSOut”.

TreeMap is very handy at identifying large disk folders, which are candidates for moving or deleting.

Windows comes with a utility to create symbolic links: mklink
C:\>mklink /?
Creates a symbolic link.

MKLINK [[/D] | [/H] | [/J]] Link Target

        /D      Creates a directory symbolic link. Default is a file
                symbolic link.
        /H      Creates a hard link instead of a symbolic link.
        /J      Creates a Directory Junction.
        Link    Specifies the new symbolic link name.
        Target Specifies the path (relative or absolute) that the new link
                refers to.

Be very careful when deleting a symbolic link: ensure that you’re not deleting the target of the link, but just the link itself!

If you are running out of space on a volume, you can move some large folders out to make more room.
Identify the large folder. E.G. the Windows SDK “C:\Program Files (x86)\Windows Kits” can be several Gigabytes.
Shutdown any program that might be using the folder, like Visual Studio (ensure MsBuild shut down too)
Copy/delete original windows kits directory: e.g. "C:\Program Files (x86)\Windows Kits" to “e:\Windows Kits"
Mklink /j "C:\Program Files (x86)\Windows Kits" "e:\Windows Kits"

You can use the program below to understand more about Symbolic Links.

File->new->project->C#->Console App

Paste in the code below.
For testing, you can choose Project->properties->Debug tab, and in the Command Line Arguments, put is some sample arguments for testing. I used e.g. /d foo "C:\footemp", which would make a link in the current directory to a folder called “c:\footemp”

The resulting Symbolic link “foo” appears:

And double clicking on foo goes to the target.

If you make a Symbolic link to a target that doesn’t exist, the link gets created, but navigating there via File Explorer yields:

If you prepend the linkname with “\\?\” then you can make paths that are longer. Try experimenting with the commented code.
"C:\Users\calvinh\source\repos\SYMBOL~1\SYMBOL~1\bin\Debug\LONGAB~1"

Put a breakpoint on the CreateSymbolicLinkW line and you can experiment with changing values, changing the code, Set Next Statement (to change the next statement to execute)
See Naming Files, Paths, and Namespaces for more on how to use very long ( up to 32,767 char) path names

  
 using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace SymbolicLInk
{
    class Program
    {
        static int Main(string[] args)
        {
            var instance = new Program();
            return instance.DoMain(args);
        }

        private int DoMain(string[] args)
        {
            var flag = SYMBOLIC_LINK_FLAG.File;
            var linkName = string.Empty;
            var linkTarget = string.Empty;
            for (int i = 0; i < args.Length; i++)
            {
                switch (args[i][0])
                {
                    case '-':
                    case '/':
                        if (args[i].Length > 1)
                        {
                            switch (args[i][1])
                            {
                                case 'D':
                                case 'd':
                                    flag = SYMBOLIC_LINK_FLAG.Directory;
                                    break;
                            }
                        }
                        break;
                    default:
                        if (string.IsNullOrEmpty(linkName))
                        {
                            linkName = args[i];
                        }
                        else
                        {
                            if (string.IsNullOrEmpty(linkTarget))
                            {
                                linkTarget = args[i];
                            }
                            else
                                return ShowHelp();
                        }
                        break;
                }
            }
            if (string.IsNullOrEmpty(linkName) || string.IsNullOrEmpty(linkTarget))
            {
                return ShowHelp();
            }
            //var longstr = $"a{new string('b', 242)}c";
            //var longname = $@"Long{longstr}dirname";
            //var lenLink = longname.Length;
            //linkName = $@"\\?\{System.Environment.CurrentDirectory}\{longname}";
            ////Starting with Windows 10, version 1607, for the unicode version of this function (CreateSymbolicLinkW), you can opt-in to remove the MAX_PATH limitation without prepending "\\?\". See the "Maximum Path Length Limitation" section of Naming Files, Paths, and Namespaces for details.
            //var lenLinkTotal = linkName.Length;

            if (CreateSymbolicLinkW(linkName, linkTarget, flag))
            {
                OutputString($"Successfully created link from '{linkName}' to '{linkTarget}'");
            }
            else
            {
                var lastErr = Marshal.GetLastWin32Error();
                var errInfo = string.Empty;
                switch (lastErr)  // from Tools->Error Lookup
                {
                    case 3: //The system cannot find the path specified. 
                        errInfo = "The system cannot find the path specified.";
                        break;
                    case 123: //The filename, directory name, or volume label syntax is incorrect. 
                        errInfo = "The filename, directory name, or volume label syntax is incorrect.";
                        break;
                    case 183: //Cannot create a file when that file already exists. 
                        errInfo = "Cannot create a file when that file already exists.";
                        break;
                    case 1314: // A required privilege is not held by the client. 
                        errInfo = "A required privilege is not held by the client. Are you running as Admin?";
                        break;
                    default:
                        break;
                }
                OutputString($"Failed to create link from '{linkName}' to '{linkTarget}'   {Marshal.GetLastWin32Error()} {errInfo}");
            }
            return 0; // success
        }

        private int ShowHelp()
        {
            OutputString("Symbolic Link");
            OutputString("Usage: SymbolicLink [/D] link target");
            OutputString("  link is the name to create for the link");
            OutputString("  target is the redirected location");
            OutputString("To delete the link, delete from File Explorer as if it were a normal file or directory");
            return 1; //failure
        }
        void OutputString(string str)
        {
            Debug.WriteLine(str);
            Console.WriteLine(str);
        }

        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
        [return: MarshalAs(System.Runtime.InteropServices.UnmanagedType.I1)]
        static extern bool CreateSymbolicLinkW(string lpSymlinkFileName, string lpTargetFileName, SYMBOLIC_LINK_FLAG dwFlags);
        public enum SYMBOLIC_LINK_FLAG
        {
            File = 0,
            Directory = 1
        }


    }
}

Lasers bouncing off elliptical mirrors in C#

CalvinH — Mon, 30 Apr 2018 17:54:55 GMT

The NumberPhile Illumination Problem https://www.youtube.com/watch?v=xhj5er1k6GQ describes reflecting light beams off mirrored walls to see if all parts of an oddly shaped room can be illuminated.

In the last 2 posts (Lasers reflecting off an ellipse and Reflect laser beams off multiple mirrors) I showed some code to simulate laser beams reflecting off multiple mirrors in C++

Here is a solution in C# that includes the prior C++ functionality and also an ellipse very close to that described in the video.

The C# code for Reflection is 1600 lines, too big to put in a blog post. So it’s here:
https://github.com/calvinhsia/HwndHost/blob/nlasers/Reflect/Reflect.xaml.cs

I’ve been hosting the code in VSOnline using GIT. Moving the code to use a different backend was pretty simple. First I created an empty repo in GitHub.
Then:

git remote set-url origin https://github.com/calvinhsia/HwndHost.git
git push

Just Start Visual Studio, View->Team Explorer, Manage Connections, Clone https://github.com/calvinhsia/HwndHost.git
Then open the HWndHost.sln, right click on Reflect (or any other project in the solution) Set as Startup, then F5 to run the code

Which one is faster the C++ or the C# solution? The number of bounces per second is displayed in the status bar for each.

Issues:
1. When a beam hits a corner, what should it do? right now the angle can be anything depending on how “close” to the corner it is. It’s the same problem as finding a tangent to a point. You can find a tangent to a curve, but what if it’s a point? Thus currently, the light beams can escape. Different starting window sizes make a difference in the calculations for the light beams.
2. The code doesn’t remember whether a particular laser beam is identical to a prior laser beam. If so, then we know that spot has been illuminated and we can terminate the laser beam (if that’s possible). It’s still interesting to watch as the laser beams change color and traverse the shape.

In the same HWndHost solution there are several other projects that do some fancy graphics stuff:

Bouncing balls on the screen (written in VB) You can use HWndHost to host a Win32 HWnd window inside a WPF element

Fish vs Sharks: Predator Prey simulation based on the same base class “HWndHost” as the Bouncing balls.

Logo Turtle Graphics in WPF where you have a very fast turtle with a pen, also based on the same base class.

Lasers reflecting off an ellipse

CalvinH — Fri, 30 Mar 2018 20:40:06 GMT

Various conic sections (hyperbolas, parabolas, ellipses) have interesting reflective properties. Parabolas are used for antennae and even car headlight and flashlight reflectors to focus a beam of light.

In the last post https://blogs.msdn.microsoft.com/calvin_hsia/2018/02/28/reflect-laser-beams-off-multiple-mirrors I showed some code to bounce a laser off various mirrors that the user can draw on the screen. I also mentioned that an elliptically shaped water tank will reflect waves and that Lithotripter uses ellipses to remove kidney stones
Let’s enhance that code:
•    Add an ellipse
•    Allow multiple lasers, initially emanating from a single point, thus simulating a point source of light
•    Added a context menu that allows the user to set the initial laser point. E.g. what happens if you put the lasers initially at a focus of the ellipse?
•    Added an options dialog that allows the user to control the number of lasers

The code involves multiple files, one of which has 1300 lines and thus is hard to publish as a single blog entry, so I’ve put it at https://github.com/calvinhsia/ReflectCpp
Just clone the repo locally, open the solution ReflectCPP.sln and run it.

Note how the code has multiple kinds of mirrors (currently 2), all of which implement an interface IMirror, which has methods like Draw, IntersectingPoint and Reflect

Things to try:
•    Slow it down, use 1 laser, watch how it reflects off the ellipse walls
•    Use your mouse and draw a mirror or several and watch how it affects the pattern.
•    Try to isolate the light into patterns stuck in just a portion of the ellipse without a mirror touching the ellipse (try setting the laser count to 1 first)

The name “ReflectCPP” implies it is the C++ version of the code, and that there’s another version. Next time!
The patterns generated from the code are pretty remarkable. You can see the symmetry around the focal points (the little dots)

Reflect laser beams off multiple mirrors

CalvinH — Wed, 28 Feb 2018 02:33:43 GMT

In some science museums there are exhibits demonstrating the paths of light rays. A typical one might have a table with small walls consisting of blocks a few inches high, with each vertical face being a mirror. A small horizontal laser can be positioned anywhere on the table. Many blocks be placed on the table to reflect the light. The room can be darkened, and chalk dust can be sprinkled to see the laser beams as the reflect from mirror to mirror. Blocks can be arranged in various shapes to vary the light patterns produced.
Creating such an environment requires a laser, several mirrors, etc. Simulating the setup with software however, is much easier.

I was talking to my son about this laser table idea and he pointed me to the The NumberPhile Illumination Problem https://www.youtube.com/watch?v=xhj5er1k6GQ

I remember years ago playing with ripple tanks years ago. A tray with e.g. circular 2 inch walls was filled with water. A point source like the tip of a vertical stick was repeatedly immersed, removed from the water to cause a point source of waves. The pattern of waves could easily be seen. If the stimulant was in the center of the circle, the ripples would reach the edges simultaneously. What if the edges were an ellipse? We learned in math class that an ellipse has many interesting properties. If you stimulate one focus of the ellipse, the other waves will converge on the other.
I remember reading about real applications of the ellipse in eliminating kidney stones with an elliptical shock wave, which pulverizes the stones without surgery using a Lithotripter

Imagine drawing arbitrary shapes on the screen with your mouse or your finger, each representing an arrangement of mirrors on the laser table. Turn on the laser and watch the laser beam bounce off the mirrors. Is it possible to create a region in which the light never goes? Sure: create a closed shape like a triangle. How about a non-closed shape?

Because the laser beam is so fast, the area gets colored very quickly. To make the light beam more visible, the code varies the color of the laser beam with time so that it’s easier to see where the laser is. If not, thousands of lasers per second would quickly fill the entire screen with the same color.
Try drawing mirrors while the light is bouncing around. Even though one thread is modifying the list of mirrors, the reflections continue.

If the walls are only horizontal or vertical, then reflecting is easy: for a horizontal wall, just negate the vertical component of the velocity. It gets more complicated when the mirrors can be any angle.

Notice how the drawing can be done in a background thread, even though WPF or GDI demands UI control access on the main thread.

Notice that there are no explicit memory allocations in this C++ program: no operator new

Various places in the code do mathematical manipulations such as multiplication, additions, square root. You can see how the optimized Release build inlines a lot of these to make the more efficient. The generated instructions are vastly different if using an Enhanced Instruction Set. Project->Properties=>C/C++->Code Generation->Enabled Enhanced Instruction Set

Below is a C++ program that models the mirror table.
A Vector (with a capital “V”) is a physics vector. (A “vector” with a lower-case “v” is a std collection of a list of elements.)
A light beam is modeled as a point (from which the laser beam emanates) and a Vector indicating direction, with x and y components.
A mirror interface IMirror is defined. A mirror can:
1.    determine if a light beam intersects it (returning the Point of intersection)
2.    draw itself
3.    determine the Vector of a reflecting incoming laser beam

A MyPoint class is a Point in the x,y plane.
A CLine class is a line, consisting of 2 points and a bool indicating whether the line is infinite (like a laser beam) or is a line segment (like a finite length mirror)

Various accelerator keys are defined, such as “R” to run/stop the simulation, “S” and “F” for slower and faster to control the reflection speed, etc.

Try turning on drag mode (right-click) and control-mouse move to draw continuous curved wall mirrors.
Try creating long angled corridors to watch the light bounce around in interesting ways. (as the light gets further down a narrowing corridor, the angles change and the light reflects out without going all the way down the corridor: a kind of light valve.
Try capturing the laser light in various shapes.
Try slowing down the light rays and follow them, while creating more mirrors
Try modifying the code to have multiple lasers at a time, simulating a point source of light.
Try comparing the performance of 32 and 64 bit builds (to build 64 bit, Menu->Build->Configurations->Active Solution Platform->x64

 // ReflectCpp.cpp : Defines the entry point for the application.
//

// Team Explorer->Connections->New Repository "ReflectCPP"
// DblClick the newly created Repo to get to the Team Explorer Home pane.
// Solutions->New->C++ Win32Project. Select all the defaults in the Win32 App Wizard
// add natvis: https://msdn.microsoft.com/en-us/library/jj620914.aspx?f=255&MSPPError=-2147217396

#include "stdafx.h"
#include "ReflectCpp.h"
#include "windowsx.h"
#include "vector"
#include "memory"
#include "string"
#include "atlbase.h"

using namespace std;
using namespace ATL;

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE g_hInstance;                                // current instance
WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name

												// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
class BounceFrame;
BounceFrame *g_pBounceFrame;

HWND g_hWnd;

//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEXW wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style = CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc = WndProc;
	wcex.cbClsExtra = 0;
	wcex.cbWndExtra = 0;
	wcex.hInstance = hInstance;
	wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_REFLECTCPP));
	wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
	wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
	wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_REFLECTCPP);
	wcex.lpszClassName = szWindowClass;
	wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	return RegisterClassExW(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
	g_hInstance = hInstance; // Store instance handle in our global variable

	HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

	if (!hWnd)
	{
		return FALSE;
	}

	ShowWindow(hWnd, nCmdShow);
	g_hWnd = hWnd;
	UpdateWindow(hWnd);
	return TRUE;
}

template <typename T> int sgn(T val) {
	return (T(0) < val) - (val < T(0));
}

typedef double MyPrecision;
const double epsilon = .00001;
const int SpeedMult = 1000;
class MyPoint
{
public:
	MyPoint()
	{
		this->X = 0;
		this->Y = 0;
	}
	MyPoint(MyPrecision x, MyPrecision y)
	{
		this->X = x;
		this->Y = y;
	}
	MyPoint(POINTS pt)
	{
		this->X = pt.x;
		this->Y = pt.y;
	}
	// assignment
	MyPoint & operator=(const MyPoint other)
	{
		this->X = other.X;
		this->Y = other.Y;
		return *this;
	}
	// equality
	bool operator ==(const MyPoint other)
	{
		if (abs(this->X - other.X) < epsilon && abs(this->Y - other.Y) < epsilon)
		{
			return true;
		}
		return false;
	}
	bool operator !=(const MyPoint other)
	{
		return !(*this == other);
	}
	bool IsNull()
	{
		return X == 0 && Y == 0;
	}
	void Clear()
	{
		X = Y = 0;
	}
	double DistanceFromPoint(MyPoint other)
	{
		auto deltax = this->X - other.X;
		auto deltay = this->Y - other.Y;
		auto d = sqrt(deltax * deltax + deltay * deltay);
		return d;
	}
	MyPrecision X;
	MyPrecision Y;
};

typedef MyPoint Vector; // as in physics vector with speed and direction

interface IMirror
{
	virtual MyPoint IntersectingPoint(MyPoint ptcLight, Vector vecLight) = 0;
	virtual Vector Reflect(MyPoint ptLight, Vector vecLight, MyPoint ptIntersect) = 0;
	virtual void Draw(HDC hDC) = 0;
	virtual ~IMirror() {};
};

class CLine : public IMirror
{
public:
	CLine(MyPoint &pt0, MyPoint &pt1, bool IsLimitedInLength = true)
	{
		this->pt0 = pt0;
		this->pt1 = pt1;
		this->IsLimitedInLength = IsLimitedInLength;
	}
	MyPrecision LineLength()
	{
		return sqrt(LineLengthSquared());
	}
	MyPrecision LineLengthSquared()
	{
		return deltaX()*deltaX() + deltaY()*deltaY();
	}
	MyPrecision deltaX()
	{
		return pt1.X - pt0.X;
	}
	MyPrecision deltaY()
	{
		return pt1.Y - pt0.Y;
	}

	MyPoint IntersectingPoint(MyPoint ptLight, Vector vecLight)
	{
		MyPoint ptIntersect;
		CLine lnIncident(ptLight, MyPoint(ptLight.X + vecLight.X, ptLight.Y + vecLight.Y));
		auto ptIntersectTest = IntersectingPoint(lnIncident);
		// the incident line intersects the mirror. Our mirrors have finite width
		// let's see if the intersection point is within the mirror's edges
		if (!ptIntersectTest.IsNull())
		{
			if (this->IsLimitedInLength)
			{
				if (pt0.DistanceFromPoint(ptIntersectTest) +
					ptIntersectTest.DistanceFromPoint(pt1) - LineLength() < epsilon)
				{
					if (abs(vecLight.X) < epsilon) // vert
					{
						auto ss = sgn(vecLight.Y);
						auto s2 = sgn(ptIntersectTest.Y - ptLight.Y);
						if (ss * s2 == 1) // in our direction?
						{
							ptIntersect = ptIntersectTest;
						}
					}
					else  // non-vertical
					{
						auto ss = sgn(vecLight.X);
						auto s2 = sgn(ptIntersectTest.X - ptLight.X);
						if (ss * s2 == 1) // in our direction?
						{
							ptIntersect = ptIntersectTest;
						}
					}
				}
			}
			else
			{
				ptIntersect = ptIntersectTest;
			}
		}
		return ptIntersect;
	}

	MyPoint IntersectingPoint(CLine otherLine)
	{
		MyPoint result;
		auto denom = (this->pt0.X - this->pt1.X) * (otherLine.pt0.Y - otherLine.pt1.Y) - (this->pt0.Y - this->pt1.Y) * (otherLine.pt0.X - otherLine.pt1.X);
		if (denom != 0)
		{
			result.X = ((this->pt0.X * this->pt1.Y - this->pt0.Y * this->pt1.X) * (otherLine.pt0.X - otherLine.pt1.X) - (this->pt0.X - this->pt1.X) * (otherLine.pt0.X * otherLine.pt1.Y - otherLine.pt0.Y * otherLine.pt1.X)) / denom;
			result.Y = ((this->pt0.X * this->pt1.Y - this->pt0.Y * this->pt1.X) * (otherLine.pt0.Y - otherLine.pt1.Y) - (this->pt0.Y - this->pt1.Y) * (otherLine.pt0.X * otherLine.pt1.Y - otherLine.pt0.Y * otherLine.pt1.X)) / denom;
		}
		return result;
	}

	Vector Reflect(MyPoint ptLight, Vector vecLight, MyPoint ptIntersect)
	{
		if (abs(pt0.X - pt1.X) < epsilon) // vertical line
		{
			vecLight.X = -vecLight.X;
		}
		else if (abs(pt0.Y - pt1.Y) < epsilon)// horiz line
		{
			vecLight.Y = -vecLight.Y;
		}
		else
		{
			//// create incident line endpoint to intersection with correct seg length
			CLine lnIncident(ptLight, ptIntersect);
			//var angBetween = lnIncidentTest.angleBetween(lnMirror);
			//var angClosest = Math.Atan(lnMirror.slope) / _piOver180;
			//var angIncident = Math.Atan(lnIncidentTest.slope) / _piOver180;
			//var angReflect = 2 * angClosest - angIncident;
			auto newSlope = tan(2 * atan(slope()) - atan(lnIncident.slope()));
			// now we have the slope of the desired reflection line: 
			// now we need to determine the reflection direction (x & y) along the slope
			// The incident line came from one side (half plane) of the mirror. We need to leave on the same side.
			// to do so, we assume we're going in a particular direction
			// then we create a test point using the new slope
			// we see which half plane the test point is in relation to the mirror.
			// and which half plane the light source is. If they're different, we reverse the vector

			// first set the new vector to the new slope in a guessed direction. 
			vecLight.X = SpeedMult;
			vecLight.Y = SpeedMult * newSlope;
			// create a test point along the line of reflection
			MyPoint ptTest(ptIntersect.X + vecLight.X, ptIntersect.Y + vecLight.Y);
			auto halfplaneLight = LeftHalf(ptLight);
			auto halfplaneTestPoint = LeftHalf(ptTest);
			if (halfplaneLight ^ halfplaneTestPoint) // xor
			{
				vecLight.X = -vecLight.X;
				vecLight.Y = -vecLight.Y;
			}
		}
		return vecLight;
	}

	MyPrecision slope()
	{
		return deltaY() / deltaX();
	}

	bool LeftHalf(MyPoint c)
	{
		auto a = pt0;
		auto b = pt1;
		auto res = (b.X - a.X) * (c.Y - a.Y) - (b.Y - a.Y) * (c.X - a.X);
		return res > 0;
	}
	void Draw(HDC hDC)
	{
		MoveToEx(hDC, (int)pt0.X, (int)pt0.Y, nullptr);
		LineTo(hDC, (int)pt1.X, (int)pt1.Y);
	}

	bool IsNull()
	{
		return pt0.IsNull() || pt1.IsNull();
	}
	MyPoint pt0;
	MyPoint pt1;
	bool IsLimitedInLength;
};


class BounceFrame
{
	CComAutoCriticalSection csLstMirrors;
#define LOCKMirrors CComCritSecLock lock(csLstMirrors)
	vector> _lstMirrors; // as in a List
#define  margin  5
#define xScale 1
#define yScale 1

	MyPoint _frameSize; // size of drawing area
	HPEN _clrLine;
	HPEN _clrFillReflection;
	int _colorReflection;
	int _nPenWidth;
	HBRUSH _hBrushBackGround;
	MyPoint _ptOldMouseDown;
	MyPoint _ptCurrentMouseDown;
	bool _fPenModeDrag = false;
	bool _fPenDown = false;
	bool _fIsRunning = false;
	bool _fCancelRequest = false;
	int _nDelayMsecs = 0;
	int _nBounces = 0;
	DWORD _timeStartmSecs;
	Vector _vecLightInit;
	MyPoint _ptLightInit;
	int _nOutofBounds;
public:
	BounceFrame()
	{
		_nPenWidth = 1;
		_hBrushBackGround = CreateSolidBrush(0xffffff);
		_clrLine = CreatePen(0, _nPenWidth, 0x0);
		_colorReflection = 0xff;
		_clrFillReflection = CreatePen(0, _nPenWidth, _colorReflection);
		_ptLightInit.X = 140;
		_ptLightInit.Y = 140;
	}
	~BounceFrame()
	{
		DeleteObject(_hBrushBackGround);
		DeleteObject(_clrLine);
		DeleteObject(_clrFillReflection);
	}
private:
	void ShowStatusMsg(LPCWSTR pText, ...)
	{
		va_list args;
		va_start(args, pText);
		wstring strtemp(1000, '\0');
		_vsnwprintf_s(&strtemp[0], 1000, _TRUNCATE, pText, args);
		va_end(args);
		auto len = wcslen(strtemp.c_str());
		strtemp.resize(len);
		HDC hDC = GetDC(g_hWnd);
		HFONT hFont = (HFONT)GetStockObject(ANSI_FIXED_FONT);
		HFONT hOldFont = (HFONT)SelectObject(hDC, hFont);
		TextOut(hDC, 0, (int)_frameSize.Y + 1, strtemp.c_str(), (int)strtemp.size());
		SelectObject(hDC, hOldFont);
		ReleaseDC(g_hWnd, hDC);
	}
	void DrawMirrors()
	{
		if (g_hWnd != nullptr)
		{
			HDC hDC = GetDC(g_hWnd);
			LOCKMirrors;
			SelectObject(hDC, _clrLine);
			for (auto line : _lstMirrors)
			{
				line->Draw(hDC);
			}
			//            Arc(hDC, 20, 20, 800, 400, 800, 200, 0, 200);
			ReleaseDC(g_hWnd, hDC);
		}
	}
	void SetColor(int color)
	{
		_colorReflection = color;
		DeleteObject(_clrFillReflection);
		_clrFillReflection = CreatePen(/*nPenStyle:*/ 0, _nPenWidth, _colorReflection);

	}
	void ChooseRandomStartingRay()
	{
		_ptLightInit.X = (MyPrecision)(margin + (_frameSize.X - 2 * margin)* ((double)rand()) / RAND_MAX);
		_ptLightInit.Y = (MyPrecision)(margin + (_frameSize.Y - 2 * margin)* ((double)rand()) / RAND_MAX);
		_vecLightInit.X = 1;
		_vecLightInit.Y = (MyPrecision)(((double)rand()) / RAND_MAX);
	}

	void Clear(bool fKeepUserMirrors)
	{
		MyPoint topLeft = { margin, margin };
		MyPoint topRight = { _frameSize.X - margin, margin };
		MyPoint botLeft = { margin, _frameSize.Y - margin };
		MyPoint botRight = { _frameSize.X - margin,_frameSize.Y - margin };
		_ptCurrentMouseDown.Clear();
		_ptOldMouseDown.Clear();
		_fPenDown = false;
		_fPenModeDrag = false;
		_ptLightInit.X = 140;
		_ptLightInit.Y = 140;
		_vecLightInit.X = 11;
		_vecLightInit.Y = 10;
		_nBounces = 0;
		_nOutofBounds = 0;
		_colorReflection = 0;
		if (!fKeepUserMirrors)
		{
			LOCKMirrors;
			_lstMirrors.clear();
			_lstMirrors.push_back(make_shared(topLeft, topRight));
			_lstMirrors.push_back(make_shared(topRight, botRight));
			_lstMirrors.push_back(make_shared(botRight, botLeft));
			_lstMirrors.push_back(make_shared(botLeft, topLeft));
		}
		if (g_hWnd != nullptr)
		{
			HDC hDC = GetDC(g_hWnd);
			RECT rect;
			GetClientRect(g_hWnd, &rect);
			FillRect(hDC, &rect, _hBrushBackGround);
			ReleaseDC(g_hWnd, hDC);
			DrawMirrors();
		}
	}

	int DoReflecting()
	{
		int nLastBounceWhenStagnant = 0;
		_timeStartmSecs = GetTickCount();
		_nOutofBounds = 0;
		HDC hDC = GetDC(g_hWnd);
		while (_fIsRunning && !_fCancelRequest)
		{
			//MyPoint ptEndIncident(_ptLight.x + _vecLight.x, _ptLight.y + _vecLight.y);
			//auto lnIncident = MyLine(_ptLight, ptEndIncident);
			auto lnIncident = CLine(_ptLightInit, MyPoint(_ptLightInit.X + _vecLightInit.X, _ptLightInit.Y + _vecLightInit.Y));
			auto minDist = 1000000.0;
			shared_ptr mirrorClosest;
			MyPoint ptIntersect = { 0,0 };
			{
				LOCKMirrors;
				for (auto mirror : _lstMirrors)
				{
					auto ptIntersectTest = mirror->IntersectingPoint(_ptLightInit, _vecLightInit);;
					if (!ptIntersectTest.IsNull())
					{
						auto dist = _ptLightInit.DistanceFromPoint(ptIntersectTest);

						if (dist > epsilon && dist < minDist)
						{
							minDist = dist;
							mirrorClosest = mirror;
							ptIntersect = ptIntersectTest;
						}
					}
				}
			}
			if (mirrorClosest == nullptr)
			{
				if (nLastBounceWhenStagnant == _nBounces)
				{// both the last bounce and this bounce were stagnant
					nLastBounceWhenStagnant = _nBounces;
					_nOutofBounds++;
					ChooseRandomStartingRay();
				}
				else
				{
					_vecLightInit.X = -_vecLightInit.X;
					nLastBounceWhenStagnant = _nBounces;
				}
				continue;
			}
			// now draw incident line from orig pt to intersection
			SelectObject(hDC, _clrFillReflection);
			if (_nBounces == 1)
			{
				MoveToEx(hDC, (int)(xScale * _ptLightInit.X), (int)(yScale * _ptLightInit.Y), nullptr);
			}
			LineTo(hDC, (int)(xScale * ptIntersect.X), (int)(yScale * ptIntersect.Y));

			// now reflect vector
			_vecLightInit = mirrorClosest->Reflect(_ptLightInit, _vecLightInit, ptIntersect);


			// now set new pt 
			_ptLightInit = ptIntersect;
			SetColor((int)_colorReflection + 1 & 0xffffff);

			if (_nDelayMsecs > 0)
			{
				Sleep(_nDelayMsecs);
			}
			if (_nBounces % 1000 == 0)
			{
				ShowStatus();
			}
			_nBounces++;

		}
		ReleaseDC(g_hWnd, hDC);
		_fCancelRequest = false;
		return 0;
	}
	static DWORD WINAPI ThreadRoutine(void *parm)
	{
		BounceFrame *pBounceFrame = (BounceFrame *)parm;
		return pBounceFrame->DoReflecting();
	}

	void CancelRunning()
	{
		if (_fIsRunning)
		{
			_fCancelRequest = true;
			_fIsRunning = false;
			while (_fCancelRequest)
			{
				Sleep(_nDelayMsecs + 10);
			}
		}
	}

	void DoRunCommand()
	{
		_fIsRunning = !_fIsRunning;
		if (_fIsRunning)
		{
			auto hThread = CreateThread(
				nullptr, // sec attr
				0,  // stack size
				ThreadRoutine,
				this, // param
				0, // creationflags
				nullptr // threadid
			);
		}
		else
		{
			CancelRunning();
		}
	}

	void ShowStatus()
	{
		int nBouncesPerSecond = 0;
		DWORD nTicks = GetTickCount() - _timeStartmSecs;
		if (_fIsRunning)
		{
			nBouncesPerSecond = (int)(_nBounces / (nTicks / 1000.0));
		}
		ShowStatusMsg(L"Drag %d PenDown %d (%d,%d)-(%d,%d) Delay=%4d #M=%d OOB=%d #Bounces=%-10d # b/sec = %d      ",
			_fPenModeDrag,
			_fPenDown,
			(int)_ptOldMouseDown.X, (int)_ptOldMouseDown.Y,
			(int)_ptCurrentMouseDown.X, (int)_ptCurrentMouseDown.Y,
			_nDelayMsecs,
			_lstMirrors.size(),
			_nOutofBounds,
			_nBounces,
			nBouncesPerSecond
		);
	}
public:
	LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
	{
		switch (message)
		{
		case WM_SIZE:
		{
			_frameSize = MAKEPOINTS(lParam);
			_frameSize.Y -= 14; // room for status
			Clear(/*fKeepUserMirrors=*/false);
		}
		break;
		case WM_RBUTTONDOWN:
			_fPenModeDrag = !_fPenModeDrag;
			_ptOldMouseDown = MAKEPOINTS(lParam);
			ShowStatus();
			break;
		case WM_LBUTTONDOWN:
			if (_fPenModeDrag)
			{
				_ptOldMouseDown = MAKEPOINTS(lParam);
			}
			else
			{
				_ptCurrentMouseDown = MAKEPOINTS(lParam);
				if (!_ptOldMouseDown.IsNull() && _ptOldMouseDown != _ptCurrentMouseDown)
				{
					LOCKMirrors;
					_lstMirrors.push_back(make_shared(_ptOldMouseDown, _ptCurrentMouseDown));
					DrawMirrors();
				}
				_ptOldMouseDown = _ptCurrentMouseDown;
			}
			ShowStatus();
			break;
		case WM_MOUSEMOVE:
		{
			if (_fPenModeDrag)
			{
				if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
				{
					if (!_ptOldMouseDown.IsNull())
					{
						_ptCurrentMouseDown = MAKEPOINTS(lParam);
						if (_ptCurrentMouseDown != _ptOldMouseDown)
						{
							LOCKMirrors;
							_lstMirrors.push_back(make_shared(_ptOldMouseDown, _ptCurrentMouseDown));
							_ptOldMouseDown = _ptCurrentMouseDown;
							DrawMirrors();
						}
					}
				}
				else
				{
					_ptOldMouseDown.Clear();
				}
			}
			else
			{
				if (_fPenDown)
				{
					if (!_ptOldMouseDown.IsNull())
					{
						_ptCurrentMouseDown = MAKEPOINTS(lParam);
					}
				}
			}
		}
		ShowStatus();
		break;
		case WM_LBUTTONUP:
			if (_fPenDown)
			{
				_ptCurrentMouseDown = MAKEPOINTS(lParam);
				if (_ptCurrentMouseDown != _ptOldMouseDown)
				{
					LOCKMirrors;
					_lstMirrors.push_back(make_shared(_ptOldMouseDown, _ptCurrentMouseDown));
					_ptOldMouseDown = _ptCurrentMouseDown;
					_fPenDown = false;
					DrawMirrors();
				}
			}
			ShowStatus();
			break;
		case WM_COMMAND:
		{
			int wmId = LOWORD(wParam);
			// Parse the menu selections:
			switch (wmId)
			{
			case ID_FILE_RUN:
				DoRunCommand();
				break;
			case ID_CLEAR:
				Clear(/*fKeepUserMirrors=*/true);
				break;
			case ID_CLEARMIRRORS:
				Clear(/*fKeepUserMirrors=*/false);
				break;
			case ID_FILE_SLOWER:
			{
				if (_nDelayMsecs == 0)
				{
					_nDelayMsecs = 1;
				}
				else
				{
					_nDelayMsecs *= 8;
				}
				ShowStatus();
			}
			break;
			case ID_FILE_FASTER:
			{
				_nDelayMsecs /= 8;
				ShowStatus();
			}
			break;
			case ID_FILE_UNDOLASTLINE:
				// don't erase the 4 walls
				if (_lstMirrors.size() > 4)
				{
					LOCKMirrors;
					auto last = _lstMirrors[_lstMirrors.size() - 1];
					_lstMirrors.pop_back();
					Clear(/*fKeepUserMirrors=*/true);
					auto lastLine = dynamic_pointer_cast(last);
					if (lastLine != nullptr)
					{
						_ptOldMouseDown = lastLine->pt1;
					}
					ShowStatus();
				}
				break;
			case IDM_ABOUT:
				DialogBox(g_hInstance, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
				break;
			case IDM_EXIT:
				DestroyWindow(hWnd);
				break;
			default:
				return DefWindowProc(hWnd, message, wParam, lParam);
			}
		}
		break;
		case WM_PAINT:
		{
			PAINTSTRUCT ps;
			HDC hdc = BeginPaint(hWnd, &ps);
			DrawMirrors();
			EndPaint(hWnd, &ps);
		}
		break;
		case WM_DESTROY:
			CancelRunning();
			PostQuitMessage(0);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		return 0;
	}
};

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	return g_pBounceFrame->WndProc(hWnd, message, wParam, lParam);
}

// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;

	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
	_In_opt_ HINSTANCE hPrevInstance,
	_In_ LPWSTR    lpCmdLine,
	_In_ int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

	//create an instance of BounceFrame on the stack
	// that lives until the app exits
	BounceFrame bounceFrame;
	g_pBounceFrame = &bounceFrame;

	// Initialize global strings
	LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadStringW(hInstance, IDC_REFLECTCPP, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Perform application initialization:
	if (!InitInstance(hInstance, SW_MAXIMIZE))
	{
		return FALSE;
	}

	HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_REFLECTCPP));

	MSG msg;

	// Main message loop:
	while (GetMessage(&msg, nullptr, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return (int)msg.wParam;
}

See also
Bouncing balls sample:
https://blogs.msdn.microsoft.com/calvin_hsia/2014/07/31/dpi-aware-sample/

https://blogs.msdn.microsoft.com/calvin_hsia/2018/01/31/store-different-derived-classes-in-collections-in-c-and-c-covariance-shared_ptr-unique_ptr/

https://en.wikipedia.org/wiki/Illumination_problem
http://mathworld.wolfram.com/IlluminationProblem.html