325 lines
18 KiB
PowerShell
325 lines
18 KiB
PowerShell
Set-StrictMode -Version Latest
|
|
|
|
function Get-AtmosphericPresetUnavailableReasonClassification {
|
|
[CmdletBinding()]
|
|
param(
|
|
[Parameter(Mandatory = $true)][string]$Reason,
|
|
[Parameter(Mandatory = $true)]
|
|
[ValidateSet('low', 'medium', 'high', 'auto')][string]$Preset)
|
|
|
|
if ($Preset -eq 'auto') {
|
|
$performancePattern = "^Automatic quality disabled render pack 'acdream\.atmospheric' because Low remained over its declared performance budget for 180 stable samples: GPU p99 (?<gpu>[0-9]+(?:\.[0-9]+)?) ms \(budget (?<gpuBudget>[0-9]+(?:\.[0-9]+)?) ms\), CPU p99 (?<cpu>[0-9]+(?:\.[0-9]+)?) ms \(budget (?<cpuBudget>[0-9]+(?:\.[0-9]+)?) ms\), resident GPU bytes (?<resident>[0-9]+) \(budget (?<residentBudget>[0-9]+)\)\.$"
|
|
$performance = [Regex]::Match(
|
|
$Reason,
|
|
$performancePattern,
|
|
[Text.RegularExpressions.RegexOptions]::CultureInvariant)
|
|
if ($performance.Success) {
|
|
$culture = [Globalization.CultureInfo]::InvariantCulture
|
|
$gpu = [double]::Parse($performance.Groups['gpu'].Value, $culture)
|
|
$gpuBudget = [double]::Parse($performance.Groups['gpuBudget'].Value, $culture)
|
|
$cpu = [double]::Parse($performance.Groups['cpu'].Value, $culture)
|
|
$cpuBudget = [double]::Parse($performance.Groups['cpuBudget'].Value, $culture)
|
|
$resident = [long]::Parse($performance.Groups['resident'].Value, $culture)
|
|
$residentBudget = [long]::Parse($performance.Groups['residentBudget'].Value, $culture)
|
|
if ($gpu -gt $gpuBudget -or $cpu -gt $cpuBudget -or
|
|
$resident -gt $residentBudget) {
|
|
return [pscustomobject][ordered]@{
|
|
Supported = $true
|
|
Classification = 'PerformanceUnavailable'
|
|
Reason = $Reason
|
|
}
|
|
}
|
|
}
|
|
foreach ($resolvedPreset in @('low', 'medium', 'high')) {
|
|
$classification = Get-AtmosphericPresetUnavailableReasonClassification `
|
|
-Reason $Reason -Preset $resolvedPreset
|
|
if ($classification.Supported) { return $classification }
|
|
}
|
|
return [pscustomobject][ordered]@{
|
|
Supported = $false
|
|
Classification = 'UnexpectedFailure'
|
|
Reason = $Reason
|
|
}
|
|
}
|
|
|
|
# Keep this allow-list deliberately narrow. A shader, validation, pipeline,
|
|
# draw, or ordinary runtime failure must not become a passing
|
|
# "unavailable" row merely because its prose contains words such as
|
|
# unsupported, resource, memory, or capability.
|
|
$escapedPreset = [Regex]::Escape($Preset)
|
|
$preparationPrefix = "(?:Render pack 'acdream\.atmospheric' could not be prepared: )?"
|
|
$resourcePatterns = @(
|
|
"^${preparationPrefix}Render pack preset '$escapedPreset' needs [1-9][0-9]* resident GPU bytes at [1-9][0-9]*x[1-9][0-9]*; its declared ceiling is [1-9][0-9]*\. Select a compatible preset or reduce the main-world resolution\.$",
|
|
"^${preparationPrefix}Render pack preset '$escapedPreset' needs [1-9][0-9]* resident GPU bytes at [1-9][0-9]*x[1-9][0-9]*; this host permits [1-9][0-9]* under its .+ policy\.$",
|
|
"^${preparationPrefix}Render pack preset '$escapedPreset' needs [1-9][0-9]* transient multisample GPU bytes at [1-9][0-9]*x[1-9][0-9]* x[1-9][0-9]*; this host permits [1-9][0-9]* under its .+ policy\.$",
|
|
"^Directional shadow rendering failed: Render pack preset '$escapedPreset' needs [1-9][0-9]* resident GPU bytes after materializing its scene-dependent shadow command buffers; the active pack budget is [1-9][0-9]* bytes\.$",
|
|
"^Preset '$escapedPreset' declares a [1-9][0-9]*-byte resident GPU ceiling, but this host permits [1-9][0-9]* bytes under its .+ policy\.$"
|
|
)
|
|
foreach ($pattern in $resourcePatterns) {
|
|
if ([Regex]::IsMatch($Reason, $pattern, [Text.RegularExpressions.RegexOptions]::CultureInvariant)) {
|
|
return [pscustomobject][ordered]@{
|
|
Supported = $true
|
|
Classification = 'ResourceUnavailable'
|
|
Reason = $Reason
|
|
}
|
|
}
|
|
}
|
|
|
|
$capabilityPatterns = @(
|
|
"^Pack 'acdream\.atmospheric' requires unsupported capability '[A-Za-z][A-Za-z0-9]*'\.$",
|
|
"^Preset '$escapedPreset' requires unsupported capability '[A-Za-z][A-Za-z0-9]*'\.$",
|
|
"^Preset '$escapedPreset' resource '[a-z0-9][a-z0-9.-]*' needs [1-9][0-9]* image-array layers; this device provides [0-9]+\.$",
|
|
"^Preset '$escapedPreset' resource '[a-z0-9][a-z0-9.-]*' needs [1-9][0-9]*(?:\.[0-9]+)?x[1-9][0-9]*(?:\.[0-9]+)?; this device's maximum 2-D image edge is [1-9][0-9]*\.$",
|
|
"^${preparationPrefix}Render pack preset '$escapedPreset' resolves an image to [1-9][0-9]*x[1-9][0-9]* at [1-9][0-9]*x[1-9][0-9]*; this device's maximum 2-D image edge is [1-9][0-9]*\.$",
|
|
"^${preparationPrefix}Render pack preset '$escapedPreset' needs [1-9][0-9]* image-array layers; this device provides [0-9]+\.$"
|
|
)
|
|
foreach ($pattern in $capabilityPatterns) {
|
|
if ([Regex]::IsMatch($Reason, $pattern, [Text.RegularExpressions.RegexOptions]::CultureInvariant)) {
|
|
return [pscustomobject][ordered]@{
|
|
Supported = $true
|
|
Classification = 'CapabilityUnavailable'
|
|
Reason = $Reason
|
|
}
|
|
}
|
|
}
|
|
|
|
return [pscustomobject][ordered]@{
|
|
Supported = $false
|
|
Classification = 'UnexpectedFailure'
|
|
Reason = $Reason
|
|
}
|
|
}
|
|
|
|
function Test-AtmosphericPerformanceMetadataEvidence {
|
|
[CmdletBinding()]
|
|
param(
|
|
[Parameter(Mandatory = $true)][string]$MetadataPath,
|
|
[Parameter(Mandatory = $true)]
|
|
[ValidateSet('retail', 'low', 'medium', 'high', 'auto')][string]$Preset,
|
|
[Parameter(Mandatory = $true)][int]$ExpectedWidth,
|
|
[Parameter(Mandatory = $true)][int]$ExpectedHeight,
|
|
[switch]$AllowSafeFallback)
|
|
|
|
$failures = [Collections.Generic.List[string]]::new()
|
|
function Require([object]$Value, [string]$Name, [string]$Context) {
|
|
$property = $Value.PSObject.Properties[$Name]
|
|
if ($null -eq $property) { throw "$Context is missing required property '$Name'." }
|
|
return $property.Value
|
|
}
|
|
function Fail([string]$Message) { $null = $failures.Add($Message) }
|
|
function Require-FiniteNonNegative([object]$Value, [string]$Name) {
|
|
$number = [double](Require $Value $Name 'RenderPack.Performance')
|
|
if (-not [double]::IsFinite($number) -or $number -lt 0) {
|
|
Fail "$Name must be finite and non-negative"
|
|
}
|
|
return $number
|
|
}
|
|
|
|
$metadata = Get-Content -Raw -LiteralPath $MetadataPath | ConvertFrom-Json
|
|
if ([int](Require $metadata 'SchemaVersion' 'metadata') -ne 1) {
|
|
Fail 'metadata SchemaVersion must be 1'
|
|
}
|
|
if ([int](Require $metadata 'Width' 'metadata') -ne $ExpectedWidth -or
|
|
[int](Require $metadata 'Height' 'metadata') -ne $ExpectedHeight) {
|
|
Fail "capture extent must be ${ExpectedWidth}x${ExpectedHeight}"
|
|
}
|
|
$pack = Require $metadata 'RenderPack' 'metadata'
|
|
$enhanced = $Preset -ne 'retail'
|
|
$state = [int](Require $pack 'State' 'RenderPack')
|
|
$fallback = $enhanced -and $state -eq 3
|
|
$expectedPackId = if ($enhanced -and -not $fallback) { 'acdream.atmospheric' } else { 'retail' }
|
|
$expectedVersion = if ($enhanced -and -not $fallback) { '1.0.0' } else { '' }
|
|
$expectedPreset = if ($enhanced -and -not $fallback) { $Preset } else { 'off' }
|
|
$expectedState = if ($enhanced -and -not $fallback) { 2 } elseif ($fallback) { 3 } else { 0 }
|
|
$actualEffectiveQuality = [string](
|
|
Require $pack 'EffectiveQuality' 'RenderPack')
|
|
$expectedQuality = if ($enhanced -and -not $fallback -and $Preset -ne 'auto') {
|
|
$Preset
|
|
} else { 'off' }
|
|
foreach ($comparison in @(
|
|
@('PackId', $expectedPackId), @('PackVersion', $expectedVersion),
|
|
@('PresetId', $expectedPreset))) {
|
|
$actual = [string](Require $pack ([string]$comparison[0]) 'RenderPack')
|
|
if ($actual -cne [string]$comparison[1]) {
|
|
Fail "$($comparison[0]) was '$actual', expected '$($comparison[1])'"
|
|
}
|
|
}
|
|
if ($enhanced -and -not $fallback -and $Preset -eq 'auto') {
|
|
if ($actualEffectiveQuality -cnotin @('low', 'medium', 'high')) {
|
|
Fail "Automatic EffectiveQuality was '$actualEffectiveQuality', expected low, medium, or high"
|
|
}
|
|
}
|
|
elseif ($actualEffectiveQuality -cne $expectedQuality) {
|
|
Fail "EffectiveQuality was '$actualEffectiveQuality', expected '$expectedQuality'"
|
|
}
|
|
if ($state -ne $expectedState) {
|
|
Fail "activation state must be $expectedState"
|
|
}
|
|
$generation = [int](Require $pack 'ActivationGeneration' 'RenderPack')
|
|
if (($fallback -and $generation -lt 1) -or
|
|
($enhanced -and -not $fallback -and $Preset -eq 'auto' -and
|
|
$generation -lt 1) -or
|
|
($enhanced -and -not $fallback -and $Preset -ne 'auto' -and
|
|
$generation -ne 1) -or
|
|
(-not $enhanced -and $generation -ne 0)) {
|
|
Fail "activation generation is invalid for state $state"
|
|
}
|
|
$failureReason = [string](Require $pack 'FailureReason' 'RenderPack')
|
|
$unavailableClassification = $null
|
|
if ($fallback) {
|
|
if (-not $AllowSafeFallback) {
|
|
Fail 'FailedToRetail fallback was not explicitly allowed for this capture'
|
|
}
|
|
if ([string]::IsNullOrWhiteSpace($failureReason)) {
|
|
Fail 'FailedToRetail fallback must preserve one exact failure reason'
|
|
}
|
|
else {
|
|
$reasonClassification = Get-AtmosphericPresetUnavailableReasonClassification `
|
|
-Reason $failureReason -Preset $Preset
|
|
$unavailableClassification = $reasonClassification.Classification
|
|
if (-not $reasonClassification.Supported) {
|
|
Fail 'FailedToRetail reason is not a strict resource/capability/Auto-performance unavailability'
|
|
}
|
|
}
|
|
}
|
|
elseif (-not [string]::IsNullOrWhiteSpace($failureReason)) {
|
|
Fail 'render-pack FailureReason must be empty'
|
|
}
|
|
|
|
$performance = Require $pack 'Performance' 'RenderPack'
|
|
$topResident = [long](Require $pack 'RetainedGpuBytes' 'RenderPack')
|
|
$topTransient = [long](Require $pack 'TransientGpuBytes' 'RenderPack')
|
|
$nestedResident = [long](Require $performance 'ResidentGpuBytes' 'RenderPack.Performance')
|
|
$nestedTransient = [long](Require $performance 'TransientGpuBytes' 'RenderPack.Performance')
|
|
if ($topResident -ne $nestedResident) { Fail 'top-level and performance resident GPU bytes disagree' }
|
|
if ($topTransient -ne $nestedTransient) { Fail 'top-level and performance transient GPU bytes disagree' }
|
|
|
|
$casterCount = [int](Require $pack 'ShadowCasterCount' 'RenderPack')
|
|
$cascadeCount = [int](Require $pack 'CascadeDrawCount' 'RenderPack')
|
|
$classificationCalls = [int](Require $pack 'CpuClassificationCalls' 'RenderPack')
|
|
$drawCalls = [int](Require $pack 'DrawCalls' 'RenderPack')
|
|
$dispatchCalls = [int](Require $pack 'DispatchCalls' 'RenderPack')
|
|
$imageCount = [int](Require $pack 'ImageCount' 'RenderPack')
|
|
$bufferCount = [int](Require $pack 'BufferCount' 'RenderPack')
|
|
$passes = @(Require $pack 'Passes' 'RenderPack')
|
|
|
|
if ($fallback) {
|
|
if ($casterCount -ne 0 -or $cascadeCount -ne 0 -or $classificationCalls -ne 0 -or
|
|
$drawCalls -ne 0 -or $dispatchCalls -ne 0 -or $passes.Count -ne 0 -or
|
|
$imageCount -ne 0 -or $bufferCount -ne 0 -or
|
|
$topResident -ne 0 -or $topTransient -ne 0) {
|
|
Fail 'FailedToRetail fallback must have zero pack work and resources'
|
|
}
|
|
foreach ($countName in @('CpuSampleCount', 'AbsoluteReceiverCpuSampleCount', 'GpuSampleCount')) {
|
|
if ([int](Require $performance $countName 'RenderPack.Performance') -ne 0) {
|
|
Fail "FailedToRetail fallback must have zero $countName"
|
|
}
|
|
}
|
|
foreach ($metric in @(
|
|
'IncrementalCpuMillisecondsP50', 'IncrementalCpuMillisecondsP95',
|
|
'IncrementalCpuMillisecondsP99', 'AbsoluteReceiverCpuMillisecondsP50',
|
|
'AbsoluteReceiverCpuMillisecondsP95', 'AbsoluteReceiverCpuMillisecondsP99',
|
|
'InclusiveGpuMillisecondsP50', 'InclusiveGpuMillisecondsP95',
|
|
'InclusiveGpuMillisecondsP99', 'ResidentGpuBytes', 'TransientGpuBytes')) {
|
|
if ([double](Require $performance $metric 'RenderPack.Performance') -ne 0) {
|
|
Fail "FailedToRetail fallback must report zero $metric"
|
|
}
|
|
}
|
|
}
|
|
elseif (-not $enhanced) {
|
|
if ($casterCount -ne 0 -or $cascadeCount -ne 0 -or $classificationCalls -ne 0 -or
|
|
$drawCalls -ne 0 -or $dispatchCalls -ne 0 -or $passes.Count -ne 0 -or
|
|
$imageCount -ne 0 -or $bufferCount -ne 0 -or
|
|
$topResident -ne 0 -or $topTransient -ne 0) {
|
|
Fail 'retail row must have zero pack work, resources, and classification'
|
|
}
|
|
}
|
|
else {
|
|
$shapePreset = if ($Preset -eq 'auto') {
|
|
$actualEffectiveQuality
|
|
} else { $Preset }
|
|
$expectedCascades = @{ low = 2; medium = 3; high = 4 }[$shapePreset]
|
|
if ($casterCount -le 0) { Fail 'enhanced row must contain at least one shadow caster' }
|
|
if ($cascadeCount -ne $expectedCascades) {
|
|
Fail "$Preset/$shapePreset must render exactly $expectedCascades cascades"
|
|
}
|
|
if ($classificationCalls -ne 0) { Fail 'warmed capture must perform zero CPU classifications' }
|
|
$expectedPassIds = [Collections.Generic.List[string]]::new()
|
|
$expectedPassIds.Add('atmospheric-world-receiver')
|
|
if ($shapePreset -eq 'low') {
|
|
$expectedPassIds.Add('directional-shadow-multiview')
|
|
}
|
|
else {
|
|
for ($cascade = 0; $cascade -lt $expectedCascades; $cascade++) {
|
|
$expectedPassIds.Add("directional-shadow-cascade-$cascade")
|
|
}
|
|
}
|
|
$postPassIds = @(
|
|
'atmospheric-sun-occlusion', 'atmospheric-sun-rays',
|
|
'atmospheric-volumetric-shafts', 'atmospheric-bloom-downsample',
|
|
'atmospheric-bloom-blur-horizontal', 'atmospheric-bloom-blur-vertical',
|
|
'atmospheric-filmic')
|
|
foreach ($id in $postPassIds) { $expectedPassIds.Add($id) }
|
|
$actualPassIds = @($passes | ForEach-Object { [string](Require $_ 'PassId' 'RenderPack.Passes[]') })
|
|
if (($actualPassIds -join '|') -cne (@($expectedPassIds) -join '|')) {
|
|
Fail "pass order/shape was '$($actualPassIds -join ',')'"
|
|
}
|
|
# The fixed offline scene resolves five prepared shadow submissions:
|
|
# terrain plus the stable opaque/alpha-cutout world runs. Low replays
|
|
# those once through multiview; Medium/High replay them per cascade.
|
|
$shadowDrawsPerPass = 5
|
|
# Low now uses the quarter-resolution separable graph as well. Its
|
|
# volumetric pass remains declared for one stable API shape but records
|
|
# zero draws because the Low preset disables volumetric strength.
|
|
$postDraws = 6
|
|
$expectedDraws = $postDraws + $(if ($shapePreset -eq 'low') {
|
|
$shadowDrawsPerPass
|
|
} else {
|
|
$shadowDrawsPerPass * $expectedCascades
|
|
})
|
|
$summedDraws = [int](($passes | Measure-Object -Property DrawCalls -Sum).Sum)
|
|
$summedDispatches = [int](($passes | Measure-Object -Property DispatchCalls -Sum).Sum)
|
|
if ($drawCalls -ne $expectedDraws -or $summedDraws -ne $expectedDraws) {
|
|
Fail "draw shape must total $expectedDraws calls"
|
|
}
|
|
if ($dispatchCalls -ne 0 -or $summedDispatches -ne 0) {
|
|
Fail 'atmospheric pack must issue zero dispatch calls'
|
|
}
|
|
foreach ($pass in $passes) {
|
|
$passId = [string](Require $pass 'PassId' 'RenderPack.Passes[]')
|
|
$expectedPassDraws = if ($passId -like 'directional-shadow-*') {
|
|
$shadowDrawsPerPass
|
|
}
|
|
elseif ($passId -in @('atmospheric-world-receiver', 'atmospheric-volumetric-shafts')) { 0 }
|
|
else { 1 }
|
|
if ([int](Require $pass 'DrawCalls' 'RenderPack.Passes[]') -ne $expectedPassDraws -or
|
|
[int](Require $pass 'DispatchCalls' 'RenderPack.Passes[]') -ne 0) {
|
|
Fail "pass '$passId' must record exactly $expectedPassDraws draws and zero dispatches"
|
|
}
|
|
}
|
|
foreach ($countName in @('CpuSampleCount', 'AbsoluteReceiverCpuSampleCount', 'GpuSampleCount')) {
|
|
if ([int](Require $performance $countName 'RenderPack.Performance') -ne 2048) {
|
|
Fail "$countName must contain the complete 2048-sample window"
|
|
}
|
|
}
|
|
foreach ($metric in @(
|
|
'IncrementalCpuMillisecondsP50', 'IncrementalCpuMillisecondsP95',
|
|
'IncrementalCpuMillisecondsP99', 'AbsoluteReceiverCpuMillisecondsP50',
|
|
'AbsoluteReceiverCpuMillisecondsP95', 'AbsoluteReceiverCpuMillisecondsP99',
|
|
'InclusiveGpuMillisecondsP50', 'InclusiveGpuMillisecondsP95',
|
|
'InclusiveGpuMillisecondsP99')) { $null = Require-FiniteNonNegative $performance $metric }
|
|
}
|
|
|
|
return [pscustomobject][ordered]@{
|
|
Passed = $failures.Count -eq 0
|
|
Failures = @($failures)
|
|
Outcome = if ($fallback) { 'Unavailable' } elseif ($enhanced) { 'Active' } else { 'Retail' }
|
|
UnavailableClassification = $unavailableClassification
|
|
FailureReason = if ($fallback) { $failureReason } else { $null }
|
|
EffectiveQuality = $actualEffectiveQuality
|
|
ShadowCasterCount = $casterCount
|
|
CascadeDrawCount = $cascadeCount
|
|
CpuClassificationCalls = $classificationCalls
|
|
PassIds = @($passes | ForEach-Object { [string]$_.PassId })
|
|
}
|
|
}
|