Resources:
Defrag Tools: #23 - Windows 8 SDK
Defrag Tools: #29 - WinDbg - ETW Logging
Windows Performance Analysis Developer Center
Windows Performance Toolkit
Channel 9 Videos
NTDebugging Blog Article
PFE Blog Series

Timeline:
[00:40] - Windows Performance Recorder (UI)
[06:00] - Windows Performance Analyzer
[06:40] - Providers vs. Visualization
[08:00] - (CPU Usage) Sampled vs. Precise
[12:30] - Analysis Pane
[14:11] - * I was thinking of MDI (Multiple Document Interface]
[14:35] - Blue Bar
[15:27] - Gold/Yellow Bar - How to Aggregate
[19:18] - Symbols & SymCache
[28:40] - Column Customization
[31:50] - More next week... and many more weeks to come!

• [00:10] 100 million licenses, 250 million Store app downloads, 400 million active Outlook accounts
• [00:56] Build will release a public preview of “Windows Blue”
• [01:36] Visual Studio 2012.3 (Update 3) “go-live” CTP is now available (Brian Harry),http://go.microsoft.com/fwlink/?LinkId=290979, http://support.microsoft.com/kb/2835600
• [02:46] Announcing availability of ISOs for Visual Studio Updates (Eric Knox), ISO Recorder 
• [04:12] TFS 2012.2 Power Tools update available (Brian Harry)
• [05:09] Publish Individual Files to your Server in Visual Studio 2012.2 (Rick Strahl)
• [06:18] Announcing TechEd Achievements (D. Begley, Karsten Januszewski)
• [07:18] .NET Crash Dump and Live Process Inspection (Lee Culver)
• [08:42] Windows Store app Development snack: Compress your images! (Robert MacLean )
• [09:41] Channel 9 Highlight: Inside Code Digger (Nikolai Tillmann, Peli de Halleux)

Picks of the Week!

• Dan's Pick of the Week:[11:10] Creative Coding Videos
• Brian's Pick of the Week:[12:03] Unit Test Generator under the bonnet (hood) … aka vsarUnitTestFx (Willy-P. Schaub)

Production Note: Yep, no bumpers... Golnaz wasn't available, leaving Brain and Dan on their own, and well... enough said.

Resources:
Defrag Tools: #23 - Windows 8 SDK
Defrag Tools: #29 - WinDbg - ETW Logging
Windows Performance Analysis Developer Center
Windows Performance Toolkit
Channel 9 Videos
NTDebugging Blog Article
PFE Blog Series

Timeline:
[00:00] - What is the Windows Performance Toolkit (WPT)?
[06:23] - Articles
[10:33] - Architecture of Event Tracing for Windows (ETW)
[18:30] - Windows Performance Recorder
[21:50] - Default, Resource and Scenario Profiles
[29:07] - More next week... and many more weeks to come!

Visual Studio has these cool things to help you in your debugging, called Visualizers. They help you see beyond the code and into the data, using a custom dialog or interface. And while there's a number in the box, they can't build one for everything.

But Visual Studio being what it is, you can create your own...

Visual Studio Visualizer: Part 1

Add a Visual Studio Visualizer to look data from: 

• Dataset; 
• DataTable; 
• DataRow; 
• DataView; 
• DataRowView; 
• DataRowCollection.

Using the code

Visit the project home page, download your flavor (2010 or 2012), unzip, and place the DLLs in the right folder, Documents\Visual Studio xxxx\Visualizers. 

When debugging with VS there is a extra option for visualizer, for the DataSet, DataTable, DataRow, and DataView objects. 

Points of Interest

For some reason arrays are not allowed for visualizing within visual studio debug, but when using the VisualizerDevelopmentHost class to test the visualizer, an array is allowed.

This project shows a work around to make a non-serializable object available to our custom visualizer. 

Create a visualizer

This project was created using visual studio express, any edition can be used.

First create a class library project then add a reference to the Visual Studio Visualizer API, the DLL can be found on: (Visual Studio installation folder)\Common7\IDE\ReferenceAssemblies\v2.0 Microsoft.VisualStudio.DebuggerVisualizers.dll. 

Add references to the types of objects, the visualizer will receive:

[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DSVisualizer), typeof(VisualizerObjectSource), Target = typeof(DataSet), Description = "My DataSet Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DTVisualizer), typeof(VisualizerObjectSource), Target = typeof(DataTable), 
    Description = "My DataTable Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DRVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataRow), Description = "My DataRow Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DVVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataView), Description = "My DataView Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DRVVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataRowView), Description = "My DataRowView Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DRCollectionVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataRowCollection), Description = "My DataRowCollection Visualizer")]

This can be inside any cs file of the project, but it must be outside any namespace declaration. As you can see, some types use VisualizerObjectSource and others use DataRowVisualizerObjectSource, this is because the DataRow type needs some massage before we can use it, this is covered later.  

The class that will get the object to visualize must inherits from DialogDebuggerVisualizer. 

This will allow to override the Show method: 

...

Visual Studio Watchers

This project contains some visualizers to work with Visual Studio.

Currently this project has visualizers for:

• DataSet
• DataTable
• DataRow
• DataView
• DataRowView
• DataRowCollection

There next visualizers will be for entity framework objects (trying to do a visualizer for all custom objects), StringBuilder, string and XDocument.

Introduction

Place the dll's in the right folder, Documents\Visual Studio xxxx\Visualizers.
When debugging with VS there is a extra option for visualizer, for the DataSet, DataTable, DataRow and DataView objects.

DataSet

The dataset visualizer mainpage, show a tree and a datagrid. In the tree all of the datatables are available:

...

And as you expect the source for all this is available too...

Timeline:
[01:25] - "Image Tile" bug
[05:00] - Interop Debugging
[06:20] - Debugger Type: Script Only vs. Native/Mixed
[08:17] - JavaScript deployment internals
[11:53] - Attach...
[14:10] - Memory Profiling
[16:58] - JavaScript Memory Analysis (VS2012 Update 1)
[20:18] - Snapshot details
[21:25] - "Root" View

Timeline:
[00:54] - Debugging a JavaScript Windows Store application
[02:30] - Catching Crashes (unhandled exceptions)
[04:25] - WinJS.Utilities.startLog
[05:22] - app.onerror
[09:30] - Stacks
[11:47] - e.detail.error.stack
[14:23] - use strict
[20:25] - www.jslint.com integrated in VS
[22:13] - "Pin" bug
[24:58] - tile vs. title - Lint cannot detect this
[26:50] - Next time... more JavaScript debugging!

Resources:
Maoni's WebLog
Channel9 - CLR 4 Garbage Collector - Inside Background GC
Channel9 - CLR 4.5: Maoni Stephens - Server Background GC
MSDN Magazine - Investigating Memory Issues

Timeline:
[03:30] - How to approach Performance Analysis
[09:00] - Cadence of Gen 0, 1 and 2 garbage collection
[12:20] - !sos.FindRoots
[14:00] - Stop at Gen 1 GC - !sos.FindRoots -gen 1
[16:09] - End of GC: clr!WKS::GCHeap::RestartEE
[17:10] - Stacks of allocations [CLRProfiler] [PerfView]
[18:39] - Object's Generation - !sos.gcwhere <addr>
[19:28] - Generation Segments - !sos.eeheap -gc
[24:52] - VM Hoarding
[28:24] - Heap Summary - !sos.heapstat

Resources:
Maoni's WebLog
Channel9 - CLR 4 Garbage Collector - Inside Background GC
Channel9 - CLR 4.5: Maoni Stephens - Server Background GC
MSDN Magazine - Investigating Memory Issues

Timeline:
[00:00] - What is a Garbage Collector (GC)?
[02:40] - How has the GC changed?
[06:02] - Memory issues
[08:57] - Stress Log (!sos.dumplog)
[10:08] - Troubleshooting and Performance
[12:20] - Demo App
[14:20] - !sos.eeheap -gc
[18:08] - !sos.dumpheap -stat
[20:38] - !sos.dumpheap -mt <mt> (Method Table)
[21:58] - !sos.dumpobj / !sos.do (Dump Object)
[24:15] - Performance Monitoring (SOS, PerfView, Performance Monitor)
[28:06] - Measure immediately after an action, not at a cadence
[29:45] - x clr!WKS::GCHeap::GcCondemnedGeneration (Current GC being collected)
[31:15] - bp clr!WKS::GCHeap::RestartEE (Break after a GC)
[35:30] - More next week...

Resources:
MCTS Windows Internals
Windows Internals Books
Kernrate
Poolmon
UMDH

Timeline:
[01:42] - Summary of the exam
[03:00] - Windows Internals books
[05:50] - Identifying Architectural Components
[14:17] - Designing Solutions
[21:34] - Monitoring Windows
[29:25] - Analyzing User Mode
[41:39] - Analyzing Kernel Mode
[45:17] - Debugging Windows
[48:32] - Good Luck!

This installment goes over the Event Tracing for Windows (ETW) buffers in a kernel mode dump or live session. The ETW buffers can be extracted from the dump and viewed using the Windows Performance Toolkit (WPT). The buffers give you insight in to what has beem happening recently on the computer.

We use these commands:

• !wmitrace.strdump
• !wmitrace.logsave 0xNN c:\example.etl
• !wmitrace.eventlogdump 0xNN
• !wmitrace.help

Make sure you watch Defrag Tools Episode #1 and Defrag Tools Episode #23 for instructions on how to get the Debugging Tools for Windows and how to set the required environment variables for symbol and source code resolution. This episode shows how install the Windows Performance Toolkit.

Timeline:
[00:00] - Event Tracing for Windows (ETW)
[02:18] - Windows Performance Toolkit (WPT)
[03:48] - !wmitrace.strdump
[04:53] - !wmitrace.logsave 0xNN c:\example.etl
[05:50] - Windows Performance Analyzer (WPA) & xPerfView
[07:57] - _NT_SYMCACHE_PATH
[10:24] - !wmitrace.eventlogdump 0xNN
[12:16] - Used for logging and performance by many teams
[15:35] - Private PDBs are needed to decode some entries
[20:00] - Windows Performance Recorder (wprui.exe)
[20:35] - Disable Paging Executive
[23:40] - WPR adds the NT Kernel Logger
[24:19] - 10min run-through of the data collected with the General, CPU and Disk providers

This installment goes over the Windows Scheduler. We look at Running, Ready and Waiting threads, and talks about the effect of Power Management on scheduling.

We use these commands:

• !running
• !running -t
• !ready
• !dpcs
• !thread <addr> 17
• !thread -1 17   (current thread)

Make sure you watch Defrag Tools Episode #1 and Defrag Tools Episode #23 for instructions on how to get the Debugging Tools for Windows and how to set the required environment variables for symbol and source code resolution.

Resources:
Microsoft Data Center Tour

Timeline:
[00:00] - Episode #27's demo issue
[02:47] - Kernel Hangs
[05:18] - !running
[05:48] - Idle Threads & Processor Power Management
[10:10] - !running -t
[13:53] - !ready
[14:15] - Thread State Diagram
[16:45] - Saturated example
[20:48] - Thread Priority Diagram
[22:22] - Balance Set Manager
[25:30] - Waiting Threads
[26:52] - Summary

This installment goes over the cables and configuration steps required to set up kernel mode debugging.

We use these BCDEdit commands:

• bcdedit
• bcdedit /dbgsettings
• bcdedit /dbgsettings 1394 channel:42
• bcdedit /dbgsettings net hostip:192.168.0.10 port:50000 key:a.b.c.d
• bcdedit /debug on
• bcdedit /debug off

In the debug session, we use these commands:

• .crash
• .dump /f
• lm
• !lmi
• .reload /f
• !drvobj
• !drvobj <module> 2
• bl
• bc *
• be <N>
• bd <N>
• bp <function>
• bm <wildcard>
• x <wildcard>
• g

Make sure you watch Defrag Tools Episode #1 and Defrag Tools Episode #23 for instructions on how to get the Debugging Tools for Windows and how to set the required environment variables for symbol and source code resolution.

Resources:
NT Debugging Blog - How to Setup a Debug Crash Cart to Prevent Your Server from Flat Lining
NT Debugging Blog - Remoting Your Debug Crash Cart With KDNET [10th May 2013]
USBView
USB3 Debugging Cable
- Note, you must use a USB3 A-A cable designed for debugging, otherwise it will fry your box!

Timeline:
[00:45] - Kernel Debugging Cables
[02:14] - USB 2.0
[04:13] - USB 3.0 - New in Windows 8/Windows RT
[05:30] - 1394 (Firewire)
[10:39] - Break
[11:38] - Driver Objects
[16:00] - Network - New in Windows 8/Windows RT
[17:30] - Breakpoint commands
[26:00] - Network - BCDEdit
[33:37] - SecureBoot and BitLocker

This installment goes over the commands used to diagnose Semaphores, Mutexes and (Waitable) Timers in a user mode application. For timers, we delve deep in to the kernel to gather more information about them. We use these commands:

• !handle
• !handle <handle> <mask>
• !object <name>
• !object <addr>
• !timer
• !timer <addr>
• ub @rip
• dt nt!_KTHREAD <addr>

Make sure you watch Defrag Tools Episode #1 and Defrag Tools Episode #23 for instructions on how to get the Debugging Tools for Windows and how to set the required environment variables for symbol and source code resolution.

Resources:
Synchronization Functions
Semaphore Objects
Mutex Objects
Waitable Timer Objects
Sysinternals LiveKD
Sysinternals WinObj
Windows 7 and Windows Server 2008 R2 Kernel Changes (Timer Coalescing)

Timeline:
[02:47] - Demo Apps [SkyDrive]
[03:08] - Semaphores
[09:32] - Mutexes
[15:32] - Waitable Timers
[15:58] - Clock Resolution
[17:05] - Timer Coalescing
[19:45] - Timer demo application
[25:05] - LiveKD makes a kernel dump
[26:37] - Object Manager - !object
[29:40] - DPC Timers - !timer
[35:22] - !timer <addr>
[35:52] - Waiting Threads - !thread <addr> 17
[37:08] - Wait Start TickCount
[38:55] - Kernel Wait Routines
[41:12] - Dump Type of Kernel Thread - dt nt!_KTHREAD <addr>
[42:00] - Running, Ready and Waiting states
[44:54] - Wakable Timers
[47:22] - powercfg.exe /waketimers
[49:18] - 'Century' DPC Timer Routine
[50:43] - Post in the forums and email us at defragtools@microsoft.com!

This installment goes over the commands used to diagnose an Event hang in a user mode application. We talk about single and multiple event hangs, automatic and manual events, waitable object handles and common design patterns that you will encounter. We use these commands:

• ~*k
• ~*kv
• ~
• ~~[TID]s
• dp <addr>
• !handle
• !handle <handle> <mask>
• .dumpdebug
• !uniqstack
• !findstack <text>

Make sure you watch Defrag Tools Episode #1 and Defrag Tools Episode #23 for instructions on how to get the Debugging Tools for Windows and how to set the required environment variables for symbol and source code resolution.

Resources:
Synchronization Functions
Sysinternals WinObj

Timeline:
[00:00] - Event objects
[03:56] - Waitable objects and Design Patterns
[08:00] - Handles
[10:52] - x64/x86/ARM calling conventions and 32/64bit addressing
[14:10] - WaitForSingleObject with a single Auto-Reset Event
[14:55] - !handle
[16:02] - .dumpdebug -- MiniDumpWithHandleData
[16:36] - !handle <handle> <mask>
[19:48] - Sysinternals WinObj
[24:14] - WaitForMultipleObjects with multiple Thread Handles
[30:00] - Work and Quit Event Design Pattern
[33:45] - WaitForMultipleObjects with multiple Event Handles
[38:52] - Windows Explorer example
[44:50] - Process Explorer also shows Handles (Ctrl-H)

This installment goes over the commands used to diagnose a Critical Section hang in a user mode application. We start with an overview of the four synchronization primitives and then delve deep in to temporary hangs, orphaned Critical Sections and deadlocks. We use these commands:

• ~*k
• ~*kv
• ~
• ~~[TID]s
• !cs
• !cs <pointer>
• !locks

Make sure you watch Defrag Tools Episode #1 and Defrag Tools Episode #23 for instructions on how to get the Debugging Tools for Windows and how to set the required environment variables for symbols and source code resolution.

Resources:
Critical Section Objects

Timeline:
[01:00] - Hang types - CPU Looping, Temporary Hangs and Permanent Hangs
[02:00] - Synchronization Objects - Event, Semaphore, Mutex, Critical Section
[06:54] - Critical Sections
[11:45] - Debugging a Hang
[28:08] - Debugging an Orphan
[32:40] - Debugging a Deadlock

Resources:
Windows Software Development Kit (SDK) for Windows 8
Sysinternals
USB3 Debugging Cable
- Note, you must use a USB3 A-A cable designed for debugging, otherwise it will fry your box!

Timeline:
[00:00] - Table tablets and 4K screens at CES 2013
[02:30] - Time to upgrade our tools to the Windows 8\Windows RT versions!
[03:20] - www.sysinternals.com
[05:34] - Win7SP1 and Win8RTM folders
[06:16] - Bing: "Windows 8 SDK"
[06:53] - Bing: "Debugging Tools for Windows"
[07:25] - New web installer does installation or download.
[10:02] - MSI files are in the ..\Windows Kits\8.0\StandaloneSDK\Installers
[13:00] - Sync your 'My' folder with SkyDrive so it is always available!
[13:30] - Install the Debugging Tools for Windows to gather the files for xcopy deployment
[15:33] - Visual Studio 2012 builds PDBs with Inline Frame information
[17:23] - Visual Studio 2012 builds PDBs with Local Variable information
[18:55] - Windows 8 supports Network and USB3 kernel debugging
[21:10] - Visual Studio 2012 now supports both the VS and DbgEng debugger engines
[21:40] - Keep posting questions and sending email to defragtools@microsoft.com!

CES 2013:
Microsoft PixelSense
The Hobbit - Production Diary #4 - Film shot at 5K 48fps 3D

This installment goes over the commands used to show the state of debug session. It also shows some of the basic commands used to view process and thread information of a user mode process. We cover these commands:

• version
• vertarget
• |
• ||
• .sympath
• .srcpath
• .exepath
• .extpath
• .chain
• !analyze -v
• .bugcheck
• !error
• ~
• ~NNs
• ~~[TID]s
• ~*k
• ~*r
• !process 0 17
• !threads
• !findstack
• !uniqstack
• !peb
• !teb
• k= <addr> <addr> <frames>
• dps
• dpu
• dpa
• dpp
• .reload /f
• .reload /user
• !gle
• !tls

Make sure you watch Defrag Tools Episode #1 for instructions on how to get the Debugging Tools for Windows and how to set the required environment variables for symbols and source code resolution.

Resources:
Microsoft Windows SDK for Windows 7 and .NET Framework 4
System Error Codes

Timeline:
[01:01] - Live Debug of Notepad
[02:14] - Overview of the debug session (version)
[03:10] - OS Version/Architecture and System/Debug/User/Kernel times (vertarget)
[09:03] - Process and System Status (| {pipe}, || {double pipe})
[10:16] - Symbol Path (.sympath)
[10:52] - Source Path (.srcpath)
[11:00] - Executable Path (.exepath, lmvm - Memory Mapped Image File)
[11:40] - Extension Path (.extpath)
[12:20] - Loaded Extensions (.chain)
[13:43] - !analyze is for both User and Kernel crashes (!analyze -v)
[14:56] - Bugcheck code and arguments (.bugcheck)
[15:26] - Error Code Lookup (!error)
[16:04] - Threads in a User Process (~ {tilde})
[17:33] - Change Current Thread Context (~NNs) 
[20:13] - Show all the call stacks or registers (~*k, ~*r)
[21:04] - Change Current Thread Context by TID (~~[TID]s) 
[24:18] - Show all the call stacks in all the processes in a kernel session (!process 0 17)
[25:29] - Configuration summary of all thread (!threads)
[26:54] - Find call stack (!findstack)
[27:35] - Unique call stacks (!uniqstack)
[28:30] - Process Environment Block (!peb)
[30:50] - Thread Environment Block (!teb)
[32:02] - Buffer Overflow of a stack variable
[33:11] - Call Stack Recreation (k= <addr> <addr> <frames> {x64})
[34:40] - Display Pointers as a Symbol, Unicode, ANSI or Pointer (dps, dpu, dpa, dpp)
[37:40] - Force the loading of symbols (.reload /f)
[38:43] - Force the loading of user symbols in the kernel when you change thread context (.reload /user)
Note: /u is for unload, not load user symbols - that's why Chad is the kernel guy!
[39:18] - SetLastError/GetLastError value in the TEB (!gle)
[40:14] - Thread Local Storage values in the TEB (!tls)

This episode demonstrates a couple ways to accomplish this basic - but very important - task. I probably should have covered this much earlier on, but better late than never (hopefully).

.NET Debugging for the Production Environment, Part 8

.NET Debugging for the Production Environment, Part 10

In this episode, we'll discuss the different types of CLR threads (.e.g., GC thread, finalizer, etc.) and give a walkthrough of how you can identify each one in a dump file.  Knowing this information can aid in your effort to find root cause - as well as avoid inaccurate reasons - for various application issues.

.NET Debugging for the Production Environment, Part 7

.NET Debugging for the Production Environment, Part 9

Ever have a situation in which your load test isn't passing the SLA, or the test results simply "look wrong"?  Even when your test hardware is exactly like your production hardware?  Is the problem somewhere in the code or... maybe something no one else has considered?  How do you troubleshoot this when - like in the production environment - you can't afford to have invasive troubleshooting tools in place?

.NET Debugging for the Production Environment, Part 6

.NET Debugging for the Production Environment, Part 8

This episode is the last of a trio which introduces viewers to the topic of troubleshooting memory pressure issues.  This session uses information from the previous two episodes to find root cause (i.e., down to the source code) of our memory pressure problem.

Get your debugging hats on before viewing this one!

.NET Debugging for the Production Environment, Part 11

This episode is the second of three which introduces viewers to the topic of troubleshooting memory pressure issues.  In the previous episode, we took a high level overview of virtual memory as it relates to troubleshooting these common memory pressure issues.  We'll use information from that episode and apply it here as we begin investigation of a dump file from a process exhibiting memory pressure.  Using windbg and some debugging extensions, we'll see how much we can learn about the source of the memory problem from a single dump file.

.NET Debugging for the Production Environment, Part 10

.NET Debugging for the Production Environment, Part 12

This episode is the first of three dedicated to troubleshooting memory pressure issues in .NET applications (the kind of troubleshooting Microsoft Support performs in the production environment).  But before we jump straight into the aspects of troubleshooting, it's best to get a good understanding of virtual memory.  Without this background, many of your troubleshooting efforts may lead to dead ends or - even worse - false conclusions.

.NET Debugging for the Production Environment, Part 9

.NET Debugging for the Production Environment, Part 11

This screencast assumes knowledge of the C++ AMP API, e.g. that you totally understand the matrix multiplication implementation in C++ AMP. So if you satisfy that prerequisite, watch this screencast on what features are available in Visual Studio 2012 for debugging C++ AMP code.

To learn more please visit the C++ AMP blog, and we encourage C++ AMP questions in the Parallel Computing in C++ and Native Code MSDN forum.