Find the Best Cosmetic Hospitals

Explore trusted cosmetic hospitals and make a confident choice for your transformation.

“Invest in yourself — your confidence is always worth it.”

Explore Cosmetic Hospitals

Start your journey today — compare options in one place.

PERFMON (Performance Monitor): Demo & Lab

Below is the definitive, step-by-step list of PerfMon counters you must add for .NET / ASP.NET Core / API / Microservices performance optimization.

This is the same checklist used in enterprise performance engineering, load testing, and production diagnostics.

I will give you:

✔ Exact counters
✔ In step-by-step order
✔ Why each counter matters
✔ Which ones are optional vs mandatory
✔ What values are considered “bad”

This is your final PerfMon Counter Checklist for .NET performance.


STEP-BY-STEP: Add These PerfMon Counters for .NET Application Performance Optimization


🔵 STEP 1 — Add Essential CPU Counters (Mandatory)

✔ Processor

  • % Processor Time — _Total
  • % Privileged Time — _Total
  • % Interrupt Time
  • Processor Queue Length (from System)

✔ Process (for your app)

Select instance:
➡ dotnet, w3wp, or yourapp.exe

Add:

  • % Processor Time
  • Thread Count
  • Handle Count
  • Private Bytes
  • Working Set
  • IO Data Bytes/sec
  • IO Read Bytes/sec
  • IO Write Bytes/sec

Why CPU counters matter

  • Detect CPU saturation (>80%)
  • Find thread pool starvation
  • Detect infinite loops, heavy JSON serialization, LINQ misuse
  • Detect high kernel (privileged) usage → drivers, encryption, networking

🟣 STEP 2 — Add Memory Counters (Mandatory)

✔ Memory

  • Available MBytes
  • % Committed Bytes in Use
  • Pages/sec
  • Page Reads/sec
  • Cache Faults/sec
  • Committed Bytes

✔ Process (your app)

  • Private Bytes (memory leak indicator)
  • Virtual Bytes
  • Working Set
  • Page Faults/sec

Why Memory counters matter

  • Identify memory leaks
  • Detect high paging → application slowdown
  • Understand GC pressure
  • Identify large object allocations

🟢 STEP 3 — Add Disk I/O Counters (Mandatory)

✔ PhysicalDisk

(_Total)

  • Avg. Disk Queue Length
  • Avg. Disk sec/Read
  • Avg. Disk sec/Write
  • Disk Reads/sec
  • Disk Writes/sec
  • Current Disk Queue Length

✔ LogicalDisk

  • % Free Space
  • Free Megabytes

Why disk counters matter

  • Identify disk bottlenecks
  • Troubleshoot long API latency caused by slow file or database I/O.
  • Detect heavy logging or temp file writes

🟡 STEP 4 — Add Network Counters (Mandatory for API/Web App)

✔ Network Interface

  • Bytes Total/sec
  • Bytes Received/sec
  • Bytes Sent/sec
  • Output Queue Length
  • Packets/sec
  • Packets Outbound Errors
  • Packets Received Errors

✔ TCPv4

  • Connections Established
  • Connection Failures
  • Segments Retransmitted/sec

Why network counters matter

  • Understand throughput
  • Detect API congestion
  • Detect retransmissions (network instability)

🔴 STEP 5 — Add .NET CLR Counters (CRITICAL for .NET Performance)

➡ In PerfMon UI, expand:
“.NET CLR Memory”
“.NET CLR Exceptions”
“.NET CLR Jit”
“.NET CLR LocksAndThreads”
“.NET CLR Networking”

Select your instance:
dotnet, w3wp, or your application name.


🍀 .NET CLR MEMORY (Very Important)

✔ Add these:

  • % Time in GC
  • Gen 0 Collections
  • Gen 1 Collections
  • Gen 2 Collections 🔥
  • Large Object Heap Size 🔥
  • # Bytes in all Heaps
  • Promoted Memory/sec
  • Finalization Survivors
  • GC Handles

Interpretation:

CounterMeaning
% Time in GC > 15%Too much GC blocking = slow app
Frequent Gen 2 GCMemory pressure / large objects
High LOH sizeLarge object allocations causing fragmentation
High Promoted MB/secShort-lived objects living too long

🍀 .NET CLR EXCEPTIONS

Add:

  • # of Exceptions Thrown/sec

This indicates:

  • Poor coding practices
  • Bad error handling
  • Hidden exceptions killing performance

If > 100/sec consistently → WRONG code.


🍀 .NET CLR LOCKS & THREADS

Add:

  • # of current logical Threads
  • # of current physical Threads
  • Contention Rate/sec
  • Queue Length

Indicates:

  • Thread pool starvation
  • Async deadlocks
  • High locking contention

🍀 .NET CLR JIT

Add:

  • % Time in JIT
  • IL Bytes Jitted/sec

JIT issues appear on:

  • Cold starts
  • Large reflection / dynamic LINQ usage

🟤 STEP 6 — Add ASP.NET / IIS Counters (If Web App or API)

✔ ASP.NET Applications

(Select your app pool)

Add:

  • Requests/Sec
  • Requests Queued
  • Requests Rejected
  • Request Execution Time
  • Pipeline Instance Count

✔ ASP.NET

  • Application Restarts
  • Worker Process Restarts

✔ Web Service

(For old .NET Framework)

  • Total Method Requests/sec

✔ WinHTTP Proxy/Service

If using HttpClient extensively.


🔵 STEP 7 — Add Kestrel & Hosting Counters (.NET Core Self-hosted)

If running on Kestrel (non-IIS):

✔ ASP.NET Core Hosting

  • Current Requests
  • Requests/sec
  • Request Queue Length

✔ Kestrel

(Available in dotnet counters, but PerfMon may expose via EventSource)

  • Connection queue length
  • Active connections
  • TLS handshake duration

🟣 STEP 8 — Add SQL Server Counters (If Your App Uses DB)

Category: SQLServer:SQL Statistics

  • Batch Requests/sec
  • Compilations/sec
  • Re-Compilations/sec

Category: SQLServer:Buffer Manager

  • Buffer cache hit ratio
  • Page life expectancy (PLE)

Category: SQLServer:General Statistics

  • User Connections
  • Processes blocked

Category: SQLServer:Wait Statistics

  • Lock waits/sec
  • Latch waits/sec

These help detect:

  • Query bottlenecks
  • High CPU SQL queries
  • Plan cache issues
  • Memory pressure

🎯 FINAL: Complete List (Copy-Paste Checklist)

Here is the single list you can paste into training material:


✔ CPU

  • Processor → % Processor Time (_Total)
  • Processor → % Privileged Time
  • Processor → % Interrupt Time
  • System → Processor Queue Length
  • Process(dotnet/w3wp/app.exe) → % Processor Time
  • Thread Count
  • Handle Count

✔ Memory

  • Memory → Available MBytes
  • Memory → % Committed Bytes
  • Memory → Pages/sec
  • Process → Private Bytes
  • Process → Page Faults/sec
  • Process → Working Set

✔ Disk

  • Avg. Disk Queue Length
  • Avg. Disk sec/Read
  • Avg. Disk sec/Write
  • Disk Reads/sec
  • Disk Writes/sec

✔ Network

  • Bytes Total/sec
  • TCP Retransmissions/sec
  • Connections Established
  • Packets Errors

✔ .NET CLR Memory

  • % Time in GC
  • Gen 0/1/2 Collections
  • Promoted MB/sec
  • Bytes in All Heaps
  • LOH Size

✔ .NET CLR Exceptions

  • Exceptions/sec

✔ .NET CLR LocksAndThreads

  • Contention Rate/sec
  • Logical Threads
  • Physical Threads

✔ ASP.NET / Hosting

  • Requests/sec
  • Current Requests
  • Request Queue Length
  • Request Execution Time

✔ SQL Server

  • Batch Requests/sec
  • SQL Compilations/sec
  • SQL Re-compilations/sec
  • Buffer Cache Hit Ratio
  • Page Life Expectancy

Find Trusted Cardiac Hospitals

Compare heart hospitals by city and services — all in one place.

Explore Hospitals
I'm Rajesh Kumar, a DevOps, SRE, DevSecOps, Cloud, and Platform Engineering expert passionate about sharing practical knowledge, real-world experiences, and industry best practices. I have worked at Cotocus and regularly write about technology, travel, investing, health, product reviews, and digital marketing through my various platforms. I publish technical articles at DevOps School, travel stories at Holiday Landmark, stock market insights at Stocks Mantra, health and fitness guidance at My Medic Plus, product reviews at TrueReviewNow, and SEO and digital marketing strategies at Wizbrand.

Related Posts

The Role of Automation in Modern iGaming Infrastructure

The iGaming industry operates in a fast-moving digital environment where scalability, reliability, security and speed are essential. Online sportsbooks and casino platforms need to handle high traffic,…

Read More

Running LLM Workloads Like Any Other Production Service: A DevOps Playbook for Model APIs

A model API is a dependency like any other, and it deserves the same operational discipline. Photo via Unsplash. When a team ships its first feature built…

Read More

Combining Tech Skills with Higher Education: Strategies for Top University Admissions

The modern higher education landscape has shifted dramatically, moving away from purely standardized metrics toward holistic evaluations where applied, real-world skills matter deeply. Secondary school students who…

Read More

What a Financial Strategy Partner Brings Beyond Basic Advisory

Basic advisory explains what happened in a business. A financial strategy partner helps leaders decide what should happen next. That difference matters when growth creates cash pressure,…

Read More

Designing a production-ready web scraping pipeline that survives blocks, retries, and CI

Most scraping failures in production look like random network noise. The real cause is usually a weak contract between your code and the target site. You deploy…

Read More

Top 7 Bare-Metal AI Infrastructure Providers

Bare-metal AI infrastructure providers give teams dedicated physical compute, but the buying experience varies considerably: some supply individual GPU servers that your engineers operate, while others take…

Read More
Subscribe
Notify of
guest
2 Comments
Newest
Oldest Most Voted
Skylar Bennett
Skylar Bennett
10 months ago

Really impressive and practical lab — a very detailed “checklist‑style” guide for anyone looking to use PerfMon for .NET / ASP.NET Core / API / Microservices performance tuning! The step‑by‑step list of recommended counters (CPU, Memory, Disk I/O, Network, .NET CLR metrics, etc.), along with clear explanations of why each counter matters, makes this tutorial especially useful for diagnosing real‑world performance bottlenecks — from CPU saturation and memory leaks to disk latency and GC pressure. For engineering teams or SRE/DevOps folks, having this as a ready‑to‑use “counter‑set checklist” is a huge time‑saver and a solid foundation for consistent monitoring across applications. 👍

Jason Mitchell
Jason Mitchell
10 months ago

This lab‑style tutorial provides a practical, step‑by‑step walkthrough of using Windows’ built‑in Performance Monitor (PerfMon) tool. It goes beyond the basics by showing how to select meaningful performance counters (CPU usage, process working set, GC cycles, SQL Server batch requests) and compare real‑world scenarios—such as non‑optimized versus optimized code paths. For DevOps engineers or SREs teaching interns, this piece is especially valuable because it bridges the gap between “what can I monitor” and “how do I interpret the data to find a bottleneck or design flaw”. With the kind of hands‑on examples provided, it’s an excellent resource for boosting your ability to gather actionable metrics and then use them for performance tuning or capacity‑planning exercises.

2
0
Would love your thoughts, please comment.x
()
x