@@ -60,10 +60,13 @@ pub enum ModelFit {
6060 Tight ,
6161 Tradeoff ,
6262 TooLarge ,
63+ Unknown ,
6364}
6465
6566fn fit_code ( model_gb : f64 , vram_gb : f64 ) -> ModelFit {
66- if model_gb <= vram_gb * 0.6 {
67+ if vram_gb <= 0.0 {
68+ ModelFit :: Unknown
69+ } else if model_gb <= vram_gb * 0.6 {
6770 ModelFit :: Comfortable
6871 } else if model_gb <= vram_gb * 0.9 {
6972 ModelFit :: Tight
@@ -80,6 +83,7 @@ fn fit_rank(fit: ModelFit) -> u8 {
8083 ModelFit :: Tight => 1 ,
8184 ModelFit :: Tradeoff => 2 ,
8285 ModelFit :: TooLarge => 3 ,
86+ ModelFit :: Unknown => 4 ,
8387 }
8488}
8589
@@ -148,129 +152,67 @@ fn catalog_hardware() -> CatalogHardware {
148152 // GPU VRAM. That is useful for runtime placement, but misleading in the
149153 // picker: a 16 GB card with 32 GB system RAM reads as ~32 GB and receives
150154 // too-large recommendations. For the catalog, report and rank against
151- // dedicated GPU memory only. These probes also hide child console windows,
152- // avoiding the visible PowerShell/nvidia-smi flashes from the upstream
153- // survey when Settings → Compute opens.
154- if let Some ( ( names, vram_bytes) ) = windows_nvidia_smi_gpus ( ) {
155- return CatalogHardware {
156- gpu_name : summarize_gpu_names ( & names) ,
157- vram_bytes,
158- } ;
159- }
160- let gpus = windows_video_controllers ( ) ;
161- let names: Vec < String > = gpus. iter ( ) . map ( |( name, _) | name. clone ( ) ) . collect ( ) ;
162- let vram_bytes = gpus. iter ( ) . map ( |( _, bytes) | * bytes) . sum ( ) ;
163- CatalogHardware {
164- gpu_name : summarize_gpu_names ( & names) ,
165- vram_bytes,
166- }
167- }
168-
169- #[ cfg( target_os = "windows" ) ]
170- fn windows_command_output ( program : & str , args : & [ & str ] ) -> Option < String > {
171- use std:: os:: windows:: process:: CommandExt ;
172-
173- const CREATE_NO_WINDOW : u32 = 0x0800_0000 ;
174- let output = std:: process:: Command :: new ( program)
175- . args ( args)
176- . creation_flags ( CREATE_NO_WINDOW )
177- . output ( )
178- . ok ( ) ?;
179- if !output. status . success ( ) {
180- return None ;
181- }
182- String :: from_utf8 ( output. stdout ) . ok ( )
183- }
184-
185- #[ cfg( target_os = "windows" ) ]
186- fn windows_nvidia_smi_gpus ( ) -> Option < ( Vec < String > , u64 ) > {
187- let output = windows_command_output (
188- "nvidia-smi" ,
189- & [
190- "--query-gpu=name,memory.total" ,
191- "--format=csv,noheader,nounits" ,
192- ] ,
193- ) ?;
194- parse_nvidia_smi_catalog_output ( & output)
155+ // dedicated GPU memory only.
156+ select_catalog_adapter ( & dxgi_adapters ( ) )
157+ . map ( |adapter| CatalogHardware {
158+ gpu_name : Some ( adapter. name . clone ( ) ) ,
159+ vram_bytes : adapter. dedicated_vram_bytes ,
160+ } )
161+ . unwrap_or ( CatalogHardware {
162+ gpu_name : None ,
163+ vram_bytes : 0 ,
164+ } )
195165}
196166
197167#[ cfg( target_os = "windows" ) ]
198- fn parse_nvidia_smi_catalog_output ( output : & str ) -> Option < ( Vec < String > , u64 ) > {
199- let mut names = Vec :: new ( ) ;
200- let mut total = 0_u64 ;
201- for line in output
202- . lines ( )
203- . map ( str:: trim)
204- . filter ( |line| !line. is_empty ( ) )
205- {
206- let Some ( ( name, mib) ) = line. rsplit_once ( ',' ) else {
207- continue ;
208- } ;
209- let Ok ( mib) = mib. trim ( ) . parse :: < u64 > ( ) else {
210- continue ;
211- } ;
212- if mib == 0 {
213- continue ;
214- }
215- names. push ( name. trim ( ) . to_string ( ) ) ;
216- total = total. saturating_add ( mib. saturating_mul ( 1024 * 1024 ) ) ;
217- }
218- ( !names. is_empty ( ) && total > 0 ) . then_some ( ( names, total) )
168+ #[ derive( Debug , Clone , PartialEq , Eq ) ]
169+ struct DxgiAdapterInfo {
170+ name : String ,
171+ dedicated_vram_bytes : u64 ,
172+ software : bool ,
219173}
220174
221175#[ cfg( target_os = "windows" ) ]
222- #[ derive( serde:: Deserialize ) ]
223- #[ serde( rename_all = "PascalCase" ) ]
224- struct WindowsVideoController {
225- name : Option < String > ,
226- #[ serde( rename = "AdapterRAM" ) ]
227- adapter_ram : Option < serde_json:: Value > ,
176+ fn select_catalog_adapter ( adapters : & [ DxgiAdapterInfo ] ) -> Option < & DxgiAdapterInfo > {
177+ adapters
178+ . iter ( )
179+ . filter ( |adapter| !adapter. software && adapter. dedicated_vram_bytes > 0 )
180+ // Rank against a single adapter's memory. Summing multiple GPUs would
181+ // recommend models that fit in no one adapter unless the runtime can
182+ // explicitly shard layers across devices.
183+ . max_by_key ( |adapter| adapter. dedicated_vram_bytes )
228184}
229185
230186#[ cfg( target_os = "windows" ) ]
231- fn windows_video_controllers ( ) -> Vec < ( String , u64 ) > {
232- let Some ( output) = windows_command_output (
233- "powershell" ,
234- & [
235- "-NoProfile" ,
236- "-Command" ,
237- "Get-CimInstance Win32_VideoController | Select-Object Name,AdapterRAM | ConvertTo-Json -Compress" ,
238- ] ,
239- ) else {
240- return Vec :: new ( ) ;
187+ fn dxgi_adapters ( ) -> Vec < DxgiAdapterInfo > {
188+ use windows:: Win32 :: Graphics :: Dxgi :: {
189+ CreateDXGIFactory1 , IDXGIFactory1 , DXGI_ADAPTER_FLAG_SOFTWARE ,
241190 } ;
242- parse_windows_video_controller_catalog_json ( & output)
243- }
244-
245- #[ cfg( target_os = "windows" ) ]
246- fn parse_windows_video_controller_catalog_json ( output : & str ) -> Vec < ( String , u64 ) > {
247- fn ram ( value : & serde_json:: Value ) -> Option < u64 > {
248- value
249- . as_u64 ( )
250- . or_else ( || value. as_str ( ) . and_then ( |s| s. trim ( ) . parse ( ) . ok ( ) ) )
251- }
252191
253- let parse_one = |controller : WindowsVideoController | {
254- let name = controller. name ?. trim ( ) . to_string ( ) ;
255- let bytes = ram ( & controller. adapter_ram ?) ?;
256- ( bytes > 0 && !name. is_empty ( ) ) . then_some ( ( name, bytes) )
192+ let Ok ( factory) = ( unsafe { CreateDXGIFactory1 :: < IDXGIFactory1 > ( ) } ) else {
193+ return Vec :: new ( ) ;
257194 } ;
258195
259- if let Ok ( controller) = serde_json:: from_str :: < WindowsVideoController > ( output) {
260- return parse_one ( controller) . into_iter ( ) . collect ( ) ;
196+ let mut adapters = Vec :: new ( ) ;
197+ let mut index = 0 ;
198+ while let Ok ( adapter) = unsafe { factory. EnumAdapters1 ( index) } {
199+ index += 1 ;
200+ let Ok ( desc) = ( unsafe { adapter. GetDesc1 ( ) } ) else {
201+ continue ;
202+ } ;
203+ adapters. push ( DxgiAdapterInfo {
204+ name : utf16_description ( & desc. Description ) ,
205+ dedicated_vram_bytes : desc. DedicatedVideoMemory as u64 ,
206+ software : ( desc. Flags & DXGI_ADAPTER_FLAG_SOFTWARE . 0 as u32 ) != 0 ,
207+ } ) ;
261208 }
262- serde_json:: from_str :: < Vec < WindowsVideoController > > ( output)
263- . map ( |controllers| controllers. into_iter ( ) . filter_map ( parse_one) . collect ( ) )
264- . unwrap_or_default ( )
209+ adapters
265210}
266211
267212#[ cfg( target_os = "windows" ) ]
268- fn summarize_gpu_names ( names : & [ String ] ) -> Option < String > {
269- match names {
270- [ ] => None ,
271- [ one] => Some ( one. clone ( ) ) ,
272- _ => Some ( format ! ( "{} GPUs" , names. len( ) ) ) ,
273- }
213+ fn utf16_description ( value : & [ u16 ] ) -> String {
214+ let len = value. iter ( ) . position ( |ch| * ch == 0 ) . unwrap_or ( value. len ( ) ) ;
215+ String :: from_utf16_lossy ( & value[ ..len] ) . trim ( ) . to_string ( )
274216}
275217
276218fn installed_names ( ) -> Vec < ( String , String ) > {
@@ -337,7 +279,8 @@ fn build_catalog(
337279 } ) ;
338280 }
339281
340- let recommended = Some ( buzz_recommended_model ( rated_capacity_gb ( vram_bytes) ) . to_string ( ) ) ;
282+ let recommended =
283+ ( vram_bytes > 0 ) . then ( || buzz_recommended_model ( rated_capacity_gb ( vram_bytes) ) . to_string ( ) ) ;
341284 for entry in & mut entries {
342285 entry. recommended = recommended. as_deref ( ) == Some ( entry. name . as_str ( ) ) ;
343286 // Both curated tiers are always offered: the recommended one for this
@@ -356,7 +299,11 @@ fn build_catalog(
356299
357300 MeshModelCatalog {
358301 gpu_name,
359- vram_display : format_rated_capacity ( vram_bytes) ,
302+ vram_display : if vram_bytes > 0 {
303+ format_rated_capacity ( vram_bytes)
304+ } else {
305+ "Unknown" . to_string ( )
306+ } ,
360307 vram_gb,
361308 recommended,
362309 entries,
@@ -386,6 +333,7 @@ mod tests {
386333 assert_eq ! ( fit_code( 10.0 , 12.0 ) , ModelFit :: Tight ) ;
387334 assert_eq ! ( fit_code( 10.0 , 10.0 ) , ModelFit :: Tradeoff ) ;
388335 assert_eq ! ( fit_code( 10.0 , 8.0 ) , ModelFit :: TooLarge ) ;
336+ assert_eq ! ( fit_code( 10.0 , 0.0 ) , ModelFit :: Unknown ) ;
389337 }
390338
391339 #[ test]
@@ -434,27 +382,62 @@ mod tests {
434382
435383 #[ cfg( target_os = "windows" ) ]
436384 #[ test]
437- fn windows_catalog_uses_dedicated_gpu_vram_not_system_offload ( ) {
438- let ( names, bytes) = parse_nvidia_smi_catalog_output ( "NVIDIA GeForce RTX 5060 Ti, 16376\n " )
439- . expect ( "nvidia-smi row parses" ) ;
440- assert_eq ! ( names, vec![ "NVIDIA GeForce RTX 5060 Ti" ] ) ;
441- assert_eq ! ( bytes, 16_376 * 1024 * 1024 ) ;
442- assert_eq ! ( format_rated_capacity( bytes) , "16 GB" ) ;
385+ fn windows_catalog_uses_max_dedicated_adapter_vram ( ) {
386+ let adapters = vec ! [
387+ DxgiAdapterInfo {
388+ name: "AMD Radeon RX 7600 XT" . to_string( ) ,
389+ dedicated_vram_bytes: 16 * 1024 * 1024 * 1024 ,
390+ software: false ,
391+ } ,
392+ DxgiAdapterInfo {
393+ name: "NVIDIA GeForce RTX 4060" . to_string( ) ,
394+ dedicated_vram_bytes: 8 * 1024 * 1024 * 1024 ,
395+ software: false ,
396+ } ,
397+ ] ;
398+ let selected = select_catalog_adapter ( & adapters) . expect ( "adapter selected" ) ;
399+ assert_eq ! ( selected. name, "AMD Radeon RX 7600 XT" ) ;
400+ // The catalog ranks what fits on one adapter, not pooled multi-GPU VRAM.
401+ assert_eq ! ( selected. dedicated_vram_bytes, 16 * 1024 * 1024 * 1024 ) ;
402+ assert_eq ! (
403+ format_rated_capacity( selected. dedicated_vram_bytes) ,
404+ "16 GB"
405+ ) ;
406+ }
407+
408+ #[ test]
409+ fn unknown_vram_does_not_mark_entries_too_large ( ) {
410+ let catalog = build_catalog ( None , 0 , 0.0 , & [ ] ) ;
411+ assert_eq ! ( catalog. vram_display, "Unknown" ) ;
412+ assert ! ( catalog. recommended. is_none( ) ) ;
413+ assert ! ( catalog
414+ . entries
415+ . iter( )
416+ . all( |entry| entry. fit == ModelFit :: Unknown ) ) ;
443417 }
444418
445419 #[ cfg( target_os = "windows" ) ]
446420 #[ test]
447- fn windows_catalog_parses_cim_video_controller_json ( ) {
448- let controllers = parse_windows_video_controller_catalog_json (
449- r#"[{"Name":"GPU A","AdapterRAM":8589934592},{"Name":"GPU B","AdapterRAM":"4294967296"}]"# ,
450- ) ;
451- assert_eq ! (
452- controllers,
453- vec![
454- ( "GPU A" . to_string( ) , 8_589_934_592 ) ,
455- ( "GPU B" . to_string( ) , 4_294_967_296 )
456- ]
457- ) ;
421+ fn windows_catalog_ignores_software_and_zero_vram_adapters ( ) {
422+ let adapters = vec ! [
423+ DxgiAdapterInfo {
424+ name: "Microsoft Basic Render Driver" . to_string( ) ,
425+ dedicated_vram_bytes: 32 * 1024 * 1024 * 1024 ,
426+ software: true ,
427+ } ,
428+ DxgiAdapterInfo {
429+ name: "DisplayLink" . to_string( ) ,
430+ dedicated_vram_bytes: 0 ,
431+ software: false ,
432+ } ,
433+ DxgiAdapterInfo {
434+ name: "AMD Radeon RX 7600 XT" . to_string( ) ,
435+ dedicated_vram_bytes: 16 * 1024 * 1024 * 1024 ,
436+ software: false ,
437+ } ,
438+ ] ;
439+ let selected = select_catalog_adapter ( & adapters) . expect ( "hardware adapter selected" ) ;
440+ assert_eq ! ( selected. name, "AMD Radeon RX 7600 XT" ) ;
458441 }
459442
460443 #[ test]
0 commit comments