nx_resource_arbiter_test.nx source
↩ module page · 124 lines · 6687 B
1// nx_resource_arbiter_test.nx -- smoke for nx_resource_arbiter.
2
3import "nx_syscalls.nx"
4import "nx_resource_arbiter.nx"
5
6func main() -> i64 {
7 let now: nx_size = 1000000
8
9 // Single out-param for granted units
10 let out_buf: *u8 = sys_mmap(8)
11 let out_g: *i64 = out_buf as *i64
12
13 // 1: enum validity
14 if nx_ra_kind_is_valid(NX_RA_KIND_VRAM_BYTES) != 1 { return 1 }
15 if nx_ra_kind_is_valid(NX_RA_KIND_FILE_HANDLES) != 1 { return 2 }
16 if nx_ra_kind_is_valid(-1) != 0 { return 3 }
17 if nx_ra_kind_is_valid(7) != 0 { return 4 }
18 if NX_RA_KIND_N != 7 { return 5 }
19
20 if nx_ra_v_is_valid(NX_RA_V_GRANTED_FULL) != 1 { return 6 }
21 if nx_ra_v_is_valid(NX_RA_V_DENIED_PREEMPTED) != 1 { return 7 }
22
23 // 2: construction
24 let a: *NxResourceArbiter = nx_ra_new(32)
25 if a.capacity != 32 { return 8 }
26 if a.n_allocations != 0 { return 9 }
27
28 if nx_ra_new(0) != (0 as *NxResourceArbiter) { return 10 }
29
30 // 3: request with no budget -> DENIED_NO_BUDGET
31 if nx_ra_request(a, 100, NX_RA_KIND_VRAM_BYTES, 1000, 50, 0, out_g, now) != NX_RA_V_DENIED_NO_BUDGET { return 11 }
32 if out_g[0] != 0 { return 12 }
33
34 // 4: set budget + max_share
35 if nx_ra_set_budget(a, NX_RA_KIND_VRAM_BYTES, 10000) != NX_RA_V_GRANTED_FULL { return 13 }
36 if nx_ra_set_max_share(a, NX_RA_KIND_VRAM_BYTES, 717) != NX_RA_V_GRANTED_FULL { return 14 } // 70%
37 if nx_ra_get_budget(a, NX_RA_KIND_VRAM_BYTES) != 10000 { return 15 }
38
39 // 5: invalid set_budget
40 if nx_ra_set_budget(a, 99, 1000) != NX_RA_V_INVALID { return 16 }
41 if nx_ra_set_max_share(a, NX_RA_KIND_VRAM_BYTES, 0) != NX_RA_V_INVALID { return 17 }
42 if nx_ra_set_max_share(a, NX_RA_KIND_VRAM_BYTES, 1025) != NX_RA_V_INVALID { return 18 }
43
44 // 6: simple full grant (1000 bytes, well under 70% of 10000=7000)
45 if nx_ra_request(a, 100, NX_RA_KIND_VRAM_BYTES, 1000, 50, 0, out_g, now) != NX_RA_V_GRANTED_FULL { return 19 }
46 if out_g[0] != 1000 { return 20 }
47 if nx_ra_total_held(a, NX_RA_KIND_VRAM_BYTES) != 1000 { return 21 }
48 if nx_ra_held_by_cell(a, 100, NX_RA_KIND_VRAM_BYTES) != 1000 { return 22 }
49 if nx_ra_grants_full(a) != 1 { return 23 }
50
51 // 7: same cell requests more, would bring total to 8000 -> exceeds 70% cap -> DENIED_MAX_SHARE.
52 // denials counter now 2 (the budget=0 test at assertion 11 was the first).
53 if nx_ra_request(a, 100, NX_RA_KIND_VRAM_BYTES, 7000, 50, 0, out_g, now) != NX_RA_V_DENIED_MAX_SHARE { return 24 }
54 if nx_ra_denials(a) != 2 { return 25 }
55
56 // 8: same cell requests amount that brings total to exactly 70% cap (7000-1000=6000 more)
57 if nx_ra_request(a, 100, NX_RA_KIND_VRAM_BYTES, 6000, 50, 0, out_g, now) != NX_RA_V_GRANTED_FULL { return 26 }
58 if out_g[0] != 6000 { return 27 }
59 if nx_ra_held_by_cell(a, 100, NX_RA_KIND_VRAM_BYTES) != 7000 { return 28 }
60
61 // 9: different cell can still get the remaining 3000
62 if nx_ra_request(a, 200, NX_RA_KIND_VRAM_BYTES, 2000, 40, 0, out_g, now) != NX_RA_V_GRANTED_FULL { return 29 }
63 if out_g[0] != 2000 { return 30 }
64 if nx_ra_total_held(a, NX_RA_KIND_VRAM_BYTES) != 9000 { return 31 }
65
66 // 10: third cell wants 2000 but only 1000 left in budget -> partial
67 if nx_ra_request(a, 300, NX_RA_KIND_VRAM_BYTES, 2000, 30, 0, out_g, now) != NX_RA_V_GRANTED_PARTIAL { return 32 }
68 if out_g[0] != 1000 { return 33 }
69 if nx_ra_grants_partial(a) != 1 { return 34 }
70 if nx_ra_total_held(a, NX_RA_KIND_VRAM_BYTES) != 10000 { return 35 }
71
72 // 11: fourth cell totally denied
73 if nx_ra_request(a, 400, NX_RA_KIND_VRAM_BYTES, 1, 30, 0, out_g, now) != NX_RA_V_DENIED_NO_BUDGET { return 36 }
74
75 // 12: release
76 if nx_ra_release(a, 200, NX_RA_KIND_VRAM_BYTES) != 2000 { return 37 }
77 if nx_ra_total_held(a, NX_RA_KIND_VRAM_BYTES) != 8000 { return 38 }
78 if nx_ra_held_by_cell(a, 200, NX_RA_KIND_VRAM_BYTES) != 0 { return 39 }
79
80 // 13: preempt -- requesting_priority=80 reclaims units from cells with priority<80,
81 // stopping as soon as 4000 is reached. Cell 100 has two allocations of 1000 and
82 // 6000 (priority 50). iteration reclaims 1000 then 6000 = 7000 (>=4000, stop).
83 // Cell 300's 1000 is NOT touched because preempt is satisfied.
84 if nx_ra_preempt(a, NX_RA_KIND_VRAM_BYTES, 80, 4000) != 7000 { return 40 }
85 if nx_ra_preemptions(a) != 2 { return 41 }
86 if nx_ra_total_held(a, NX_RA_KIND_VRAM_BYTES) != 1000 { return 42 }
87
88 // 14: preempt with no eligible victims returns 0
89 let a2: *NxResourceArbiter = nx_ra_new(8)
90 nx_ra_set_budget(a2, NX_RA_KIND_RAM_BYTES, 10000)
91 nx_ra_request(a2, 1, NX_RA_KIND_RAM_BYTES, 5000, 90, 0, out_g, now)
92 // requester priority 50 < holder priority 90 -> no preemption possible
93 if nx_ra_preempt(a2, NX_RA_KIND_RAM_BYTES, 50, 1000) != 0 { return 43 }
94
95 // 15: invalid request inputs
96 if nx_ra_request(a, 0, NX_RA_KIND_VRAM_BYTES, 100, 50, 0, out_g, now) != NX_RA_V_INVALID { return 44 }
97 if nx_ra_request(a, 100, 99, 100, 50, 0, out_g, now) != NX_RA_V_INVALID { return 45 }
98 if nx_ra_request(a, 100, NX_RA_KIND_VRAM_BYTES, 0, 50, 0, out_g, now) != NX_RA_V_INVALID { return 46 }
99
100 // 16: capacity exceeded. Use a fresh arbiter with capacity 2.
101 let a_full: *NxResourceArbiter = nx_ra_new(2)
102 nx_ra_set_budget(a_full, NX_RA_KIND_DISK_BYTES, 100000)
103 nx_ra_set_max_share(a_full, NX_RA_KIND_DISK_BYTES, 1024) // allow 100% per cell
104 nx_ra_request(a_full, 1, NX_RA_KIND_DISK_BYTES, 10, 0, 0, out_g, now)
105 nx_ra_request(a_full, 2, NX_RA_KIND_DISK_BYTES, 10, 0, 0, out_g, now)
106 if nx_ra_request(a_full, 3, NX_RA_KIND_DISK_BYTES, 10, 0, 0, out_g, now) != NX_RA_V_DENIED_NO_BUDGET { return 47 }
107
108 // 17: null handling
109 let null_a: *NxResourceArbiter = (0 as i64) as *NxResourceArbiter
110 let null_out: *i64 = (0 as i64) as *i64
111 if nx_ra_request(null_a, 1, NX_RA_KIND_VRAM_BYTES, 100, 50, 0, out_g, now) != NX_RA_V_NULL { return 48 }
112 if nx_ra_request(a, 1, NX_RA_KIND_VRAM_BYTES, 100, 50, 0, null_out, now) != NX_RA_V_NULL { return 49 }
113 if nx_ra_set_budget(null_a, NX_RA_KIND_VRAM_BYTES, 100) != NX_RA_V_NULL { return 50 }
114 if nx_ra_set_max_share(null_a, NX_RA_KIND_VRAM_BYTES, 717) != NX_RA_V_NULL { return 51 }
115 if nx_ra_get_budget(null_a, NX_RA_KIND_VRAM_BYTES) != 0 { return 52 }
116 if nx_ra_total_held(null_a, NX_RA_KIND_VRAM_BYTES) != 0 { return 53 }
117 if nx_ra_held_by_cell(null_a, 1, NX_RA_KIND_VRAM_BYTES) != 0 { return 54 }
118 if nx_ra_release(null_a, 1, NX_RA_KIND_VRAM_BYTES) != 0 { return 55 }
119 if nx_ra_preempt(null_a, NX_RA_KIND_VRAM_BYTES, 80, 100) != 0 { return 56 }
120 if nx_ra_grants_full(null_a) != 0 { return 57 }
121 if nx_ra_denials(null_a) != 0 { return 58 }
122
123 return 0
124}