В один из смежных с DotNext 2018 Piter дней мы планируем провести отдельный performance-тренинг Саши Гольдштейна на целый день. Тренинги будут проходить на английском языке. Ориентировочная стоимость тренинга: 15-20 тысяч рублей.

Помогите нам понять, какую (или какие?) из доступных тем выбрать.

*1.Выберите один тренинг, на который вы бы пошли:(Обязательный)

SENIOR LEVEL: Production Performance and Troubleshooting of .NET Applications

Modern applications are extremely complex, and with complexity come difficulties in diagnosing performance issues, memory leaks, crashes, and other problems that might manifest only in the production environment. In this workshop, we will review the tools, libraries, and best practices for setting up your production monitoring and diagnostic environment. Through a series of detailed hands-on labs, you will learn how to measure performance in a production environment without interrupting operations, how to automatically diagnose and detect the root cause of crashes and memory leaks, how to identify and display specific objects in memory without suspending or modifying the application code, and how to set up alerts for performance issues.

Topics:
– Requirements for production monitoring and diagnostics
– The USE (Utilization, Saturation, Errors) performance method and checklist
– Continuous performance monitoring using Windows performance counters
– Configuring performance counter alerts
– Event Tracing for Windows and related tools (PerfView, WPR, WPA, etrace)
– Collecting ETW traces on-demand and continuously with memory buffers
– Diagnosing high-CPU and high-memory spikes
– Collecting and comparing heap snapshots for memory leak analysis
– Dump files and dump file types
– Collecting dumps automatically for crashes or extreme leaks
– Basic dump file analysis with Visual Studio and WinDbg
– Automatic dump analysis with the CLRMD library and related tools (msos, PerfView)
– Using CLRMD for live process diagnostics

SENIOR LEVEL: Mastering ETW to make .NET applications faster

Event Tracing for Windows (ETW) has been on the scene for several years, but it is only recently that is has become so popular for performance monitoring in production and development environments. Today, .NET developers can use freely available tools with a minimal performance overhead to monitor their application performance: CPU utilization, blocked threads, memory usage, and garbage collection metrics. In this workshop we will explore the rich world of ETW through free tools such as the Windows Performance Toolkit and PerfView. We will also see how to produce ETW logs from .NET applications, push them to custom ETW sinks (including ElasticSearch and Azure Storage), and monitor ETW data in real-time from .NET code. This workshop includes labs in which you will practice performance measurement and diagnostic techniques.

Topics:
– Challenges in production performance diagnostics
– Traditional profilers vs. Event Tracing for Windows
– ETW roles and components
– Using ETW as a diagnostics log framework with TraceEvent and Semantic Logging Application Block
– Pushing ETW logs to ElasticSearch and other storage engines
– Tools for ETW recording and analysis: WPR, WPA, PerfView, etrace
– Diagnosing high CPU and blocked time issues
– Diagnosing slow I/O, application startup, and system boot issues
– Diagnosing high GC and memory traffic issues
– Diagnosing memory leaks with compact heap snapshots and dump files

SENIOR LEVEL: Making .NET applications faster (code-level workshop with SIMD, GC optimization, unsafe code and more)

.NET is evolving at a rapid pace, making strides into new platforms and environments, and getting new features and enhancements from the community. At the same time, writing fast .NET applications requires significant understanding of the underlying platform and the new features the .NET framework has to offer.

This workshop introduces a set of practical techniques, tools, and libraries for improving .NET application performance on the code level. We will discuss modern processor organization and SIMD instructions, and leverage them with the System.Numerics.Vectors library and the new RyuJIT 64-bit compiler. We will explore garbage collector internals, including the most recent changes, and how to identify and tackle common GC performance issues. We will see where unsafe code can still make sense, and how to measure and improve application startup performance. Throughout the day, you will work on hands-on labs that reinforce the material and leave you with practical examples of how to apply these optimizations to your own products.

MIDDLE LEVEL: Debugging and dump analysis with Visual Studio, WinDbg, and CLRMD

WinDbg, the scary beast born in the dark cellars of the Microsoft Redmond campus, is still an extremely useful diagnostic tool. Mastering WinDbg can help untangle the most complex crashes, memory leaks, hangs, and other issues that mere mortal developers have no chance at attempting. But you don't need to make a deal with the devil to master WinDbg: all it takes is a didactic approach, some patience, and a lot of practice. Besides, WinDbg is becoming more and more user-friendly over the years – if you're the right kind of user, that is – with extensions such as SOSEX and NetExt, and built-in exploration commands such as "dx" introduced in the latest Windows 10 release.

In the first part of the workshop we will explore some of the scenarios where WinDbg truly shines and makes it worthwhile to remember arcane commands and parse head-scratching output such as "This dump file has an exception of interest stored in it". We'll talk about advanced breakpoints and how you can use them to monitor what's going on with your system. We'll talk about heap queries that you can run with NetExt to see individual objects on your heap such as ASP.NET requests, WPF data binding collections, or your own business entities. We'll practice some magic WinDbg script incantations that automate extremely tedious operations like tracing through thread stacks or millions of heap objects. After completing this workshop, you will be a master of WinDbg – to be looked up in awe by all your developer colleagues.

In the second part of the workshop, we will discuss automation scenarios where WinDbg scripting doesn’t quite cut it. For complex programmatic analysis of live processes or dump files, we will use CLRMD – a Microsoft library that provides a friendly C# API on top of the Windows debugging libraries and the SOS debugging interfaces. By using CLRMD, we’ll be able to attach to a live process or a dump file and extract thread information, call stacks, GC heap statistics, individual heap objects, synchronization mechanisms, and so much more.

MIDDLE LEVEL: Profiling and debugging .NET Core applications on Linux

OK, great, you can now run your favorite ASP.NET app or console application on Linux using .NET Core. What happens next? In fact, what happens straight after deployment, when you discover memory leaks, surprising crashes, performance problems, and other woes – in the production environment? The tools and profilers you're used to from Windows don't work on Linux, and a lot of them don't have easy-to-use alternatives.

In this workshop, you will learn the up-to-date tools for profiling and debugging .NET Core apps on Linux. We will begin with `perf`, the Linux performance multi-tool, which can perform CPU sampling, record tracepoint events, and attach to arbitrary functions with dynamic tracing. In the lab, you will profile a CPU-bound application, identify disk access stacks and visualize them using a flame graph, and trace garbage collection events. Then, we will discuss LTTng, which is CoreCLR's tracing facility on Linux, and how to collect LTTng events. In the lab, you will record GC and heap statistics and write some shell one-liners to parse them. Next, we will talk about BPF, a novel kernel technology for low-overhead, high-performance tracing tools. You will use BPF-based tools from the BCC toolkit to perform blocked-time analysis and allocation profiling. Finally, we will discuss Linux core dumps and how to analyze the managed part of the core dump using LLDB and the libsosplugin. In the last lab session, you will analyze a core dump generated in a runtime-only Docker container using another Docker container.

MIDDLE LEVEL: Container internals and troubleshooting tools for .NET developers

Everyone is talking and shipping containers: modern development and deployment tools make it incredibly easy to package a .NET Core application in a container and deploy it to a Linux system running in a cloud, or even to wrap a traditional ASP.NET application in a container and run it on Windows. At the same time, understanding how containers work under the hood on both Linux and Windows, and how to troubleshoot and diagnose issues with containerized applications, is becoming crucially important.

In this workshop, we will explore the internals of Linux and Windows container technologies: cgroups, namespaces, and chroot on Linux; job objects, silos, and object namespaces on Windows. We will monitor container performance and identify situations where the container breaches its assigned resource quotas. Then, we will dive in and use more thorough investigation tools to profile applications running in a container (from within the container, from the host, or from a “sidecar” container); to record low-level events like filesystem and disk accesses; and to troubleshoot “traditional” performance issues with .NET applications such as GC pressure and excessive allocations.

Ни на какой из перечисленных

*2.Оставьте ваш email для связи.
Мы пришлем на него анонс, если мы решим проводить тренинг, выбранный вами.(Обязательный)