Channel 9 - Entries tagged with Kernel

Bruce Worthington: Power Efficiency in Windows 8 and Beyond

Charles — Tue, 29 Jan 2013 21:28:25 GMT

In developing Windows 8, power efficiency was a primary engineering theme. This means that all aspects of the system were designed and developed with efficient power usage in mind. It's paid off—Windows 8 is the most power efficient version of Windows to date.

In this video, Windows Development Lead Bruce Worthington, an OS power and performance expert who leads a team of engineers working on Windows power management fundamentals, sits down with us to share the story of power efficiency in Windows 8. The renewed focus on power has paid off and is evident across the Windows ecosystem—from Windows on tablets, notebooks, hybrids, and desktops to Windows running in the data center.

Huge thanks to Bruce for this excellent conversation!

Tune in.

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.

Inside Windows 8: Chris Stevens - Boot Environment

Charles — Mon, 14 Jan 2013 18:02:53 GMT

Chris Stevens is a software developer on the Windows kernel team working on the Windows boot environment. Windows 8 boots faster than any other version of Windows. Why? How?

Chris begins with the fundamentals (so, if you don't know anything about the boot process or what actually happens when an OS like Windows starts up, then you will after watching this...) and then digs into how the boot experience/environment/process was has evolved in Windows 8.

Tune in!

Inside Windows 8: Jon Berry - Desktop Activity Moderator and Connected Standby

Charles — Mon, 07 Jan 2013 13:55:24 GMT

Jon Berry, a veteran Windows engineer, digs into the new way Windows 8 manages processes to support the brave new world of Windows running on various CPU architectures including ARM and ATOM, which present an interesting set of technical challenges given the need to aggressively preserve energy when running—yet not fully running—while in a battery-powered state.

Jon owns the Desktop Activity Moderator (DAM), which, as the name implies, moderates desktop processes. The DAM is one of several new features in Windows 8 designed to ensure consistent, long battery life for devices that support connected standby.

Connected standby occurs when the device is powered on but the screen is turned off. In this power state, the system is technically always "on" (to support key scenarios like mail, VoIP, social networking, and instant messaging with Windows Store apps). It is analogous to the state a smart phone is in when the user presses the power button.

As such, software (including apps and operating system software) must be well-behaved during connected standby. The DAM was created to suppress desktop app execution in a manner similar to the Sleep state. It does this by suspending or throttling desktop software processes across the system upon connected standby entry. This enables systems that support connected standby to deliver minimized resource usage and long, consistent battery life while enabling Windows Store apps to deliver the connected experiences they promise.

The DAM is a kernel mode driver that is loaded and initialized at system boot if the system supports connected standby.

How does Windows 8 provide this always-on experience and not drain the battery in 10 minutes? What does the DAM actually do? How does it work? The DAM is part of a larger management system, which Jon also describes here. What is connected standby, exactly? Jon spends a lot of time at the whiteboard answering these and other questions. Thank you, Jon!

Tune in. Learn.

Inside Windows 8: Greg Colombo - Heap Manager

Charles — Tue, 18 Dec 2012 18:09:07 GMT

The Windows heap manager has been around as long as Windows has, evolving with each release, getting faster, more reliable, and more secure. In Windows 8, the heap manager improves in two major areas: performance and security. In this video, Greg Colombo, a developer on the Windows kernel team working on the Windows heap manager, digs into the details. What are the changes that positively impact performance and security?

This conversation—conducted entirely at the whiteboard—provides enough introductory information to ensure that even if you have no idea what a heap manager is—or what the heap is, for that matter—you will after you watch this. The complexity in this discussion increases over time, but remains understandable all the way through. Greg is an excellent communicator! Huge thanks to Greg for taking the time to educate us.

Tune in. Learn.

Inside Windows 8: Pedro Teixeira - Thread pools

Charles — Fri, 07 Dec 2012 05:21:14 GMT

Continuing with our series of conversations with engineers in Windows, we meet Pedro Teixeira, a software developer on the Windows kernel team (aka core OS) who has improved the Windows thread pools in Windows 8. Thread pools are thread management subsystems (user mode and kernel mode) where threads are created and queued for any number of arbitrary tasks (work) required by applications and services. As it turns out, there are some significant improvements to the thread pool pattern in Windows 8. Pedro takes the time necessary - at the whiteboard for the entire interview - to dig into the details, beginning with first principles. So, if you don't really know what a thread pool is, then you will after the first 5 minutes of this interview. As the conversation progresses, the complexity will increase, but will remain suitable for most user mode application developers. Speaking of user mode, much of the time in this interview is spent on the Windows 8 user mode thread pool. The kernel mode thread pool is addressed towards the end of the conversation.

In Windows 8, there is a new thread pool model and new thread creation policy. What is the new policy? How is the new user mode thread pool designed? How is it better than its predecessors? What does this all mean for developers?

Tune in. Learn. Huge thanks to Pedro for taking the time to dig in - and for explain things in such a clear way.

Inside Windows 8: Arun Kishan - Windows App Model

Charles — Wed, 21 Nov 2012 20:08:51 GMT

Arun Kishan digs into the low level details of Windows 8's new application model.

How has Process Lifetime Management (PLM) been reimagined in Windows 8? How does app suspension work, exactly, or, what happens when an app is no longer in the foreground and not closed? How much work can you do in the background when an app is suspended? Arun covers several topics here, so please do set aside some quality time. In return, you will gain new levels of deep understanding that will help you take advantage of the Windows Store App platform and build excellent modern Windows applications.

You've met Arun before, so you should be prepared for some very deep treatment of this new world for Windows and Windows developers. This is an excellent 400 level investigation of the core changes that support the new app model.

Huge thanks to Arun for another exceptional conversation and whiteboard session.

Tune in. Learn.

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.

Drawbridge: A new form of virtualization for application sandboxing

Charles — Mon, 17 Oct 2011 17:27:19 GMT

Drawbridge is a research prototype of a new form of virtualization for application sandboxing. Drawbridge combines two core technologies: First, a picoprocess, which is a process-based isolation container with a minimal kernel API surface. Second, a library OS, which is a version of Windows enlightened to run efficiently within a picoprocess. Drawbridge combines two ideas from the literature, the picoprocess and the library OS, to provide a new form of computing, which retains the benefits of secure isolation, persistent compatibility, and execution continuity, but with drastically lower resource overheads.

The Drawbridge library OS is an experimental Windows 7 library OS - a research project and proving ground for a larger concept: application virtualization and sandboxing. Drawbridge is capable of running the latest releases of major Windows applications such as Microsoft Excel, PowerPoint, and Internet Explorer with very little overhead compared to the traditional virtualization techniques. The experiment is going well! Now, what's going on here, exactly?

Drawbridge research team members Galen Hunt, Reuben Olinsky and Jon Howell dig into some of the details, including project rationale and OS architecture, of research project Drawbridge.

Paper: http://research.microsoft.com/apps/pubs/default.aspx?id=141071

Abolade Gbadegesin: Inside Windows Phone "Mango"

Charles — Tue, 05 Jul 2011 16:46:55 GMT

There have been a lot of positive reviews of the upcoming Windows Phone 7 OS release, code named "Mango." This release is a big one. It contains over 500 new features (and over 1000 new APIs), is full of improvements - from the core OS to the performance of UI scrolling - and "Mango" puts the user in control of almost everything the system has to offer.

"Mango" represents some impressive engineering. Since this is Going Deep, we are necessarily interested in the system-level improvements inside the Windows Phone operating system (in addition meeting a key engineer behind it).

Two new core or system-level features in "Mango" are a generational garbage collector and support for multitasking, or the ability to concurrently run application processes in both the foreground and background. GGC and Multitasking are going to be great for developers and users alike.

How does multitasking in "Mango" work? How is it designed? Lot's of great user features, but what about improvements to the developer experience? Let's ask the great Abolade Gbadegesin—a stellar software engineer (writing mostly C++ -> go native!) and key contributor to the Windows Phone operating system, application services, and overall "Mango" platform architecture—to get some real answers.

Tune in.

ICSE 2011: Victor Pankratius - Developing Manycore Applications with Concurrency Auto-Tuners

Charles — Mon, 20 Jun 2011 21:21:02 GMT

Continuing on with our coverage of ICSE 2011, meet Dr. Victor Pankratius. Dr. Pankratius heads the Multicore Software Engineering investigator group at the Karlsruhe Institute of Technology, Germany. He also serves as the elected chairman of the Software Engineering for parallel Systems (SEPARS) international working group. Dr. Pankratius' current research concentrates on how to make parallel programming easier. His work on multicore software engineering covers a range of research topics including empirical studies, auto-tuning, language design, and debugging.

In this video, Wolfram Schulte joins Victor to discuss the challenges of making concurrency easier for developers. One of the really interesting approaches that Victor and team are investigating is concurrency auto-tuning, and the example discussed here involve adding OS kernel-level support for auto-tuning user mode applications for manycore processor architectures. This is very fascinating research with great potential. Concurrency auto-tuner in an OS kernel? Concurrency-enlightened operating systems? Why not? Always great to meet young innovators with no fear of failure. I hope to see this type of thing materialize. Very interesting research and real world problem. Go Victor. Go!

Thanks to Wolfram and Victor for another great conversation. Tune in.

Verve: A Type Safe Operating System

Charles — Tue, 07 Dec 2010 17:01:28 GMT

The Singularity project (an OS written in managed code used for research purposes) has provided several very useful research results and opened new avenues for exploration in operating system design. Recently, MSR released a paper covering an operating system research project that takes a new approach to building an OS stack with verifiable and type safe managed code. This project employs a novel use of Typed Assembly Language, which is what you think it is: Assembly with types (implemented as annotations and verified statically using the verification technology Boogie and the theorem prover Z3(Boogie generates verification conditions that are then statically proven by Z3. Boogie is also a language used to build program verifiers for other languages)). As with Singularity, the C# Bartok compiler is used, but this time it generates TAL. The entire OS stack is verifiably type safe (the Nucleus is essentially the Verve HAL) and all objects are garbage collected. It does not employ the SIP model of process isolation (like Singularity). In this case, again, the entire operating system is type safe and statically proven as such using world-class theorem provers.

Here's the basic idea (from the introduction of the paper):

Typed assembly language (TAL) and Hoare logic can verify the absence of many kinds of errors in low-level code. We use TAL and Hoare logic to achieve highly automated, static verification of the safety of a new operating system called Verve. Our techniques and tools mechanically verify the safety of every assembly language instruction in the operating system, run-time system, drivers, and applications (in fact, every part of the system software except the boot loader). Verve consists of a “Nucleus” that provides primitive access to hardware and memory, a kernel that builds services on top of the Nucleus, and applications that run on top of the kernel.

Here, Microsoft research scientist and operating system expert (he worked on the Singularity project) Chris Hawblitzel sits down with me to discuss the rationale behind the Verve project, the architecture and design of Verve and the Nucleus, Typed Assembly Language (TAL), potential for Verve in the real world, and much more. This is a conversational piece (no demos, no whiteboarding), but if you are into operating research and strategies for building type safe systems at the lowest levels, then this is for you. If you are interested, perhaps we could get Chris into our studio for a lecture or two on OS design.

Niner Richard Hein's question is asked here.

Get the Verve source code here.

Enjoy. Learn.

Mark Russinovich: Windows Azure, Cloud Operating Systems and Platform as a Service

Charles — Thu, 25 Nov 2010 19:30:45 GMT

Mark Russinovich is a Technical Fellow working on the Windows Azure team. His focus is on solving hard problems related to the Fabric Controller, which is in some sense the Windows Azure operating system kernel - it provides services and management infrastructure for the applications that run on Windows Azure.

Before joining the Windows Azure team, Mark worked in the Windows kernel engineering group and, as you probably know, Mark is one of the founders of SysInternals and is the co-author of several extremely useful tools for analyzing, measuring, monitoring and really understanding the things that happen at the lowest levels of the system like memory management, process management, threading, etc... Mark also is the co-author of the best Windows Internals books on the market. Finally, Mark is one of the highest rated speakers at Microsoft technical conferences (you must watch his PDC10 sessions!). Will he still work on Windows Internals series of books now that he is no longer on the Windows team? Is he still deeply engaged in the goings on in Windows kernel world? Is he writing SysInternals tools for Windows Azure? What is the Fabric Controller, exactly? How does it work? What's underneath the Fabric Controller?

Windows Azure is a cloud operating system. What does that mean? What are the Windows-analogous components running inside Windows Azure? What's Mark up to? How does he like the new gig? Why is platform as a service (PaaS) so important? What is PaaS, really? And more.

As usual, this is a turn-the-camera-on-and-converse interview that happened just as you see and hear it. We therefore move from topic to topic in a natural and somewhat unstructured way and yours truly probably had too much coffee before heading to Mark's office

It's always a real pleasure to get to chat with Mark. He has the uncanny ability to simplify complexity so that we can understand the meaning and reasoning behind the technology at hand without possesssing expert level knowledge or being as bright as Mark. He's one of our best and brightest technical minds and Windows Azure is lucky to have him solving hard problems and pushing the Windows Azure kernel(Fabric Controller) envelope.

Tune in.

Landy Wang - Windows Memory Manager

The Channel 9 Team — Wed, 29 Sep 2010 18:24:12 GMT

Charles Torre (interviewer) and Michael Lehman (cameraman) continue the "Going Deep: Windows" series with a discussion with Landy Wang, a developer of the oh so important Windows Memory Manager.

Sorry for the low audio volume.

EDIT November 2, 2008: There is no streaming video for this interview. We will look into it. For now, please clickhere.

Ch9Live at Tech.Ed NA 2010 - Ask Mark Russinovich Anything... LIVE!

Nic Fillingham — Thu, 08 Jul 2010 20:11:00 GMT

Charles Torre sat down with Mark Russinovich at Tech.Ed North America 2010 to answer live questions from the Tweetosphere and studio audience.

Recorded live as part of Channel 9 Live at Tech.Ed North America 2010

Inside Windows 7: Recovering Windows from System Degradation and Boot Failures

Charles — Mon, 30 Nov 2009 18:58:00 GMT

Windows 7 is capable of certain levels of self-repair, as you've learned. One of the new capabilities in Windows is its ability to recover from serious failures that can impact the OS's ability to boot. How does Windows 7 handle these errors? Can you boot Windows 7 into Safe Mode or to an earlier functional state when something really bad happens? Yes. You can, depending on the nature of the problem. How?

Stephan Doll, Pavan Kasturi, Desmond Lee and Baskar Sridharan make up most of the team that has enabled Windows 7 to be the most recoverable version of Windows to date. By ensuring that every Windows 7 machine has the ability to automatically diagnose and recover from most boot failures with little or no interaction from the user, this team's work promises to greatly reduce—or even eliminate—the impact of a serious issue that would otherwise cause significant pain for Windows 7 users.

Tune in.

Mark Russinovich: Inside Windows 7 Redux

Charles — Thu, 22 Oct 2009 16:30:00 GMT

Windows 7 is here, available to all for purchase and ships today with new PCs! To celebrate this momentous occasion for Windows and Microsoft, Technical Fellow Mark Russinovich joins me in a discussion that extends the great conversation we had last year on Windows 7 internals. In his previous C9 interview, Mark told us about many of the new additions to the Windows kernel which enable Windows 7 (and Windows Server R2) to scale to large numbers of processors. Well, removing the kernel dispatcher lock is not all that the great Arun Kishan did. He also developed a new scheduling mechanism known as Distributed Fair Share Scheduling (DFSS). Mark describes what this is and how it works.

We also discuss NUMA, non-uniform memory access, (and Mark explains NUMA to us while showing a demo or two on a 256 processor machine!)

Moving on to Windows memory management, the domain of the great engineer Landy Wang, Mark discusses the new additions to the Windows Memory Manager and explains why they matter to those of us who spend all of our time and in user mode.

Learn about all of this and much more as Mark digs into the insides of Windows 7, way deep down in the system (the culmative effects of which help to make Windows 7 Microsoft's most reliable, scalable and efficient general purpose operating system to date). As usual, Mark explains very complex mechanisms and concepts in a readily understandable way. This is a very conversational piece and we cover a lot of ground in a relatively short period of time. We also learn exactly why Mark is so passionate about operating systems and what the spark was that set off his passion and curiosity of how things work internally.

Mark will be presenting at PDC09 in the Technical Leaders track and the free Windows 7 Developer Boot Camp. His talks will be very deep and will explore all aspects of the new, improved Windows 7 kernel. I highly recommend that you attend both of these talks if you are going to PDC (you're going, right?!).

Check out the Windows area on 9 for more great Windows 7 content, all rolled up into a nice experience!

Enjoy!

Note: Check out all the 9 Guys Mark has. Also, you should subscribe to his incredible blog.

Silviu Calinoiu: Inside Windows 7 - Fault Tolerant Heap

Charles — Tue, 25 Aug 2009 05:35:00 GMT

The Fault Tolerant Heap (FTH) is a subsystem of Windows 7 responsible for monitoring application crashes and autonomously applying mitigations to prevent future crashes on a per application basis. For the vast majority of users, FTH will function with no need for intervention or change on their part.

Principal Development Lead and rock star developer Silviu Calinoiu is the mastermind behind FTH. Here, we go deep into how FTH works and why it's designed the way it is.

The Fault Tolerant Heap is another example of the low level efficiency built into the system: FTH automatically corrects memory faults that cause applications to crash which has the pleasant side effect of preventing future crashes. How does FTH work, exactly? What types of memory problems does it address, specifically? How do developers monitor FTH events and can they override FTH's behavior? What does this all mean to the average user?

FTH, as an autonomous monitoring and correction system, represents a step in the right direction for the evolution of a more homeostatic general purpose operating system. Simply, Windows is getting smarter in the sense that it's increasingly becoming better at self-regulation and self-healing. Yes, there's a very long way to go, but we're making real progress.

You will continue to learn about recoverability in Windows over the coming months here on C9.

Tune in.

Arun Kishan: Inside Windows 7 - Farewell to the Windows Kernel Dispatcher Lock

Charles — Thu, 06 Aug 2009 17:28:00 GMT

You've learned about many of the new features of the latest version of the Windows kernel in the Mark Russinovich Inside Windows 7 conversation here on Channel 9. One of Mark’s favorite kernel innovations is the way the Windows 7 kernel manages scheduling of threads and the underlying synchronization primitives that embody kernel thread management.

Prior to Windows 7 (and therefore Windows Server 2008 R2) the Windows kernel dispatcher employed a single lock, the dispatcher lock, which worked well for a relatively small numbers of processors (like 64). However, now that we find ourselves in the midst of the ManyCore era, well, 64 processors aren’t that many... A new strategy was required to scale Windows to large numbers of processors since a single lock is limited in capability, by design: The masterful David Cutler, one of the world's greatest software engineers, wrote the NT scheduler in a time when the notion of affordable 256-processor machines was more science fiction than probable.

As we learned in the Mark Russinovich video, Windows 7 can now scale to 256 processors thanks to the great engineering of Arun Kishan, a kernel architect you've met on C9 back in the Vista days. In order to promote further scalability of the NT kernel, Arun completely eliminated the dispatcher lock and replaced it with a much finer grained set of synchronization primitives. Gone are the days of contention for a single spinlock. How did Arun pull this off, exactly, you ask? Who is this genius? Well, tune in. Lots of answers await…

Arun's work directly benefits the overall performance of Windows running on many processors and means, simply, Windows can now really scale. Thank you, Arun!

Spinlocks are synchronization primitives that cause a processor to busy-wait until the state of the lock’s memory location changes.

As the name implies, the dispatcher lock is the fundamental lock associated with the kernel dispatcher, or the scheduler.

Michael Fortin: Windows 7 Efficiency

Charles — Wed, 22 Jul 2009 20:42:00 GMT

The Windows 7 project involved very efficient software engineering planning and execution. It is no surprise that an equivalent level of efficiency exists throughout the OS (efficiency in how the OS deals with faults, threads, memory management, power management, process management, window management, graphics, audio, local search, diagnostics, and on and on - truly excellent, and efficient, engineering).

Michael Fortin is a Distinguished Engineer in the Windows Core Operating System Division. His team builds the technologies that help make Windows 7 reliable, stable and performant, which are core ingredients in any highly efficient general purpose operating system. You'll hear us talk about Windows 7 as a very efficient general purpose operating system quite a bit over the coming months. In fact, if I had to sum up Windows 7 in one word it would be Efficient.

Michael's team also builds the troubleshooting and diagnostics systems in Windows, including the internal mechanisms that construct fault data packages and sends them to cloud-based components which receive data from millions of clients running Windows 7. Michael's team is a global team - engineers are located in multiple places around the world including a stellar team of engineers located in Beijing, China (you'll meet them in the future right here on C9).

You may remember Michael from his last interview on Channel 9 that covered his work on Vista's SuperFetch and ReadyBoost technologies. Yep, these great technologies are alive and well in Windows 7 and have evolved to meet the needs of the evolving system and help add to the overall efficiency of Windows. (There, I wrote "efficiency" again...)

Over the past year or so, Michael's team has received, analyzed and acted upon a very large amount of data sent from Windows 7 Beta and RC running on a variety of PCs with a variety of hardware and software configurations in place. This data was used to construct new system features, like the Fault Tolerant Heap, and to engineer updates to existing mechanisms to make them more robust or performant or reliable or stable... You will meet some of his team here on C9 in the future and we will dig into many of the mechanisms Michael touched on in this conversation (Fault Tolerant Heap, Troubleshooting and Diagnostics, etc).

Here, Michael and I chat about the work his team has done, the engineering philosophy that has driven efficiency into Windows at all levels (from the kernel to the shell), the knowledge his team has gained about how Windows is used in the wild, what the most common problems have been and the solutions that are based on this important telemetry data. So, for all of you out there who chose to send fault data from your PC to Microsoft - THANK YOU. You truly have helped, in a fundamental way, to make Windows 7 the most efficient general purpose operating system from Microsoft to date. Yeah. True story.

Enjoy.

Mark Russinovich and David Solomon: Windows Internals 5 Released

Charles — Fri, 19 Jun 2009 16:01:00 GMT

Windows kernel expert and kernel "professor" David Solomon and Windows Kernel Technical Fellow Mark Russinovich have written another great book covering, in great detail, the internal composition of Windows Vista and Windows Server 2008. A third author,Alex Ionescu, joined the fray this time around. Together, they've just released Windows Internals Fifth Edition. My order has been submitted! If you want to really understand the mechanics of Windows' latest generation general purpose kernel, then go get this book.

David was in Redmond recently conducting deep training on the Windows 7 kernel, which contains 95% of the same ingredients as the Windows Vista kernel. So, of course we had to get the dynamic duo together to talk about their book, the Windows kernel, their history (they've been working together for a long time) and their future.

Enjoy! Happy reading.

Mark Russinovich: Pushing the Limits of Windows - Paged and Nonpaged Pool

Charles — Thu, 02 Apr 2009 22:39:00 GMT

Paged and Nonpaged Pool.

Mark's posts are stellar. The detail, the clarity, the usefulness. Definitely one of my favorite technical Windows-related blogs. The post I linked to specifically is incredibly interesting given that it details a rare, but very painful problem and in process teaches us about some fundamental properties of the Windows kernel (see his other Pushing the Limits posts on Physical and Virtual memory).

C

Dave Probert: Inside Windows 7 - User Mode Scheduler (UMS)

Charles — Mon, 02 Feb 2009 20:11:00 GMT

Here, we continue our exploration of the morphology of Windows 7 on Going Deep with windows kernel architect Dave Probert. You may remember him from an early four part episode of Going Deep where he teaches us about general purpose operating system architectures and history: Part 1, Part 2, Part 3, Part 4

That was a great conversation from a few years ago and it's been way too long since we returned to Windows kernel world to converse with and learn from Dr. Probert. Not surprisingly, Dave has been busy innovating the Windows core.

Dave and team, working very closely with the Parallel Computing Platform People, have created a very compelling new user mode thread scheduling/management system in Windows 7. In a nutshell, the User Mode Scheduler provides a new model for high-performance applications to control the execution of threads by allowing applications to schedule, throttle and control the overhead due to blocking system calls. In other words, applications can switch user threads completely in user mode without going through the kernel level scheduler. This frees up the kernel thread scheduler from having to block unnecessarily, which is a very good thing as we move into the age of Many-Core... Speaking of Many-Core, remember the piece we did on the Concurrency Runtime (ConcRT)? ConcRT is built on top of UMS and is the best way to most effectively utilize this new user mode thread scheduling model in Windows 7.

Make yourself comfortable and spend some time watching and listening to Dave make all of this crystal clear.

This is another great conversation with a fantastic OS architect and Windows kernel professor. Lots to learn here. Enjoy.

Chittur Subbaraman: Inside Windows 7 - Service Controller and Background Processing

Charles — Fri, 23 Jan 2009 19:39:00 GMT

At any given point, Windows is executing a lot of code. Some of this code runs in the background as services. In pre Windows 7 operating systems some services were set to auto run even though the configuration of the system (installed apps, hardware, etc) did not warrant them running. This had a four-fold potential effect:

1) Windows might start up slower as the service fires up
2) Users may experience sluggish performance as the service runs taking up processing and memory resources
3) Windows might take a long time to shut down as the service shuts down, unwinding itself and cleaning up it's resources
4) The surface area for code-level security breaches is larger(though, since Vista, most services run in a restricted security context)

Chittur Subbaraman, Windows kernel developer extraordinaire, and team spent a great deal of time thinking about and rectifying these problems by re-architecting the Windows 7 Service Controller. They also identified services that don't need to auto run (like a TabletPC Pen service that need not ever run on a desktop (non-Tablet) machine by default). But they went much further than simply figuring out which services can be set to manual start-up state in Windows 7. They added a new feature for service developers based on the trigger pattern: services can be started and shut down via triggers - this means developers are able to specify programmatically when a service needs to start or stop. This allows Wndows to control services in a much more dynamic way so less code has to run in any given user session. The Service Controller monitors and reacts to trigger events as opposed to just running services marked as auto when the system starts. Less code running in the background on Windows means more resources available for foregrond processing, faster start up of sessions and faster shut down.

The great work in the Windows 7 service controller by Chittur and team has a direct impact on the performance of Windows 7. Tune in to learn about the details and history of the service controller (and Task Manager).

Here are some great resources for you to read to get the details behind all of this great engineering in the background processing mechanisms deep inside Windows 7.

·White paper on Designing Efficient Background Processes.

·PDC talk on Designing Efficient Background Processes.

Mark Russinovich: Inside Windows 7

Charles — Wed, 14 Jan 2009 19:39:00 GMT

How has Windows evolved, as a general purpose operating system and at the lowest levels, in Windows 7? Who better to talk to than Technical Fellow and Windows Kernel guru Mark Russinovich? Here, Mark enlightens us on the new kernel constructs in Windows 7 (and, yeah, we do wander up into user mode, but only briefly). One very important change in the Windows 7 kernel is the dismantling of the dispatcher spin lock and redesign and implementation of its functionality. This great work was done by Arun Kishan (you've met him here on C9 last year). EDIT: You can learn exactly what Arun did in eliminating the dispatcher lock and replacing it with a set of synchronization primitives and a new "pre-wait" thread state, here. The direct result of the reworking of the dispatcher lock is that Windows 7 can scale to 256 processors. Further, this enabled the great Landy Wang to tune the Windows Memory Manager to be even more efficient than it already is. Mark also explains (again) what MinWin really is (heck, even I was confused. Not anymore...). MinWin is present in Windows 7. Native support for VHD (boot from VHD anyone?) is another very cool addition to our next general purpose OS. Yes, and there's more!

Tune in. This is a great conversation (if you're into operating systems). It's always great to chat with Mark.