its all compile time
#uACPI - a portable and easy-to-integrate ACPI implementation
left orbit
frank canopy
ive got intrusive singly and doubly linked lists in zig in my kernel under bsd 0-clause btw, separate license from the rest of the project
yeah its great
you cant put decls on types at comptime only fields but its still great
fiery turtle
Are there macros
left orbit
nope
frank canopy
no macros only comptime
fiery turtle
you cant put decls on types at comptime only fields but its still great
What does this mean
left orbit
no new functions on types
frank canopy
decls are type-scoped things that arent fields
fiery turtle
Hm
frank canopy
you cant create a type with reflection that has decls is the only major limit
left orbit
and if you do you can somewhat easily work around that
frank canopy
and yeah ive never needed it either
fiery turtle
Is that like a compiler limitation or on purpose
left orbit
if i had to guess i'd say both
frank canopy
technically a not implemented but it looks like itll be made on purpose yeah
theres an open gh issue with a debate on whether to implement it or make it actually illegal
left orbit
i can't think of a way to create functions at compile time
fiery turtle
Interesting
left orbit
and functions are decls so
frank canopy
theres a proposed builtin called unrollArgumentTuple that would take a function with a tuple argument and return a function with one argument per tuple element
fiery turtle
Ill definitely try writing something in zig tomorrow just to see how it feels
frank canopy
and you can use a comptime switch to implement it yourself
left orbit
day 0 of asking for an ultra rewrite in zig
fiery turtle
day 0 of asking for an ultra rewrite in zig
Its like a barenones kernel that prints one message to e9 💀
frank canopy
the other thing to note with zig is that varargs only exist for c binding compat - to make a varargs zig function you take a tuple and use anytype to let it specialize per tuple combination
left orbit
Its like a barenones kernel that prints one message to e9 💀
that's a good start
now implement everything else
north holly
day 0 of asking for ultra
left orbit
and make it run wayland
fiery turtle
Bash before obos
frank canopy
the downside of that tuples for varargs bit is that std fmt generates generic specializations for every combination of argument types which can cause some binary size bloat - theres an open issue there too iirc
left orbit
let's make it happen 🔥
fiery turtle
the other thing to note with zig is that varargs only exist for c binding compat...
So like c++ templates
left orbit
lmao
frank canopy
So like c++ templates
a bit yeah
left orbit
it's still probably better than std::format lmao
north holly
assuming ttys aren't too confusing, I should get bash by the new year
fiery turtle
Lfg 2026 
left orbit
it's still probably better than std::format lmao
and iostream
iostream is a disgrace to humanity
north holly
iostream is a disgrace to humanity
this
frank canopy
for reference on the linked list question btw, https://github.com/Khitiara/imaginarium/blob/main/src/util/queue.zig heres my impl that i use basically everywhere in my kernel lol
fiery turtle
Iostream is truly disgusting
frank canopy
it really is lol
left orbit
petition to the c++ committee to remove iostream in c++29 or whatever
median crest
and make it run wayland
no
north holly
what dumbass in the C++ committee decided to add it in the first place
fiery turtle
for reference on the linked list question btw, <https://github.com/Khitiara/imag...
Is ? Like Optional
north holly
and what dumbass(es) decided to accept it
median crest
assuming ttys aren't too confusing, I should get bash by the new year
they arent that bad
fiery turtle
Why do you want both ? And a pointer
frank canopy
Is ? Like Optional
its even called optional
left orbit
.? is like rust unwrap
north holly
the api is dogshit lol
are you talking about ttys or smth else
frank canopy
Why do you want both ? And a pointer
an optional pointer automatically uses 0 as null
left orbit
you can have ?T which is a nullable T
fiery turtle
Ah so there's no hidden fields there?
frank canopy
so ?* is more like a nullable pointer than it is an optional-of-pointer
median crest
tty.c in astral is 550 lines ~~if you ignore the 611 lines signal.c and 430 lines of jobctl.c 
~~
frank canopy
an optional not-pointer requires one extra hidden field but optional pointers dont
left orbit
and you can also have !T which is an error union, basically T with an addiitonal error value passed together
fiery turtle
Makes sense
slim panther
that's what i do
median crest
what if I don't implement TTYs, but always return false from `sys_isatty`
good luck doing anything other than simple programs
frank canopy
technically SomeErrorSet!T is an error union, !T by itself infers the error set
fiery turtle
and you can also have !T which is an error union, basically T with an addiitonal...
Are errors standardized
left orbit
and E!T is a T with an explicit error union type
they are user defined
you can return error.MyError
left orbit
and it adds MyError to the global error set, which is the default
yeah but it's a global enum sort of
fiery turtle
Wait u can do that
frank canopy
an error set is a subset of the global error set which is every error in the program
fiery turtle
What if I make a typo and add a new bogus error
left orbit
every type that doesnt use an explicit error set uses the global error set anyerror
left orbit
What if I make a typo and add a new bogus error
use an explicit error set :^)
const MyErrorSet = error { A, B, C };
fiery turtle
Interesting
frank canopy
and the global error set gets mapped onto a 16-bit int internally but the mapping isnt reliable
left orbit
anyerror is more of a convenience i'd say
fiery turtle
Can u store extra info in there?
left orbit
sadly not
frank canopy
if you return an error not in the explicit set you have then its a compile error
nope, its errors in the same way a status enum is
frank canopy
if you want extra info do it the C way and have a function to get extra info
which you store in a threadlocal global or something
frank canopy
you can get a stack trace for the error with a builtin though which is usually enough to debug things, or also catch errors and return more specific ones in intermediate stages
as long as you stay below 2^16 error names total its fine
fiery turtle
U can get an original backtrace of the error when it’s propagated down?
frank canopy
yeah
fiery turtle
Damn
fiery turtle
as long as you stay below 2^16 error names total its fine
Why does it matter?
frank canopy
Why does it matter?
the compiler bakes the global error set into a u16-backed enum basically. i think you can change the size though somewhere
any function that returns an error takes a hidden parameter of type *StackTrace and appends its current rip to the trace before calling an error-returning function or returning its own error
left orbit
65k errors ought to be enough for anybody
frank canopy
and then you can get that trace with @errorReturnTrace
fiery turtle
any function that returns an error takes a hidden parameter of type `*StackTrace...
Ohh
left orbit
also defer and errdefer are beautiful
frank canopy
though the builtin returns an optional trace because that whole thing gets elided if you run optimized modes with error tracing turned off
gods yeah defer and errdefer rule
left orbit
errdefer is defer which runs if the function returns an error
frank canopy
block not function
fiery turtle
Really nice yeah
frank canopy
defer statements run in reverse order when the block theyre in is exited by any means
left orbit
zig has been successfully shilled
frank canopy
lol
fiery turtle
`defer` statements run in reverse order when the block theyre in is exited by an...
What about errdefer
frank canopy
What about errdefer
same thing but only if the block returns by returning an error. useful for stuff that allocates something and then initializes and returns it - if the init code errors you can free the partially-initialized object with errdefer
fiery turtle
`defer` statements run in reverse order when the block theyre in is exited by an...
I mean this makes sense, same as c++ destructors
fiery turtle
same thing but only if the block returns by returning an error. useful for stuff...
Yeah I can appreciate that
frank canopy
my favorite use for defer is for locks and for frees - put the free with the alloc or the unlock with the lock in the source and guarantee itll still go in the right order and everything
left orbit
yeah it's amazing
frank canopy
i think what actually convinced me to try zig was still the bit-packed structs though tbh
i think C has those now too but idk
fiery turtle
my favorite use for defer is for locks and for frees - put the free with the all...
Yeah
fiery turtle
i think what actually convinced me to try zig was still the bit-packed structs t...
Hm?
Like bitfields?
frank canopy
yeah
left orbit
also arbitrarily sized integers
fiery turtle
Yeah C has that but in broken ways
left orbit
u5 is a thing
frank canopy
zig technically has every signed and unsigned int size from 0 bits to 65536 bits (idk why that big) and inside a packed struct any of those things take up exactly that many bits
instead of rounding up to bytes
frank canopy
also inside a packed struct a bool becomes 1 bit
fiery turtle
u5 is a thing
I remember that breaking llvm in some way
left orbit
zig is probably a big fucking benchmark and test case for llvm lmao
frank canopy
idk if it actually works for big int, i remember some crashing issues for ints bigger than whatever your biggest register can support
and yeah lol zig runs on llvm atm
fiery turtle
zig is probably a big fucking benchmark and test case for llvm lmao
Yeah
frank canopy
outside a packed struct, a u5 is a u8 but in safe modes it gets its overflow checks for 5 bits of size. inside a packed struct u5 is a 5-bit-wide bitfield
packed structs are backed by integers to and you can cast both ways there
basically means my page table entry struct looks like this and just works
left orbit
you really should give zig a go, not even for osdev :)
fiery turtle
Very cool
fiery turtle
you really should give zig a go, not even for osdev :)
Yeah
frank canopy
packed unions are untagged unions of packed things, and in this case Pfi and PtePfiPad are int types determined by comptime from the physical addr width and page size
left orbit
but a new osdev project that has a chance of getting off would be cool
frank canopy
if you do decide to do zig osdev i have fully working uacpi integration in zig already you can steal lmao
left orbit
if you do decide to do zig osdev there's my https://github.com/48cf/limine-zig-template and https://github.com/48cf/limine-zig you can use as reference
i might try to make a hyper-template too
never looked at it but it might be fun
frank canopy
i still might grab limine-zig someday if i decide to switch off of bootelf
fiery turtle
Lol thanks, ill definitely be taking a look
left orbit
i still might grab limine-zig someday if i decide to switch off of bootelf
if you find anything missing or wrong just lmk i will fix it as fast as i can
i dont really keep it up to date because i dont do much osdev, especially in zig
fiery turtle
Nice
fiery turtle
Good to hear
frank canopy
yeah
im running nightlies and have had nearly zero issues with zig itself
plenty of issues with my kernel being bad but thats separate lol
fiery turtle
Lol
slim panther
bro is looking for a dtb on x86
kind mantle
Well that's kinda what happens in the early stages of adding AMD64 support to a RISC-V kernel.
Anyway, I'll make sure to run the uACPI benchmark thingy as well ;)
left orbit
i was bored lol, here it is https://github.com/48cf/hyper-zig-template
no proper hyper bindings but cimport did well :^)
even the ULTRA_NEXT_ATTRIBUTE macro was translated which is pretty cool
left orbit
if i was i would make proper hyper bindings
(i will at some point tomorrow)
(yes i want to see ultra-zig )
left orbit
i was bored lol, here it is <https://github.com/48cf/hyper-zig-template>
also i have no idea how to actually do all that hyper stuff, i just kind of freestyled it hoping it would work which it did :^)
north holly
I mean lgtm
fiery turtle
It's (BadgerOS) uACPI time!
fiery turtle
i was bored lol, here it is <https://github.com/48cf/hyper-zig-template>
Lol, thats pretty cool
fiery turtle
(yes i want to see ultra-zig <:meme:575445094589661215>)
Btw the protocol is called ultra 
fiery turtle
also i have no idea how to actually do all that hyper stuff, i just kind of free...
Yeah looks pretty good to me
Ideally it should be higher half exclusive I guess
torpid root
Btw the protocol is called ultra <:ultrameme:729026898666979428>
billions must rename repos
gentle peak
what a coincidence, i currently happen to be working on implementing realloc efficiently
it's not going to be that much faster than just normal kalloc+kfree, because of some of the general constraints of my allocator
(each heap page needs to have the same power-of-two size for each object, so shrinking/expanding an object beyond its current power-of-two size requires kalloc+memcpy+kfree)
but for ranges that end up using vmalloc_large, it should have a good impact
gentle peak
@fiery turtle just by making dynamic arrays use realloc, proxima's score went from 5.1M to 5.6M
fiery turtle
<@353593948523986945> just by making dynamic arrays use realloc, proxima's score...
did you hack uacpi's dynamic array to use them?
gentle peak
yeah
fiery turtle
damn
it also grows only by one element each time, i wonder if making this constant configurable could improve perf
gentle peak
oh definitely
if a dynamic array doubles its capacity when growing instead of just adding space for one element, its insert performance is amortized to O(1) iirc
fiery turtle
hmm
vagrant hull
it used to be terrible but its good
right, that, and a million other lies
gentle peak
here's the patch i used for getting dynamic array to use realloc btw https://hst.sh/piroloyahu.php
fiery turtle
makes sense
fiery turtle
right, that, and a million other lies
wdym
gentle peak
if a dynamic array doubles its capacity when growing instead of just adding spac...
if i make it do this (combined with realloc) proxima's score goes to 5.9M
fiery turtle
nice, I guess an optional realloc is useful to have
gentle peak
the combined patch: https://hst.sh/ojofuluhit.php
fiery turtle
nothing dw just me being salty at zig's lack of stability
did u find it unstable?
vagrant hull
i did not use it but i was at the receiving end of many reports when the limine-zig-template was part of the limine organisation
which is the main reason why i transferred it to czapek
fiery turtle
ah
loud ice
right, that, and a million other lies
nah its true afaik
it used to be that the language is cool but the compiler is buggy
and now they have a working compiler and a shitty language
left orbit
basically
rustic compass
In rust you get that automatically when implementing the allocator trait
left orbit
In rust you get that automatically when implementing the allocator trait
you also actually have to implement it
gentle peak
In rust you get that automatically when implementing the allocator trait
not really, you get a default impl that does alloc+memcpy+free
rustic compass
Nope mandatory is only alloc and free
left orbit
Nope mandatory is only alloc and free
well yeah but you don’t just “get one” is what i’m trying to say 😅
fiery turtle
@gentle peak btw for those measurements, did you look into the hit/miss rate of how many allocations were able to get resized, and where they came from etc?
rustic compass
well yeah but you don’t just “get one” is what i’m trying to say 😅
Yea the allocator has to actually implement it to be usefull but when you change yours to be able to do so you don't have to recheck all allocation sites
gentle peak
<@938223886439436320> btw for those measurements, did you look into the hit/miss...
i didn't
for the former i assume not that many because all of them were getting routed to kalloc which has very strict requirements for actually resizing vs copying+freeing
fiery turtle
interesting
left orbit
basically
also, most complaints about limine-zig not working were because of the big changes to the build api at the time, the rest were probably me not updating the thing lol
gentle peak
<@938223886439436320> btw for those measurements, did you look into the hit/miss...
some basic measurements:
vmrealloc: 301 calls, 271 with orig == NULL (routed to vmalloc), 30 routed to krealloc
krealloc: 30 calls, 0 successfully resized
i really have no idea where the speedup came from considering all of them were alloc+copy+free anyway
fiery turtle
lmao
gentle peak
actually maybe that's because this is with both realloc and dynamic array doubling
i wonder what it'd be like if it expanded by one at a time
fiery turtle
yeah the x2 growth probably allocates way too much
so u get way less allocations and hence the perf improves
gentle peak
not just that
2x growth guarantees that the new allocation won't fit in the same power-of-two bucket
fiery turtle
and that yeah
gentle peak
so krealloc can never resize the allocation
ok disabled the 2x growth
vmrealloc: 1823 calls, 271 with orig == NULL (routed to vmalloc), 1552 routed to krealloc
krealloc: 1552 calls, 980 successfully resized, 572 kalloc+memcpy+kfree
gentle peak
yeah
on the other hand
i just tested with only dynamic array doubling and not realloc
it's still 5.9M
fiery turtle
lmao
gentle peak
dynamic array doubling + realloc was also 5.9M, and just realloc was 5.6M
fiery turtle
well realloc is basically a no-op for x2 growth as we've found out
fiery turtle
id imagine for most implemetations, at least slab-like allocators
gentle peak
anyway this should be a pretty good universal performance improvement ```patch
diff --git a/include/uacpi/internal/dynamic_array.h b/include/uacpi/internal/dynamic_array.h
index 8135d7e..a68c1d6 100644
--- a/include/uacpi/internal/dynamic_array.h
+++ b/include/uacpi/internal/dynamic_array.h
@@ -65,8 +65,8 @@
void *new_buf;
type_size = sizeof(*arr->dynamic_storage); \
-
bytes = arr->dynamic_capacity * type_size; \ -
bytes += type_size; \
-
bytes = arr->dynamic_capacity * type_size * 2; \ -
if (bytes == 0) bytes = type_size * 8; \ \ new_buf = uacpi_kernel_alloc(bytes); \ if (!new_buf) \
might need per-instance tuning, some of those are pretty huge structs
especially call_stack
or call_frame sorry
fiery turtle
oh yeah 1840 bytes per element
yup
gentle peak
maybe add a parameter to the dynamic array macro that specifies the initial capacity?
fiery turtle
i was also thinking of caching execution_context and reusing them for further eval's, since that thing is 2 pages almost
gentle peak
or even a parameter that enables/disables the doubling growth
fiery turtle
maybe add a parameter to the dynamic array macro that specifies the initial capa...
yeah thats what i was thinking
fiery turtle
or even a parameter that enables/disables the doubling growth
yup
or like that takes in a growth "functor"
gentle peak
yeah thats what i was thinking
oh wait you already have that effectively because it first uses inline storage
fiery turtle
yup
gentle peak
i wonder if the call frame dynamic array ever even starts using dynamic storage
fiery turtle
depends how deep qemu's AML nests
probably never
i fine tuned these to have inline storage that should cover hopefully at least 80% of real life aml
so first 4 function calls are free
(nested that is)
gentle peak
yeah i overlooked that
then the initial capacity for the dynamic storage should probably not be 8 lmao
fiery turtle
maybe the size of inline storage
gentle peak
oh yeah that'd effectively continue the doubling
fiery turtle
basically yeah
and from there it could be any other algo
maybe += initial_capacity / 2
gentle peak
iirc the O(1) amortization applies as long as the new capacity is a factor of the previous one
fiery turtle
do you not grow arrays by 2x?
yes because it would be a 10k byte allocation for some of them right away
i cant just blindly 2x
loud ice
also you should move uacpi_shareable_unref_and_delete_if_last, uacpi_shareable_unref and uacpi_shareable_ref into a header
loud ice
also you should move uacpi_shareable_unref_and_delete_if_last, uacpi_shareable_u...
also the uacpi_bugged_shareable checks should just be an assertion
i think
fiery turtle
for some of them i can and should probably yeah, for huge strucuts i definitely dont want that, especially since exceeding inline capacity is rather rare there
loud ice
it produces hilariously bad codegen
flat badge
thats the only way to get O(1) performance in fact
to get O(1) amortized cost, it's enough to grow exponentially
the factor doesn't matter
loud ice
to get O(1) amortized cost, it's enough to grow exponentially
well yeah true
flat badge
whether it's 2 or 1.000001
loud ice
ofc
fiery turtle
it produces hilariously bad codegen
💀
loud ice
it produces hilariously bad codegen
and it never gets inlined
flat badge
(ofc 0.000001 would be stupid)
loud ice
maybe i should try getting lto working
fiery turtle
well its in a C file
fiery turtle
i was thinking half of base inline storage size each time
but could be a more sophisticated formula
gentle peak
never! this does not result in a trap
loud ice
you need it to be a factor of the previous size
gentle peak
oh discord cleared the message i was replying to
anyway the call frame array never gets into dynamic storage
fiery turtle
anyway the call frame array never gets into dynamic storage
yaeh makes sense
fiery turtle
gets significantly better if you turn on LTO btw
i guess i should move those into the header yeah
gentle peak
also if i make the initial dynamic capacity the inline capacity the score becomes 5.7-5.8M instead of 5.9M
fiery turtle
isn't that 2x as well
i mean the numbers shouldnt change from 2x unless it grows even further?
gentle peak
yeah
but the 5.9M is when the initial dynamic capacity is a constant 8
for a lot of things, that's effectively multiple doublings at once
fiery turtle
ah
thats probably the item array id guess
although it has a base cap of 8
idk actually
flat badge
you need it to be a factor of the previous size
^ pitust is right here, if you grow linearly, the total cost becomes quadratic in some cases
should definitely use a factor of the current size
gentle peak
with initial_dynamic_cap == inline_cap it's still O(1) amortized but a worse O(1)
loud ice
it has a worse constant
gentle peak
yeah
loud ice
^ pitust is right here, if you grow linearly, the total cost becomes quadratic i...
the current cost is definitely quadratic
fiery turtle
its interesting because u hardcoded 8, which happens to be the inline_cap of most used arrays
gentle peak
oh 8 just happens to be my go-to for initial cap of dynamic arrays
completely arbitrary
loud ice
8 or 16 is a pretty good choice i think
fiery turtle
no like, i dont get where we lost 200k
if its the same constant
all interpreter arrays are base 8, call frame (which is never resized as we've found out is 4)
gentle peak
when i say 5.9M btw it's more like 5.85-5.95M
i might've just gotten a bad run with inline_cap
fiery turtle
probably
fiery turtle
what if u grow by prev_size / 2?
gentle peak
it's a factor
loud ice
its just growing by 1.5 times
gentle peak
it's just a factor below 1
loud ice
thats fine
fiery turtle
below 1 would be shrinking lol
loud ice
yes lol
fiery turtle
tbh the += 1 there was probably left from a very long time ago when i was debugging it lmao
and then never reverted to x2
gentle peak
still 5.8-5.9M but the mean seems to be closer to 5.83M
fiery turtle
thats not too bad considering its way less memory used
gentle peak
bytes = arr->dynamic_capacity * type_size; \
bytes += arr->dynamic_capacity / 2 * type_size; \
if (bytes == 0) bytes = type_size * inline_cap; \
``` this is what i'm using for that btwit's also with -O3 and LTO
fiery turtle
not sure if its feasible for AML?
feasible ig, the buffers are immutable size
loud ice
most common allocations for the benchmark thing
fiery turtle
what are the hex numbers
loud ice
the top 4
assign, control method, package, buffer
the small 0x5 byte allocs are probably ssoable?
gentle peak
i think you'd also benefit a lot from SSO tbh
what's that?
fiery turtle
assign is basically object copying
loud ice
what's that?
small string optimization
fiery turtle
what's that?
storing strings in the pointer
gentle peak
ahh
loud ice
the number 1 spot is when src->type is 2 or 3
fiery turtle
string & buffer
loud ice
and when behavior != UACPI_ASSIGN_BEHAVIOR_SHALLOW_COPY
loud ice
this is by size
so, 769 allocs of 5 byte buffers
lol
you can fit that in sso no problem
fiery turtle
yeah SSO could really help here
fiery turtle
you can't abuse copyobject to change a string inplace right?
u would overwrite it to a completely different string object
like python basically
gentle peak
AML name + null term
is the null term removable? because if you're gonna use sso for this, making it 4 bytes would be helpful for kernels that support i386
fiery turtle
like, ```
X = "asd"
Y = "def"
Z = X
CopyObject(X, Y) // doesn't set Z to "def"
`...
this does a deep copy of the string at X and stores it at label Y, the Z = X is a memcpy
gentle peak
or other 32 bit platforms for that matter, though i don't think any of them other than i386 use acpi
loud ice
this does a deep copy of the string at X and stores it at label Y, the `Z = X` i...
ah
wait
so you can't overwrite a string by reference?
fiery turtle
u can only change the characters, but not resize it
loud ice
ah
fiery turtle
so memcpy basically
or memcpy_zerout rather as uacpi calls it lol
if the thing being assigned is bigger, the rest of it is zeroed
fiery turtle
is the null term removable? because if you're gonna use sso for this, making it ...
i could just reuse one byte of the size field
there are smart ways to get 6-7 bytes of storage out of ptr + size
iirc
loud ice
you can even get more
fiery turtle
on 32 bit
loud ice
because aml names (which are the common case anyway) are super common
so you can constrain to an alphabet of \_ and A-Z
and 0-9
that's 38 symbols
fiery turtle
no like, obviously object names are stored as inline data, i dont heap allocate them, these are probably package fields or something, which are just normal string objects, but they store the aml name to look it up later
loud ice
assuming lengths are less than 2^31, you can fit 12 whole characters
loud ice
no like, obviously object names are stored as inline data, i dont heap allocate ...
well yeah
but still
fiery turtle
if u add like an AML_NAME bit or something?
fiery turtle
perhaps yeah
loud ice
apple did this kind of meme in objc :^)
fiery turtle
lol
yeah thats definitely an optimization you could do
would shave a lot of those allocs
loud ice
yeah
fiery turtle
i wonder how far that'd push the numbers lol
also if i cache execution contexts and have a small pool of them
although the benchmark is the first invocation of the interpreter so doenst matter
they're always allocated at the beginning of execute_control_method
and are 7k bytes lol
loud ice
how do you compile all the test stuff?
loud ice
they're always allocated at the beginning of execute_control_method
a single large alloc isnt that bad
the important thing is avoiding tons of small allocations
fiery turtle
cd tests/runner && mkdir build && cd build && cmake .. && make
loud ice
ah
fiery turtle
or ./run_tests.py
loud ice
btw you know that cmake .. -G Ninja && ninja can make builds go faster for free?
fiery turtle
yeye, my build times are shit because they're done over 9P anyway
loud ice
ah lol
fiery turtle
since im using wsl
io is ridiculously slow
well i could do it on the ext partition but whatever
but uacpi is small enough its not noticable
loud ice
fair enough
fiery turtle
```c
bytes = arr->dynamic_capacity * type_size; ...
I can add you to Co-authored-by or something if u would like, once i make the commit with this stuff
gentle peak
nah dw
gentle peak
i remember this question being asked but i don't remember the answer, for uacpi_kernel_wait_for_event if the timeout is 0 should it be non-blocking just like with uacpi_kernel_acquire_mutex? because right now i only implement that for mutexes
fiery turtle
yeah it should be, since you're not the first to ask that I should probably add a comment
since it's only used by AML it probably won't notice if u block it for a tiny bit, but yeah it shouldnt be
gentle peak
yeah right now it'd try to sleep for 0 tsc ticks, aka it'd be timed out immediately after blocking if the initial try was unsuccessful, but still
fiery turtle
out of my 500 blobs there isnt a single invocation of Wait with anything less than 0x05
in case u were wondering as well:
❯ grep -rni 'Wait (' -l | wc -l
114
about 20% use Event
gentle peak
huh that's more than i thought it'd be
fiery turtle
from what i've seen its used on wake, aml waits for some sort of event from firmware
maybe some initialization to finish
gentle peak
that'd make sense ig
fiery turtle
but there could be other use cases as well, you never know with these people
every blob is strange and unique in its own way
gentle peak
yeah... unique... While ((GP50 || (GP51 || (GP52 || (GP53 || (GP54 || ( GP55 || (GP56 || (GP57 || (GP60 || (GP61 || (GP62 || (GP63 || (GP66 || (GP67 || (GP70 || (GP71 || (GP93 || (GP94 || ( GPAP || (GPBP || (GPCP || (GPDP || (GPEP || (GPFP || (GPGP || (GPHP || (FCDP || (FTVP || (FQSP || (GP96 || (GP97 || ( GPD0 || (GPD1 || (GPD2 || (GPD3 || (GPD4 || (BPFE || (TPBP || (ECDS || (B1ST || B2ST)))))))))))))))))))))))))))))))))))))))))
fiery turtle
lmao
loud ice
@fiery turtle do_make_empty_object seems to leak memory?
you set buf->text to a pointer that points to 1 byte of memory
without setting the size
which is invalid
fiery turtle
Check the corresponding free
But anyway its a hack that im not sure is needed, I might take a look at it at some point
Im sure there are no leaks because I run with asan on at all times
fiery turtle
Check the corresponding free
Its special cased there basically
fiery turtle
I dont remember, probably not needed now
I think it was because the Mid operator is the only legal way to produce an empty buffer and I didnt want to add special handling for null buffers everywhere
But I dont think I actually rely on that anywhere
loud ice
also seems like handle_concatenate leaks memory?
if arg0 is UACPI_OBJECT_STRING and arg1 is UACPI_OBJECT_BUFFER
you allocate an on-stack buffer then never free it
(im trying to hack up sso into uacpi as an experiment)
ah wait nvm
i didnt see the free
fiery turtle
ye
fiery turtle
(im trying to hack up sso into uacpi as an experiment)
nice, im not sure about the complexity of that, but there have to be some pitfalls lmao
fiery turtle
aight
on my experimental branch for now but will merge along with some api changes later
fiery turtle
```c
bytes = arr->dynamic_capacity * type_size; ...
i think this breaks if inline_cap is 1
it will always grow by 0
fiery turtle
ye, ill fix it
was just making sure
if (arr->dynamic_capacity == 0) {
bytes = type_size * inline_cap;
} else {
bytes = (arr->dynamic_capacity / 2) * type_size;
if (bytes == 0)
bytes += type_size;
bytes += arr->dynamic_capacity * type_size;
}
I think this should work
gentle peak
looks right yeah
fiery turtle
how did u implement sso so fast
lmao
how many tests we talking
btw --large-tests
loud ice
tbh its probably all of them
fiery turtle
and dont forget to test 32 bits as well, there's a switch in ./run_tests
loud ice
and dont forget to test 32 bits as well, there's a switch in `./run_tests`
cant really do that on my m1 though
fiery turtle
https://paste.sr.ht/~pitust/306a5166a58fafd1f1e4385ed64e815a02607d56
ah, this is resource conversion tests
its not aml methods
calm latch
or other 32 bit platforms for that matter, though i don't think any of them othe...
You can have 32 bit kernel running on them
fiery turtle
lol yeah
fiery turtle
cant really do that on my m1 though
fair, CI will do all of that anyway
calm latch
You can have 32 bit kernel running on them
I would imagine some people could want to do that on some embedded shit or something like that where memory is limited
fiery turtle
embedded doesnt have acpi
fiery turtle
it might not even support 32 bits at EL1 or wahtever
calm latch
No, it runs 32 bit kernels
fiery turtle
ah ok
fiery turtle
also the 0xBF/0xBE thing is sketch
btw how much storage did u squeeze out of that
calm latch
Like an official raspbian up to Raspberry Pi 4 was 32 bit
calm latch
Even though raspberry pi 3 was 64 bit
loud ice
i probably forgot to zero out a buffer
calm latch
And newer revisions of raspberry pi 2
fiery turtle
you're not sure what your SSO buffer size is?
calm latch
ACPI has a lot of strings which are 5 characters ¿
gentle peak
truly 5 chars or 4 chars+null?
because from what i've seen of acpi dumps it's mostly 4c+0
calm latch
Like method names
fiery turtle
because from what i've seen of acpi dumps it's mostly 4c+0
4 + 0
well in the byte stream its litrally 4 ascii chars
there are no zeroes anywhere
fiery turtle
yeah
it has a StringOp which is zero terminated tho
and it doesnt tell u the length
so u have to strlen it
calm latch
They save memory though
fiery turtle
yeah no aml encoding is pretty good
gentle peak
if you're that desperate for mem they're fine yeah
but having the length speeds up a lot of string ops
calm latch
zero-terminated strings are terrible imo
So many bugs in all sorts of software could have been avoided if C didn't have them
fiery turtle
aml has a ByteOp + <byte> to encode bytes, but Zero, Ones or One are separate op codes which are exactly 1 byte long
calm latch
but having the length speeds up a lot of string ops
Does it that much?
gentle peak
a lot of string ops are O(1) if you have the length already
calm latch
The're so common they must be optimized very well by the compilers and whatnot
gentle peak
strlen can be optimized a lot with simd and such but it's still O(n) by nature
fiery turtle
there's a reason people use string_view etc
mortal yoke
also stuff like strcmp could have early return if the length of both strings are known
fiery turtle
yeah
gentle peak
using slices instead of zero-terminated strings also makes syscall param validation easier, not that it wasn't easy to begin with
fiery turtle
strlen_from_user
calm latch
My syscalls only take slices
gentle peak
hence the "not that it wasn't easy to begin with"
yeah same
or well they did in my previous rewrite and they will when i implement them in this one
fiery turtle
honestly syscalls should always take slices
calm latch
You can just strlen in userspace if you need it that much
calm latch
My syscalls only take slices
And it's like how strings function everywhere that's not C anyways
(I kinda don't like C)
fiery turtle
ill have to take raw strings because im going for full linux compat tho (in my kernel)
gentle peak
like binary compat?
fiery turtle
yeah
gentle peak
damn
calm latch
Can you not do that in vdso?
calm latch
Like have native API not take them
fiery turtle
also this allows me to reuse linux stuff for validation
calm latch
And then give a shim for syscalls
fiery turtle
syzkaller, fio, etc
gentle peak
i hate userspace and porting shit
i mean it's fairly simple to be linux-compatible on the source level (as long as you have all the same capabilities as linux), and once you have that porting stuff is just recompiling it
fiery turtle
and programs that work on linux in one way i can instantly spot a mismatch e.g. in strace
fiery turtle
i mean it's fairly simple to be linux-compatible on the source level (as long as...
true, still kinda dont wanna go there
calm latch
Programs that do that are stupid (?)
fiery turtle
i just want cp ./bash ./myimage
calm latch
What if Linux adds a new syscall
fiery turtle
programs wont randomly start using it
calm latch
glibc or something might
mortal yoke
and thankfully the amount of raw syscalls programs do is not that much
fiery turtle
it does that based on the kernel version or some other property
that i can just not expose
calm latch
glibc or something might
I'd imagine
fiery turtle
just return-ENOSYS and glibc will fuck off
calm latch
Idk, personally I just find making Linux clones kinda uninspiring
fiery turtle
a posix clone is somehow more inspiring?
calm latch
Posix is just a bunch of functions
fiery turtle
im mostly doing it to learn about linux internals while also focusing on drivers (the thing im interested in)
so i spend as little time as possible on userspace
calm latch
Posix is just a bunch of functions
My kernel doesn't have a single POSIX system call
I implement all of them in userspace
fiery turtle
well u still have a posix server
calm latch
I have a process server, a vfs server and pipes server
fiery turtle
a posix clone is somehow more inspiring? <:LULW:543420553021882371>
this wasnt directed at you tbh, u have a pretty unique kernel
i just dont care about uniqueness, im just doing my thing
i want 3d accel with my drivers etc
calm latch
Idk, personally I just find making Linux clones kinda uninspiring
Yeah I'm not criticizing you
fiery turtle
not interested in innovating userspace
if i can run e.g. wine + some cool windows game fully 3d accelerated on my kernel that would be an achievement for me
at least on an older igpu, like 2015 or soemthing
although there isnt that much of a difference between generations
calm latch
Is new Arc memes very different from their older iGPUs?
fiery turtle
nah
although linux is using a new driver for it
they got rid of backward compat and made a new driver that uses only new things
calm latch
There was a lot of drama with Windows drivers when the first gen launched
fiery turtle
its the exact same igpu, just with more command streamer engines lmao
mortal yoke
one nice thing about them might be that as they are dedicated things you can probably pass through them to qemu I'd imagine unlike some other newer igpus
fiery turtle
for development u should just run linux headless and pass through to qemu entirely
just ssh into it instead
calm latch
No but in theory you should full on be able to pass the GPU to Windows
While linux is not left headless
calm latch
for development u should just run linux headless and pass through to qemu entire...
Get a second GPU 
mortal yoke
I couldn't get that to work either, the south bridge registers always returned zeros on my alder lake igpu
calm latch
u can via a virtual gpu
Yeh that's what I'm talking about
gentle peak
Get a second GPU <a:spun:689344958846730333>
i have two gpus but one wide enough pcie slot unfortunately
fiery turtle
motherboard skill issue
calm latch
But it's only on server GPUs on nvidia and amd afaik
calm latch
i have two gpus but one wide enough pcie slot unfortunately
Me too
fiery turtle
i have a 4060ti so no such problems
mortal yoke
I could put a second gpu with a pcie riser cable 
though I think it would have to partially be outside the case
calm latch
PCIe connector in second slot
Free slot is occupied by serial lead, as in the stone age 
fiery turtle
I could put a second gpu with a pcie riser cable <:troll:796858892985434152> tho...
wouldnt that result in increased latencies and stuff
calm latch
I don't think this would make a difference
mortal yoke
wouldnt that result in increased latencies and stuff
I mean maybe but I don't think its that much, I used to use a gpu like that when I had even smaller case than I do now
calm latch
There's also Thunderbolt/USB 4 memes
fiery turtle
i mean there's a reason u put your gpu to the pcie slot closer to the cpu
calm latch
i mean there's a reason u put your gpu to the pcie slot closer to the cpu
It has more PCIe lanes
And on nower motherboards it's the slot which is wired to PCIe 4/5
fiery turtle
ah maybe idk
fiery turtle
fun fact, igpus are mandated by the spec to be located at 0000:00:02:00
calm latch
It's for that forum person who refuses to use ACPI
gentle peak
you wouldn't even need ACPI to detect it in places other than that
calm latch
Windows 98 compat?
gentle peak
just brute force detect all possible devices on every addressable bus
calm latch
I don't have experience in computer industry so I don't know if that's true, but I would imagine there must be some embedded shit which uses some cursed OS to control machine tools and that stuff would have it hardcoded
gentle peak
doesn't that kinda stuff use 386 and 486 CPUs
fiery turtle
igpus are pretty tightly intergrated with acpi as well, they usually have a separate SSDT dedicated for them, a custom opregion, and various notification things
if you're lucky there is even a method to do modesetting via acpi
calm latch
The ASUS laptop which I've dumped yesterday was turning screen on and off with the keyboard buttons in pmOS
median crest
if you're lucky there is even a method to do modesetting via acpi
Wtf
calm latch
With no GPU driver
median crest
Really?
calm latch
And spamming a bunch of ACPI events
calm latch
So could have that been done by ACPI?
fiery turtle
yeah, by the corresponding query handler
calm latch
i have a 4060ti so no such problems <:LULW:543420553021882371>
Does uDRM have plans for Nvidia? 
north holly
Ye
fiery turtle
maybe you're expected to call this after resume from suspend
your blob has this method
north holly
Hmm
fiery turtle
this might restore graphical output
north holly
your blob has this method
Which one
fiery turtle
_DOS
north holly
Which blob
fiery turtle
the laptop one
north holly
I'll try that
north holly
I assume it is under the GFX0 object?
fiery turtle
yeah
north holly
in an ssdt
fiery turtle
SSDT1 has tons of stuff for graphics-related things
probably some combination of those methods can restore the screen
just read the entire spec chapter on that, its pretty small
so u need to detect which screen u want to activate, then activate it ig
idk
calm latch
https://uefi.org/specs/ACPI/6.5/Apx_B_Video_Extensions.html#dos-enable-disable-o...
Does yesterday's laptop have this?
It also has 6000 series AMD iGPU
Which has datasheet
fiery turtle
Does yesterday's laptop have this?
yeah
calm latch
Btw, I don't think it has Windows keys
fiery turtle
your laptop has 2
❯ grep _DOS *.dsl
dsdt.dsl: Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching
dsdt.dsl: Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching
How do you remove them?
fiery turtle
if you could PR it that would be great
fiery turtle
How do you remove them?
the dump is an ascii file
calm latch
On my Lenovo laptop, I could only get touchscreen version with Windows license so I don't want that on github
fiery turtle
just remove the windows license table from the table dump
north holly
I wanna fuck around and find out what happens if I call _SPD (set post device) for my graphics card
fiery turtle
north holly
because after all what could possibly go wrong
fiery turtle
i guess by posting they mean this
maybe they post it somehow after restore
need to find code
fiery turtle
k
all video logic is here
you might be saved from having to write every driver
they even set notify handlers for brightness control etc
pretty interesting
north holly
so it seems like I need to do the following:
on suspend:
foreach graphics device
save_brightness
on resume (after _WAK):
foreach saved graphics device
restore_brightness```(pseudocode of course)
fiery turtle
something like that i guess
north holly
that's what linux seems to be doing in the thing you sent me
calm latch
Do PCs with descrete GPUs have that?
fiery turtle
yes
loud ice
you're not sure what your SSO buffer size is? <:LULW:543420553021882371>
no i didnt understand what you meant
calm latch
Now that I'm dumping all the tables
fiery turtle
ah
fiery turtle
are you sure?
that dump contains a hex view
gentle peak
oh right it might be on a column boundary
fiery turtle
acpixtract -a dump.txt && iasl *.dat
gentle peak
nope
fiery turtle
oh right it might be on a column boundary
nah like actually look at whats inside
is there a GFX0?
gentle peak
oh wait is this only for pcs with an igpu?
because mine doesn't have an igpu
and no there's no gfx0
gentle peak
also no
fiery turtle
is that a laptop or
gentle peak
desktop pc
calm latch
My new-ish b550 PC
fiery turtle
which cpu/gpu?
gentle peak
ryzen 5800x, rx 6500 xt
north holly
and my other test pc
north holly
although this one doesn't have s3 suspend
gentle peak
$ ls
apic.dat cdit.dat dsdt.dat facp.dsl fidt.dsl hpet.dsl mcfg.dsl ssdt1.dsl ssdt11.dsl ssdt3.dsl ssdt5.dsl ssdt7.dsl ssdt9.dsl vfct.dsl
apic.dsl cdit.dsl dsdt.dsl facs.dat fpdt.dat ivrs.dat pcct.dat ssdt10.dat ssdt2.dat ssdt4.dat ssdt6.dat ssdt8.dat tpm2.dat wsmt.dat
bgrt.dat crat.dat dump.txt facs.dsl fpdt.dsl ivrs.dsl pcct.dsl ssdt10.dsl ssdt2.dsl ssdt4.dsl ssdt6.dsl ssdt8.dsl tpm2.dsl wsmt.dsl
bgrt.dsl crat.dsl facp.dat fidt.dat hpet.dat mcfg.dat ssdt1.dat ssdt11.dat ssdt3.dat ssdt5.dat ssdt7.dat ssdt9.dat vfct.dat```hmm ok maybe new amds dont do that or sometihng
@gentle peak any of these?
barring _ADR
gentle peak
gentle peak
no
fiery turtle
ah ok
fiery turtle
mkdir -p acpidumps && cd acpidumps && acpidump > dump.txt && acpixtract -a dump.txt && iasl *.dat
calm latch
thx
calm latch
Wth is Component Distance Information Table
fiery turtle
open the dsl maybe it will tell u
calm latch
My PC has no BCL
fiery turtle
F
calm latch
My PC has no BCL
5900X + 5700 XT
fiery turtle
apparently discrete amd gpus dont have those
torpid root
`mkdir -p acpidumps && cd acpidumps && acpidump > dump.txt && acpixtract -a dump...
doesn't that output many files in the current directory
calm latch
I should've gotten 5700X 
fiery turtle
doesn't that output many files in the current directory
it does
calm latch
apparently discrete amd gpus dont have those
I have 7850, I can also check there
torpid root
probably should add a notice then
fiery turtle
ill add a mkdir step
torpid root
I was skill issued enough to do it in my home dir once
fiery turtle
lol
gentle peak
just rm *.dat *.dsl
and make sure you don't have anything important with those extensions in your home dir ofc
fiery turtle
rm -rf / to be sure
calm latch
That need a flag to work
fiery turtle
downgrade rm to some old version
slim panther
do you want a b650e dump
calm latch
rm -rf --no-preserve-root /
mortal yoke
find /dev -type f -exec dd if=/dev/urandom of={} \;
fiery turtle
do you want a b650e dump
if you're willing to PR it in a proper format ill gladly accept :^)
torpid root
rm -rf / to be sure
remove the French rm -fr
slim panther
wdym PR
gentle peak
the link it generates has a hwid column
it'd be cool if i could figure out how to generate that without having to upload all the hw info to that website but whatever
fiery turtle
maybe i should make a script to PR a local dump quickly
so that its easier for people
slim panther
i got this now
fiery turtle
for the sake of the PR we only need the .txt renamed to <ID>.bin
slim panther
and what's ID
gentle peak
is <ID> really that important?
fiery turtle
`sudo -E hw-probe -all -upload -dump-acpi`
either this or come up with a random one
gentle peak
maybe it can just be dump.bin
fiery turtle
im cargo culting it at this point
gentle peak
also how should it be handled if different firmware versions have different acpi tables/aml
fiery turtle
that would probably produce a different id
gentle peak
fair
fiery turtle
@north holly btw if that works we can PR a _BCL for QEMU's bochs device as well
unless there's one already
fiery turtle
and that reminds me that u have abandoned your SeaBIOS series
slim panther
no local file tho
fiery turtle
the website now has an id
u can take that and rename your file i guess
(is that what monkuous did?)
gentle peak
yeah
gentle peak
that would probably produce a different id
just tested it, id didn't change
north holly
and that reminds me that u have abandoned your SeaBIOS series
who me?
fiery turtle
Yes
fiery turtle
just tested it, id didn't change
I guess their tools aren't that good
slim panther
north holly
until they return to their senses and fix the bug themselves, I will be using my patched seabios
gentle peak
what's the bug
north holly
what's the bug
ECAM restored using ECAM on wake from S3
the fix is literally:
+make_bios_writable();
+mmconfig = 0;```
in pci_resumeI can pick it up if u want
north holly
yea sure
infy
if I do this:
uacpi_eval_simple_typed(node, "_BQC", UACPI_OBJECT_INTEGER_BIT, &dev->current_brightness);```
do I need to `uacpi_object_ref(dev->current_brightness);` manually?Why would u ever need to ref manually
north holly
idk
fiery turtle
Tldr no
north holly
k
fiery turtle
@north holly could u test a faster uacpi + new kapi real quick?
north holly
sure
fiery turtle
u should be getting more points now
north holly
just let me test suspend with the gfx things
north holly
I'll try
fiery turtle
maybe u also need to enable switching and stuff
that could be handled by linux native drivers or something
north holly
that could be handled by linux native drivers or something
btw is it valid to do something like:
uacpi_object_array arr = {.objects=&dev->current_brightness, 1};
to pass to uacpi_eval
fiery turtle
ofc
fiery turtle
pretty sure it wouldve segfaulted otherwise lol
north holly
I mean who knows, maybe it did, as that's done after wake from suspend (therefore I have no way of knowing about the crash)
fiery turtle
lol
north holly
what I find interesting is that the function key to disable the display works despite me not handling it
fiery turtle
u dont have to handle it even for firmware to do wahtever it wants in the query handler
if u have a keyboard driver u can actually try to increase/decrease brightness for different keypresses just to see if it does anything
or hook up a notify handler on LCD
north holly
what the hell's the problem with just doing Return(Zero)
fiery turtle
probably workaround for some windows xp aml interpreter bug
north holly
north holly
```
Local0 = Zero
Return (Local0)
```
yeah but why would it do this here
north holly
but this here
fiery turtle
brain rot
north holly
I swear I'd rather have shrek write AML
fiery turtle
maybe he did
north holly
I'll test the uacpi updates
fiery turtle
whats up with bcl stuff?
left orbit
can’t wait to see proxima results with sso
fiery turtle
1B
north holly
whats up with bcl stuff?
I think I might need to also call _DOS
fiery turtle
I think I might need to also call _DOS
probably
north holly
uacpi_object* brightness = uacpi_object_create_integer(0);
uacpi_object_array arr = {.objects=&brightness, 1};
uacpi_eval(node, "_BCM", &arr, nullptr);
although doing this has no visible change in brightness, but maybe I'm just doing it wrong
Zero is the third element of _BCL
fiery turtle
i mean
whats the default level
and whats the current
u should've increased it and have like a sleep() loop
north holly
good idea
fiery turtle
Zero is the third element of `_BCL`
also dump the entire thing
fiery turtle
uacpi_object_assign
calm latch
the aml is hungry
I can't stop laughing
fiery turtle
imagine people wrote C like they did AML
nyaux
slim panther
the aml is hungry
?????
slim panther
i will make a header that converts ASL to C
calm latch
the aml is hungry
Eat, sleep, repeat
gentle peak
proxima on uacpi's api-changes branch (a932364e16a8bb7e59007fad1bbf564eede5e1d8, qemu-system-x86_64 -accel kvm -cpu host,migratable=off -no-reboot -debugcon stdio -device isa-debug-exit,iobase=0xf4,iosize=0x04 -M q35,smm=off -cdrom proxima.iso):
uacpi: info: successfully loaded 1 AML blob, 1705 ops in 0ms (avg 6123797/s)
fiery turtle
huh, faster than we did locally?
gentle peak
apparently
omitting migratable=off has a negative impact on the performance now for some reason
gentle peak
like if i just do qemu-system-x86_64 -accel kvm -cpu host -M q35,smm=off -cdrom proxima.iso i get 5975411
whereas with qemu-system-x86_64 -accel kvm -cpu host,migratable=off -M q35,smm=off -cdrom proxima.iso i get 6113455/s
fiery turtle
i can feel the speedup even locally with the base test cases, perhaps my shitty memcpy being used less at O0 helps
north holly
I decided to add a handler for the brightness FN keys
and change the brightness there
to see how that goes
fiery turtle
oh cool
north holly
it's only temporary though
fiery turtle
why not keep it
north holly
because of how I register it
uacpi_namespace_node* node = nullptr;
uacpi_namespace_node_find(uacpi_namespace_get_predefined(UACPI_PREDEFINED_NAMESPACE_SB), "PCI0.GFX0.DD1F", &node);
if (node)
uacpi_install_notify_handler(node, gfx0_handler, nullptr);```also when asked to increase u should probably use items from that package right?
north holly
they range from 0->100
fiery turtle
```c
uacpi_namespace_node* node = nullptr;
uacpi_namespace_node_find(uacpi_names...
💀
calm latch
pmOS on the latest commit and with pthread_mutex fixes, on a faster PC
(haven't changed uACPI stuff to builtins)
fiery turtle
what does it return for current level? @north holly
calm latch
So like 0 optimization work
fiery turtle
pmOS on the latest commit and with pthread_mutex fixes, on a faster PC
big
north holly
what does it return for current level? <@841762704766140486>
tryna figure that out rn
inb4 obos gets highest score when ran with the new branch
gentle peak
like if i just do `qemu-system-x86_64 -accel kvm -cpu host -M q35,smm=off -cdrom...
i suspect this is because my tsc calibration code usually gets a frequency that's a bit lower than it actually is, so with migratable=off the same number of tsc ticks is assumed to take longer.
with migratable=off time: tsc is 3792.871000 MHz
without time: tsc is 3792.733814 MHz
fiery turtle
pmOS on the latest commit and with pthread_mutex fixes, on a faster PC
latest commit is api-changes branch or master?
calm latch
master
fiery turtle
i suspect this is because my tsc calibration code usually gets a frequency that'...
interesting
calm latch
And because pthread_mutex doesn't yield on unlock anymore
fiery turtle
ah
calm latch
But like faster CPU is 5900X
vs 7480S in my laptop
Which should still be fast on single core
I suppose
median crest
Soon I will get 1 bil aml ops per sec trust
fiery turtle
i would need to jit aml for that
calm latch
uACPI 2.0
Imagine people switching from python to aml one day for quick compute stuff 
Does TSC run at CPU frequency?
I've just noticed that my CPU reports itself as 3.7 GHz in Windows, and that is more or less my TSC clock
fiery turtle
Imagine people switching from python to aml one day for quick compute stuff <:KE...
python has an experimental jit now as well
gentle peak
Does TSC run at CPU frequency?
usually it runs at one of the cpu frequency levels
north holly
python has an experimental jit now as well
I have discovered that _BCM doesn't do shit
calm latch
I've just noticed that my CPU reports itself as 3.7 GHz in Windows, and that is ...
But it boosts to 4.5GHz or so all the time
torpid ferry
Does TSC run at CPU frequency?
not entirely if you have invariant tsc