Channel 9 - Entries tagged with Performance

Defrag Tools: #40 - WPT - WPR & WPA

Larry Larsen, Andrew Richards, Chad Beeder — Mon, 13 May 2013 15:20:42 GMT

In this episode of Defrag Tools, Andrew Richards, Chad Beeder and Larry Larsen continue walking you through the Windows Performance Toolkit (WPT).

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!

Defrag Tools: #39 - Windows Performance Toolkit

Larry Larsen, Andrew Richards, Chad Beeder — Mon, 06 May 2013 18:00:45 GMT

In this episode of Defrag Tools, Andrew Richards, Chad Beeder and Larry Larsen starting walking you through the Windows Performance Toolkit (WPT).

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!

TechNet Radio: Cloud Innovators – Monitor Your Applications with Foglight for Windows Azure Applications

ChrisCaldwell, TechNet Radio, Kevin Remde — Thu, 07 Mar 2013 12:00:15 GMT

Like what you heard? Try Windows Azure for FREE and enjoy the freedom to use your preferred OS, language, database or tool. Windows Azure can help you deploy sites to a highly scalable environment, deploy and run virtual machines, and create highly scalable application in a rich PaaS environment. Give it a try!

_________________

Abstract:
Kevin Remde, welcomes Douglas Chrystall, Chief Architect at Dell Software to the show as they discuss Foglight for Windows Azure applications – a new product offering from Dell which helps monitor applications built on the Azure platform. Tune in as they chat about this solution which can provide diagnostics and improve your applications performance quality.

If you're interested in learning more about the products or solutions discussed in this episode, click on any of the below links for free, in-depth information:

Resources:

Websites & Blogs:

Videos:

Virtual Labs:

MSDN Virtual Labs: Windows Azure

Follow @technetradio
Become a Fan @ facebook.com/MicrosoftTechNetRadio
Subscribe to our podcast via iTunes, Stitcher, or RSS

Inside Windows 8: Prashant Ratanchandani - Telemetry and Performance

Charles — Mon, 21 Jan 2013 20:37:16 GMT

A great deal of data is collected during the alpha and beta phases (aka the Developer Preview and the Customer Preview) of Windows. As with Windows 7, Windows 8 performance telemetry is invaluable for identifying performance bottlenecks and bugs in Windows running in the real world.

There are sophisticated performance and reliability measurement systems inside Windows. PerfTrack is one of these and is instrumental for providing Windows team engineers with highly detailed performance data (how long an app took to launch, how long an app took to shutdown, how long it took Windows to standby, to resume, etc...). Here, we meet Prashant Ratanchandani, one of the developers who works tirelessly to build/fine tune telemetric measurement algorithms for Windows client (you can imagine there is an equally robust performance telemetry system in Windows 8 Server) and to analyze performance telemetry.

Tutorial 14 - Investigating Wall Clock Responce Time in ASP.NET Scenarios

Vance Morrison — Thu, 29 Nov 2012 14:27:33 GMT

This video is about doing a wall clock time investigation of ASP.NET scenarios using the PerfView tool. It is best to watch the video using one of the high quality links on the right so the text is readable. If you have not already watched the video on wall clock time basics, you should do that first (as well as the even more fundamental videos it will refer you to). You may also be interested in the video on wall clock time for parallel/async programs.

As explained video on the basics wall clock time investigations, the key to doing such an investigation is focusing in on a 'critical path' of interest. For ASP.NET scenarios the most obvious such path is the time it takes to respond to any particular request. PerfView supports this idea by creating the 'ASP.NET Thread Time view', by identifying the snippets of time on individual threads that represent work to respond to the request, and associating this cost to a particular request (and further grouping requests by URL. This allows you to quickly segregate 'uninteresting' time where threads are simply waiting for work from the 'important' time when it is on the critical path to respond to a request. The result that it is very straightforward to drill into performance problems on any particular request.

There is a companion perfView blog entries that you may be interested in. In particular there is a ZIP file of source code and data used in this tutorial, so that you can explore this data and 'follow along' yourself with what was done in this video. To use the zip file simply open it, and drag the directory inside to your desktop (or other location). The file contains an HelloWorld.ASPX file (the source code, just view in notepad) as well as the AspNetHelloWorld.ETL.ZIP file (The data file used in this video) You don't need to unzip this file, simply open it in PerfView.

You may be interested in the entire PerfView Tutorial video series,

Tutorial 13 - Leveraging Tasks make sense of Parallel/Asynchronous programs

Vance Morrison — Thu, 29 Nov 2012 14:26:50 GMT

This is the second of a set of video tutorials on how to do wall clock time investigations with PerfView. It is best to watch the video using one of the high quality links on the right so the text is readable. If you have not already watched the video on wall clock time basics, you should do that first (as well as the even more fundamental videos it will refer you to).

In the first video the demo was the simplest case, a sequential program with both disk and CPU time. In this video we discuss the more complex case when there are several threads doing concurrent activity that you wish to analyze.

The key PerfView feature that helps in cases like these is the 'Thread Time (with Tasks)', but only works if you use the System.Diagnostics.Threading.Tasks.Task class to spawn the concurrent activities. In this view if one Task spawns another, the time associated with the subtask is attributed to the point at which the new Task was created. Thus even though the work might be done on another thread, the cost is 'rolled up' based on the code that requested that that action be done. This allows concurrent applications to be analyzed like the simple sequential case (where the cost of calling a routine is attributed to the routine that called it).

There is a companion perfView blog entries that you may be interested in. In particular there is a ZIP file of source code and data used in this tutorial, so that you can explore this data and 'follow along' yourself with what was done in this video. To use the zip file simply open it, and drag the directory inside to your desktop (or other location). The file contains the EXE and PDB (symbol file), the complete VS2012 source (in the src directory) as well as the BlockedTimeParallel.ETL.ZIP file (The data file used in this video) You don't need to unzip this file, simply open it in PerfView.

You may be interested in the entire PerfView Tutorial video series,

Tutorial 12 - Wall Clock Time Investigation Basics

Vance Morrison — Mon, 26 Nov 2012 19:42:19 GMT

This is the first of a set of video tutorials on how to do wall clock time investigations with PerfView. It is best to watch the video using one of the high quality links on the right so the text is readable. Wall clock time is often the most interesting metric because it is the time that the end user sees your app taking. Unfortunately wall clock time investigations are more complex because frankly there are more 'players' (disk and network as well as CPU, page faulting, waiting on threads and processes, concurrent activity and resource contention). Thus it does requires more thought and care on your part perform a blocked time investigation.

In this tutorial we take the simplest case (a sequential program that scans the file system, which requires both CPU and DISK), to cover the basics of wall clock time investigation. This tutorial assumes you have already seen the video on CPU analysis as well as the videos on resolving symbols and using the stack viewer. Frankly taking a quick tour of the whole PerfView Tutorial Series, would not hurt.

There is a companion perfView blog entries that you may be interested in. In particular there is a ZIP file of source code and data used in this tutorial, so that you can explore this data and 'follow along' yourself with what was done in this video. To use the zip file simply open it, and drag the directory inside to your desktop (or other location). The file contains the EXE and PDB (symbol file), the complete VS2012 source (in the src directory) as well as the BlockedTimeSync.ETL.ZIP file (The data file used in this video) You don't need to unzip this file, simply open it in PerfView.

Other videos on wall clock time analysis include

Leveraging Tasks make sense of Parallel/Asynchronous programs
Investigating Wall Clock Response Time of ASP.NET scenarios which I talk about in this blog entry.

.NET 4.5 - Multicore JIT

Charles — Thu, 18 Oct 2012 13:00:00 GMT

Multicore JIT is a .NET 4.5 compiler technology that uses parallelization to reduce the JIT compilation time during application startup.

Multicore JIT team says:

"With Multicore JIT, methods are compiled on two cores in parallel. The more code you execute on your startup path, the more effective Multicore JIT will be at reducing startup time. Improvements of 20%-50% are very typical, which is great news to anyone developing medium to large .NET Framework applications that are not able to take advantage of NGen. You can improve the startup time of your application by up to 50% with very little work, even if it runs off of a USB stick."

Who better to explain this than .NET Performance Architect Vance Morrison and Multicore JIT program manager Dan Taylor? They are joined by software engineer Rick Brewster from the Windows team to discuss how this technology works and why it matters. Rick works on a large .NET Windows desktop application and Multicore JIT has clearly sped up his app's startup time. We'll get the inside scoop from both those who designed the technology and those who use it in production.

Tutorial 11 - Investigating .NET Heap Memory Leaks :Part2 Analyzing the data

Vance Morrison — Thu, 13 Sep 2012 14:21:44 GMT

This video is the second in a two-part video on investigating a GC memory 'leak'. This video discusses a real world memory leak that was found and corrected in PerfView itself. If you have not watched part one, you should do so now. This second part assumes that we have taken two heap snapshots and now wish to investigate the differences between the two snapshots. We show how to do a diff, and explain the theory (negating the sample of the baseline), and how trivial it is to find what 'path of referneces' are keeping the objects alive.

Armed with this information we disover that some of growth is 'by design' (it is part of a useful cache), however some of the growh is an unfortunate side effect of other caching. We discuss how we fixed this problem and then validated that the fix actually worked.

Aftet watching this if you have not already done so, you should watch the video on GC Memory Investigation Basics. You may also be interested in the whole PerfView Tutorial Series.

Tutorial 10 - Investigating .NET Heap Memory Leaks :Part1 Collecting the data

Vance Morrison — Thu, 13 Sep 2012 14:21:32 GMT

This video is the first in a two-part video on investigating a GC memory 'leak'. This video discusses a real world memory leak that was found and corrected in PerfView itself. This first part discusses how you likely found the leak (by observing memory growth using TaskManager or a simmiar utility), and that some care is needed because not all memory growth is a leadk. The hallmark of a leak is unbounded growth when repeating an operation.

Also discussed is the the basic theory of taking two snapshots, one as a baseline, and another after doing an operation that should return the application to the same memory configuration.

Aftet watching this you should watch part two of this video. If you have not already done so, you should watch the video on GC Memory Investigation Basics. You may also be interested in the whole PerfView Tutorial Series.

PerfView Tutorial 9 - .NET Memory Investigation: Basics of GC Heap Snapshots

Vance Morrison — Thu, 13 Sep 2012 14:21:11 GMT

This video describes the basic information you need to start a NET memory investigation and in particular understand the data shown you in a .NET GC snapshot.

The first step in doing .NET Memory investigation is first determine whether .NET Memory is your problem and take a heap snapshot. This tutorial shows you how to determine how much of your process's memory is GC heap and (if that is your problem) shows you how to take a snapshot of the GC heap. For large GC heaps, PerfView does not dump every object, but instead samples the heap (but goes to great lengths to insure that sample is representative). This video describes this sampling and how to learn more about it.

After watching this video you should follow up with the tutorial on investigating heap minemory leaks with PerfView. You may also be interested in the whole PerfView Tutorial Series.

PerfView Tutorial 8 - Generating Your Own Events with EventSources

Vance Morrison — Sun, 19 Aug 2012 01:12:46 GMT

It may be that the ASP.NET events discussed in the previous video are diagnosting the performance of you service. However it not (or you are not using ASP.NET), you will want to log your own ETW events. This video shows you
how easy it is to do this from C# by using a V4.5 Runtime class called System.Diagnostics.Tracing.EventSource (there is also a stand alone version for V3.5 or V4.0 runtimes). The video goes through the process end-to-end from
creating the C# method to do the logging, through activating the logging using PerfView, and finally displaying the events in PerfView's 'events' view.

It is best to watch the video using one of the high quality links on the right so the text is readable.

See the companion blog entry for the demo code and stand alone EventSource DLL. You may also be interested in the whole PerfView Tutorial Series, as well as performance related material at Vance Morrison's Performance Blog.

PerfView Tutorial 7 - Using the Event Viewer in ASP.NET Scenarios

Vance Morrison — Sun, 19 Aug 2012 01:12:31 GMT

In the previous video learned the basics of using the event viewer. In this video we use that knowledge in a common scenario: investigating the performance of an ASP.NET server scenario. The video discusses the ASP.NET ETW events as well important fields like the 'ContextID' field that let you quickly home in on the processing that is related to a single event. This is VERY helpful in understanding performance regressions and sporatic peformance degrades.

It is best to watch the video using one of the high quality links on the right so the text is readable.

The next video is on showing you how to insert your own events int the ETW stream. You may also be interested in the whole PerfView Tutorial Series, as well as performance related material at Vance Morrison's Performance Blog.

Perfview Tutorial 6 - The Event Viewer Basics

Vance Morrison — Sun, 19 Aug 2012 01:11:54 GMT

In the first tutorial we used the 'Run' command to caputure data while an executable ran. In tutorial 2-5 we learned how to use the StackViewer to do a CPU investigation. In this tutorial we learn more about a very different view called the EventViewer that allows you to look at ALL the data in each event that is logged in cronological order. This view is especially useful for finding 'when things happen' as well as see useful side information (like process command lines, and the version of all the DLLs in use). We show how to filter by event name, process, time range and event text as well as show to display only the columns that you are interested in.

It is best to watch the video using one of the high quality links on the right so the text is readable.

The next video is on applying the Event viewer to investigating an ASP.NET scenario. You may also be interested in the whole PerfView Tutorial Series, as well as performance related material at Vance Morrison's Performance Blog.

PerfView Tutorial 1.1 Data Collection for Server Scenarios

Vance Morrison — Tue, 07 Aug 2012 15:30:29 GMT

In the first tutorial we used the 'Run' command to caputure data while an executable ran. However for server scenarios you simply want to explicitly state when to start and stop data collection. It is also likely that you will need to ask someone else (e.g. operations staff) to collect the data for you and send the data for 'offline' analysis. This video shows you the support PerfView has for these server style scenarios.

It is best to watch the video using one of the high quality links on the right so the text is readable.

You may also be interested in the whole PerfView Tutorial Series.

PerfView Tutorial 5 - The Drilling Into Feature

Vance Morrison — Mon, 06 Aug 2012 19:09:11 GMT

This is the fifth in a series of video tutorials on how to use the PerfView profiling tool. It is best to watch the video using one of the high quality links on the right so the text is readable. This tutoral is on PerfView's 'Drill Into' feature, which allows you to selectively ungroup a set of samples in isolation, so you can understand just that part in more detail. You may wish to also to to the first tutorial on data collection or the second tutoral on data analysis if you have not already done so.

The PerfView tool is a free Windows performance tool developed by the Microsoft .NET Runtime Performance team for investigating both managed can unmanaged performance problems. If you are having a performance problem, especially if it is a .NET application, it is hard to overestimate the value of this tool.

You can get the PerfView tool (for free) at the Microsoft Download center. (bing search on 'PerfView download'). PerfView consists of a single XCOPYable EXE so it is easy to simply 'try out'. You can literally open the .ZIP file, and double click on the .EXE inside to launch it and then follow along with the video tutorial. Ultimately you will want to copy this file out of the ZIP file (e.g. drag it to the desktop) to make it easier to launch.

Vance Morrison: Performance and PerfView

Charles — Wed, 01 Aug 2012 13:00:00 GMT

Visual Studio performance architect Vance Morrison is very passionate about, well, performance. He deeply cares about making it easier for you to write fast code - both through education and finding/fixing bugs in the system that prevents your code from being as fast as it can be. Of course, most of the work here is yours - the code you write is the code you write and if you are doing things that negatively impact the performance of your executing application, then you need to fix them. Now, this is harder than it sounds. In many cases, these bad things are hard to spot and hard to reason about up front. You need help. You need tools. You need analysis. You need Vance!

Fortunately, you can get Vance by proxy: a free tool called PerfView. (By now, you must have noticed Vance's screencast series on C9 that walks you through how to use PerfView. It's a series that will grow over time, so keep an eye on it.)

Michael Fortin: Getting More Done in Less Time

Charles — Mon, 30 Jul 2012 16:00:00 GMT

It seems as though all of us are actively trying to cram more and more features, functionality, and speed out of everything we use. While the world seems faster paced today than it ever has been in the past, the quest for performance and efficiency is as old as recorded history, and almost certainly beyond. Getting more done, in less time has always been a component driving human ingenuity. Today's guest doesn't just understand how to improve system performance, he and his teams have revolutionized the tools and methodologies we use to do it.

Michael Fortin began his Career at Microsoft in 1997, where he worked on Windows 2000 doing development on tools to aid in improving system and application performance. Later, as a performance analyst, he took a more active role in overall systems performance and fundamentals.

Robert Hess moderates this edition of Behind the Code.

PerfVIew Tutorial 4 - Grouping And Folding

Vance Morrison — Tue, 17 Jul 2012 17:07:59 GMT

This is the fourth in a series of video tutorials on how to use the PerfView profiling tool. It is best to watch the video using one of the high quality links on the right so the text is readable. This tutoral is on PerfView's grouping and folding operators, which are essential to finding the semantically meaninful operation (the forest) in the mounds of data collected (the trees). You may wish to also to to the first tutorial on data collection or the second tutoral on data analysis if you have not already done so. The next tutorial is on the 'Drill-Into' feature that lets you isolate and zoom into a performance issue.

PerfView Tutorial 3 - Resolving Symbols

Vance Morrison — Tue, 17 Jul 2012 17:07:33 GMT

This is the third in a series of video tutorials on how to use the PerfView profiling tool. It is best to watch the video using one of the high quality links on the right so the text is readable. A big part of an effective performance investigation is getting symbolic information (method names) for the parts of the program that are of interest to you. This tutorial describes what you need to know to insure getting this information is not a stumbling block. You may wish to also to to the first tutorial on data collection or the second tutoral on data analysis if you have not already done so. The next tutorial is on the powerful grouping and folding operations PerfView supplies.

PerfView Tutorial 2 - A Simple CPU Performance Investigation

Vance Morrison — Tue, 17 Jul 2012 17:07:17 GMT

This is the second of a series of video tutorials on how to use the PerfView profiling tool. This tutorial assumes you have watch the first tutorial on collecting data. It is best to watch the video using one of the high quality links on the right so the text is readable. The next tutoral will discuss the important topic of symbol resolution.

PerfView Tutorial 1 - Collecting data with the Run command

Vance Morrison — Tue, 17 Jul 2012 15:22:16 GMT

This is the first of a series of video tutorials on how to use the PerfView profiling tool to gather data for a CPU performance data on a simple .NET program. It is best to watch the video using one of the high quality links on the right so the text is readable.

If you don't have PerfView already see tutorial 0: Getting PerfView to see just how easy it is to get it. After watching this eee the next tutoral for how to analyze this data or browse the whole series.

PerfView Tutorial 0 - Getting PerfView

Vance Morrison — Tue, 17 Jul 2012 14:22:16 GMT

If you have an internet connection you are just a few clicks away from installing perfView. This video shows you just how easy it is. It is best to watch the video using one of the high quality links on the right so the text is readable. After downloading PerfView start with Tutorial 1: Collecting Data.

This video assumes that you have .NET V4.0 installed. If you run windows update, this is almost certainly the case as windows update does auto-install it. It also assumes you are running on at least Windows Vista (e.g. Windows 7) or at least Windows 2K8.

You may also be interested in the whole PerfView Tutorial Series.

.NET 4.5 in Practice: Bing

Charles — Mon, 25 Jun 2012 08:58:46 GMT

.NET GC developer Maoni Stephens, Performance Architect Vance Morrison and Bing front end developer Mukul Sabharwal join us for a conversation about .NET 4.5 in practice.

We spent some time with the.NET 4.5 team earlier in the year. You can see the series of conversational interviews we did here.

The Bing front end is powered by .NET 4.5 and Windows Server 2012 RC. This constitutes a large number of servers doing a lot of work. How do some of the new .NET 4.5 features (like multi-core JIT and background GC) scale? Bing's a rather good test case for both .NET 4.5 and WS 2012 given the volume of requests it serves.

Topics include:

Pinning and Heap Corruption (and strategies for alternative approaches to pinning).

Multicore JIT

Performance tuning and PerfView

Background GC

As usual, this is conversation that happened as it did. There will be a few random turns, but roads lead to time well spent! Thanks for being sports, Maoni, Vance and Mukul!

Tune in. Enjoy

Internet Explorer 10 Test Drive on Windows 8 Release Preview

Tobin Titus, Internet Explorer Team — Thu, 31 May 2012 22:44:54 GMT

In this video, we take a look at the Internet Explorer 10 on the Windows 8 Release Preview and the improvements made in performance, touch-first experiences, and HTML5 standards-based adaptive layouts.

We explore three new demos available on IETestDrive.com today. The first demo, Chalkboard Benchmark, takes a look at the hardware-accelerated performance of Internet Explorer 10 with common touch actions such as panning, zooming and scaling content. Our next demo, Browser Surface, takes design cues from Microsoft Surface. This demo focuses on the touch-first experiences that are enabled using standards-based design and the new MSGesture API. Lastly, the Layout Adaptation demo shows the power of using Media Queries and Viewport to create layouts that adapt to your device and the size of your browser.

With this latest platform preview, IE10 continues to deliver the foundational features and performance that developers depend on to build great applications. You can download the Windows 8 Release Preview today, then try these demos and more at http://ietestdrive.com.

— Tobin Titus, Program Manager, Internet Explorer Performance