When troubleshooting performance issues on Windows systems, disk space analysis often becomes critical. Unlike Unix systems with the handy du command, Windows requires alternative approaches to identify space-hogging directories.

PowerShell Approach

The most direct native solution comes through PowerShell:

# Recursive directory size (similar to du -sh)
Get-ChildItem -Recurse | Measure-Object -Property Length -Sum | Select-Object Sum

# Sorted directory listing (like du -hs * | sort -h)
Get-ChildItem | 
    ForEach-Object { 
        $size = (Get-ChildItem $_ -Recurse | Measure-Object -Property Length -Sum).Sum
        [PSCustomObject]@{
            Name = $_.Name
            Size = $size
        }
    } | Sort-Object Size -Descending

Command Prompt Alternatives

:: Basic folder size (slow for large directories)
dir /s /a

WinDirStat

The gold standard for Windows disk visualization with treemap display:

• Free and open-source
• Color-coded block representation
• Detailed file type statistics

SpaceSniffer

Another excellent visual analyzer with unique features:

• Real-time updating
• Portable version available
• Custom filtering options

WizTree

For those needing extreme speed:

• Uses MFT for instant results
• Handles multi-TB drives efficiently
• Command-line version available

For system administrators needing regular reports:

# PowerShell script to log top 10 space consumers
$logPath = "C:\Admin\DiskUsage_$(Get-Date -Format 'yyyyMMdd').csv"
Get-ChildItem C:\ -Directory | 
    Select-Object FullName,
        @{Name="SizeGB";Expression={[math]::Round((($_ | Get-ChildItem -Recurse | 
        Measure-Object -Property Length -Sum).Sum/1GB),2)}} |
    Sort-Object SizeGB -Descending |
    Select-Object -First 10 |
    Export-Csv -Path $logPath -NoTypeInformation

Windows systems often use junctions that can distort size calculations. Detect them with:

dir /AL /S

---

When troubleshooting performance issues on Windows systems, especially when dealing with nearly full disks, administrators often need to identify which directories or files are consuming the most space. While Unix/Linux systems have the handy 'du' command, Windows lacks a direct equivalent in its native toolset.

Windows does provide some built-in tools for disk analysis:

dir /s /a | sort /+14

This command recursively lists all files and sorts them by size (the 14th column in dir output). However, it's not as comprehensive as Unix's du.

For more powerful analysis, PowerShell offers better solutions:

Get-ChildItem -Recurse | 
    Where-Object { $_.PSIsContainer } | 
    Select-Object FullName, 
        @{Name="Size(MB)";Expression={ 
            [math]::Round((
                (Get-ChildItem $_.FullName -Recurse | 
                Measure-Object -Property Length -Sum).Sum / 1MB
            ), 2) 
        }}

This script recursively calculates folder sizes similar to 'du -h' in Unix.

Several excellent third-party tools provide GUI visualization:

• WinDirStat: Creates treemap visualizations of disk usage
• TreeSize Free: Shows folder sizes in a tree structure
• SpaceSniffer: Provides block-based visualization of disk usage

For Windows Server environments where you need to identify service-specific disk consumption:

wmic service where (state="running") get name,pathname | 
    ForEach-Object {
        $service = $_.Trim()
        if ($service -match '^(.+?)\s+(.+)') {
            [PSCustomObject]@{
                Service = $matches[1]
                Path = $matches[2]
                Size = (Get-Item $matches[2]).Length / 1MB
            }
        }
    }

For regular monitoring, you can create scheduled tasks that generate disk usage reports:

$report = Get-WmiObject Win32_LogicalDisk | 
    Select-Object DeviceID, 
        @{Name="Size(GB)";Expression={[math]::Round($_.Size/1GB,2)}}, 
        @{Name="Free(GB)";Expression={[math]::Round($_.FreeSpace/1GB,2)}}
$report | Export-Csv -Path "C:\DiskReport.csv" -NoTypeInformation

This script creates a CSV report of all disk drives and their free space.

When dealing with very large directory structures, consider these performance optimizations:

# Fast folder size calculation using .NET
function Get-FolderSize {
    param([string]$path)
    $fso = New-Object -ComObject Scripting.FileSystemObject
    $folder = $fso.GetFolder($path)
    [math]::Round($folder.Size / 1GB, 2)
}

The FileSystemObject COM object is generally faster than PowerShell's native cmdlets for large scans.