#MINTIA (not vibecoded)

1 messages · Page 23 of 1

shadow ridge
#

if you also include intelligent people with inertia in that

#

it's probably more like 70% who will actually verify

digital pivot
#

_KI_AB_BOOST_STRATEGY hmmmmm

#

probably cpu vs io

blissful smelt
#

lol

#

not NT but similar naming

digital pivot
#

there must be thousands of priority inheritance patents there

#

how can it make sense

blissful smelt
#

the descriptions in the patents makes it look incredibly easy to accidentally replicate

warm pine
#

the only reason anyone gets anywhere with them is because they can afford to bring to bear great sums of money on using them to try to extract great sums of money from other firms

acoustic sparrow
#

there are three real practical operating systems

#

and suing linux over patents is an awful PR move

warm pine
acoustic sparrow
#

oh yeah

#

those are a scam anyway

twilit smelt
#

It's my understanding that they mostly file these patents in order to reward their engineers

#

Because it makes them legally into inventors and they can list patents X, Y, and Z that they invented

#

People rarely try to enforce software patents yet Microsoft files for (and receives) like 4 a week

#

Or more

digital pivot
#

iirc theres a visa for extraordinary ability or something like that

raven drift
#

i doubt that's done in practice too much

#

back when the tech job market was overheated, h-1b was by far the most common type of visa

twilit smelt
#

Mintia

#

@warm pine when do we merge our projects and make keytia or mintonex

digital pivot
#

am i right in thinking that when you do priority inheritance you generally dont allow to release a lock from another thread

#

than the acquirer

twilit smelt
#

Yeah that's ugly in general and becomes broken when you have PI

digital pivot
#

i looked at the struct called _KLOCK_ENTRY_LOCK_STATE and it has CrossThreadReleasable which hints that a releaser can be another thread?

twilit smelt
#

Perhaps

#

I wouldn't allow that

#

If I had to guess they only support that in autoboost bc of drivers that did menacing things

digital pivot
#

KeAbMarkCrossThreadReleasable
KeAbCrossThreadRelease
KeAbCrossThreadDelete

#

it probably adds a lot of complexity then

twilit smelt
#

Yeah it's kind of a synchronization nightmare

#

Might be another reason for the deferring

balmy zealot
#

You’d need to be a proper good engineer to work with this.

#

Just the multi-level inversions were enough to make my head go round.

digital pivot
twilit smelt
#

Could happen if someone stupidly used a mutex as a cross thread semaphore by having thread A take the mutex and thread B release it

digital pivot
#

looks like it tries to be very efficient for user mode locks

#

even happened to " break" some old game

twilit smelt
#

especially because the win32 mutex primitives might have been the fastest way to do that at one point

#

since they had a noncontended fast path that doesn't enter the kernel

#

whereas the full semaphore or event objects always would

#

so I bet a lot of programs in the 90s tried to be clever

digital pivot
#

well it was the game's fault anyway

#

its just the implementation of critical section changed with some new user mode autoboost behavior

craggy spire
craggy spire
#

Apparently, only fast resources (Win 10+) use CrossThreadRelease

warm pine
digital pivot
twilit smelt
#

man im washed up

#

people used to glaze mintia so much and it sucked total ass compared to Astral or a number of other current projects

#

theres only one solution: locking in...

#

i think the bar has been raised to the point where like rejoining the ranks of the best of the server would mean mintia2 is running on amd64 and has advanced device driver support and runs minecraft

#

paging gimmicks wouldnt cut it anymo

#

ppl here are getting too good...

twilit smelt
#

that is to say i have to get it done before we reach the year of the astral desktop

dense vigil
#

The bar is very high these days indeed

#

Its not like 2021 when a gdt os was considered a pretty big achievement

twilit smelt
#

well a gdt os was never considered a pretty big achievement in this community

#

except maybe in like 2018

#

kind of amazing mintia1 got so much glaze just cuz it had some uncommon paging features like swapping and had a userspace, when it wasnt even SMP and only ran on a fake computer (at the time)

#

that might be more reflective of how suckish everything was back in like 2021-2023

#

the days where toaru was the most commonly cited example of a highly complete project

digital pivot
#

astral has swapping and other uncommon paging features ?

twilit smelt
#

i feel like fadanoid and i introduced people to the novel idea of spending more than 2 months on your kernel before speedrunning to the window system and then we both immediately ate shit

#

hopefully one day we can escape mathewnd's dust cloud and be bar raisers again

#

lmfao

twilit smelt
#

in terms of overall quality

digital pivot
#

its just you focus more on the kernel while other focus on getting ports and user mode stuff

twilit smelt
#

mathewnd has been grinding away at his project during the whole like 2 yr period where ive been struggling with motivation on mine

#

as a result it has you know obviously raced by me

#

which is based

shadow ridge
#

motivation starts a project, discipline continues it

twilit smelt
shadow ridge
#

if you just wait for motivation to strike, youre done for

#

youll get like nothing done

#

except for like some random days

#

where u do 10 hours of work

twilit smelt
#

i did well in the past because it was the default thing i would do in my free time rather than doomscroll which is a thing ive taken up over the last couple years and is possibly a contributor to the motivation issues

shadow ridge
#

i dont think theres a single person on earth who can stay motivated on one thing for more than a year or two

twilit smelt
#

me

#

because i stayed motivated on it from like 2018-2023 continuously

shadow ridge
#

well, youve obviously ran out

twilit smelt
#

nope its just hiding

shadow ridge
#

if doomscrolling is an issue then stop doomscrolling

#

nobody is holding a gun to your head

twilit smelt
#

i was not asking for advice

#

merely stating that i have eaten mathewnd's dust and intend to resume regular work and not be a dust eater forever

twilit smelt
shadow ridge
#

well

#

im merely stating that if motivation is the only thing keeping ur project going then you'll eat dust forever

digital pivot
shadow ridge
#

that too like

#

mintia1 wasnt glazed

#

just because paging or whatever

digital pivot
#

and spent more time on research on iokit and stuff

shadow ridge
#

it was written in a writeonly language with a custom toolchain

digital pivot
#

instead of speed running

twilit smelt
shadow ridge
#

im not 15 years old

twilit smelt
#

this is revisionism or you werent there

#

it was 100% for the kernel design aspects

shadow ridge
#

people didnt like df but they did like the fact that it had its own compiler and stuff

twilit smelt
#

no, people here took that for what it is, in the context of kernel dev, which is a largely uninteresting novelty

shadow ridge
#

it was also the first hobby kernel outside of react that resembled NT

#

wasnt nt like completely hated and clowned on here

twilit smelt
#

its cool broadly to have an nih ecosystem and i have my reasons for maintaining that but in the context of this server it like basically is not relevant lol

#

and rarely came up in mintia1 discussions

#

its tangible contributions were 100% to general knowledge of like paging dynamics and the constraints they place on kernel design since i was like the only person exploring that at the time and people got interested in it

twilit smelt
shadow ridge
#

yeah not really "hated"

#

more "ignored" ig

#

well i have stuff to do

#

bye

twilit smelt
#

theres always like r/osdev poster types who are going to go like "ZOMG A CUSTOM LANGUAGE??? WELCOME BACK TERRY"

#

for ppl who knew what they were talking about the interest was 100% in me being able to tell them how to design like dependency ordering for a swapping vmm so that you dont deadlock after 0.5 seconds

#

which was like completely undocumented arcane knowledge at the time

#

and is hard kind of

#

mintia2's things i wanted to focus on and explore are stuff like a really good plug n play io system and numa

#

(without losing any of the vmm features mintia1 had)

#

oh yeah and a hopefully interesting take on vfs

#

all yet to be implemented

#

that might be part of the loss of motivation too is that it took way longer than i anticipated to get to the stuff i considered interesting to work on

twilit smelt
#

already knowing that was the whole reason i mentioned it!

#

if i say "i have X issue because of Y thing i can just stop doing" the "so i will not do Y anymore" is implied and i will want to cleat you in the face for saying it at me

#

just for future reference

mortal thunder
shadow ridge
#

most people ive seen vent like this do know the issue

#

and they just dont fix it

#

because theyre addicted to it / procrastinating / whatever

twilit smelt
#

im not most people though

#

and im not venting

shadow ridge
raven drift
#

For example, Managarm has it a lot easier to survive because it doesn't depend on a single person's continuous attention

raven drift
twilit smelt
#

i disagree since the language is sort of an isolated time investment aside from early compiler bugs which you do get like 99.99% sorted out

#

at least it is for me

#

after that it can easily go at the same rate as any other kernel project written in a language at the level of C

#

i would not agree with the idea that mintia2 is doomed in some way to lag behind other projects that arent written in custom langs

#

there is essentially no reason that would be true aside from extra porting effort but that is again a minor one time investment compared to the broader timescale of the project

raven drift
#

I'm not saying that Mintia2 is doomed to lag behind other projects, I'm saying this without the specifics of Mintia2 in mind

#

basically it boilds down to: "first do X, then Y" is always going to be harder than "do Y"

twilit smelt
#

i dont understand the point of your statement then

twilit smelt
#

(well, the wider fake computer project, mintia is only ~5 yrs old)

raven drift
#

That statement was not a judgement of you or anything, it's just what I observe in general. Managarm has also been a continuous effort for 11-12 years now with same codebase, yet ppl (myself included) lose and re-gain motivation from time to time

twilit smelt
#

my basic motivation for it is fairly eternal since my fixation on OS stuff is close to the core of my personality since i was a preteen and im probably too autistic for that to change

#

i dont see myself ever permanently stopping work on it for any reason other than maybe it becoming profoundly irrelevant in multiple ways

raven drift
#

For me, the motivation to work on low level stuff as a hobby definitely took a hit when I started doing systems engineering as a job

twilit smelt
#

something like technology moving away from the current basics of OS design in fundamental ways and a loss of a corresponding community and so on

#

which i dont see in the foreseeable future

#

OSes are going to look different in 2050 but not so different that they dont have like schedulers or memory barriers anymore

#

probly

#

the most fundamental changes are more likely to be security related

warm mural
#

I think it also helps that you weren't focused on a single thing

#

Like, it's a bunch of projects instead of just one

warm mural
twilit smelt
shadow ridge
twilit smelt
#

something i think we might see is like

#

that one apple silicon feature where the pte permission bits are indices into an on-chip table of the real permissions bits

#

and you can change the permissions of like terabytes of virtual memory at once by writing new permission bits to an entry in that table

#

i forget what the acronym for it is

#

i think thatll become ubiquitous and will be used for fairly profound kernel design features

shadow ridge
twilit smelt
#

for example you can toggle W^X memory back and forth between writable and executable

#

i think thats one of the things they use it for

shadow ridge
twilit smelt
#

which happens in JIT engines

twilit smelt
# twilit smelt i think thats one of the things they use it for

but more profoundly you could use it to separate a monolithic kernel into separate components that might for example have read-only access to one another's data but no write access and you can call through gates that switch subsystems by writing new entries in this table

#

things like that

shadow ridge
#

that sounds more useful

twilit smelt
#

which is already being done in XNU to some extent btw

#

on iOS

#

they now isolate the page tables by doing that

#

along with an extra privilege ring

#

which is the only one allowed to modify that table of permission bits

#

all apple silicon specific features

raven drift
#

now they just need a feature where the instruction's PTE also determines which permission table is used and they'll have fully re invented segmentation halfmemeleft

twilit smelt
#

but the way they did it was to manually set all the PTEs for data in the old subsystem to read-only and the ones for the new subsystem to read-write

#

which is obviously slow as shit and also has the inherent hole that anybody in kernel mode on a 1989 chip can touch the PTEs, so it only makes specific types of attacks harder

#

they were def missing this hardware feature

#

which would have made the subsystem gates instantaneous and provides the extra privilege level which makes them airtight as well

#

nearly

dense vigil
twilit smelt
#

thats the intel name for it, apple doesnt call it that (or do they! i dont remember)

#

also i think intel's impl is inherently holey in some way that apple's isnt

#

last i heard

oak spade
twilit smelt
#

if id known about that earlier i def would have designed it into my toy architecture and would be using it in mintia2 lol

#

the coolest part is that it doesnt require any tlb invalidations since the tlb caches the index which indirects into the permissions table

#

so it really is like

#

a couple cycles

#

no extra tlb misses

#

or shootdowns

#

cuz the contents of the changeable parts of the permissions table, are part of the thread context and are switched when threads are

#

its also a fairly cheap feature and it could have probably been implemented on 1989 chips

#

its just that nobody had thought of it

#

the VAX in 1978 probably could have had this

#

and then everything after would have it

#

NT's Ke vs executive separation would probably have been runtime enforced this way lol

#

i think this specific feature represents a real alternate reality for the last few decades of os design and possibly a future as well

#

xnu's already using it to isolate the page table manipulation code and it sounds like the uses of it are still expanding

#

xnu's security features will prob trickle down to the other major kernels

#

over the next 10-20 yrs

#

i think they have such an edge because of the vertical integration where the chip architecture design and kernel design teams can directly coordinate under the same roof and rapidly iterate on cool ideas

digital pivot
twilit smelt
#

i dont think nt will vanish on a 10-20 yr timescale

#

doesnt make much sense that it would

shadow ridge
#

its desktop share will diminish a lot imo

#

linux might even pass 10%

twilit smelt
#

its unlikely to ever be cheaper for MS to try to make Linux (or whatever) walk and talk like NT to the decades of programs that want it to, than to just keep going with NT

digital pivot
#

im quite pessimistic about the future of microsoft, but yeah 10 years is too little

warm pine
twilit smelt
#

we could see xnu become the most structurally exotic kernel fairly quickly if they keep this up

#

mostly motivated by security

warm pine
#

For the first time since 90s we are seeing what happens when the chipmaker and kernel authors are in the same building

twilit smelt
#

i think the xnu team might be like the coolest modern kernel team to work on if i got to pick

warm pine
#

Really historically this was more of the norm and that's how we ever got a lot of the features we now consider fundamental. Without it kernels would've been stagnant

twilit smelt
#

it would be cool to see some kind of macromicrokernel where you have subsystems separated by gates to the extent that theres like fault isolation

#

and a crash inside most subsystems doesnt panic the kernel but reinitializes the subsystem and sets the thread to return an error status to the gate caller

digital pivot
#

is its just an idea

twilit smelt
#

just an idea

#

possibly the only originalish idea ive ever had since i dont think ive seen it before in any form other than the primitive form described in the ozix docs

digital pivot
#

i kinda like how windows was separated into different worlds to protect the kernel and separate the secure kernel and all that stuff

#

but it loses the hardware support which apple has i believe

#

maybe it moved further, i remember sangrealis mentioned miroexecutive

#

#lounge-0 message

twilit smelt
#

then you can just have the one kernel stack which gets reassigned between subsystems as the thread crosses them

#

and is reset on each gate cross

#

would be kind of ass pain but it would work

#

would be a very unusual kernel structure

#

which im saving for my hypothetical master's thesis.

warm pine
#

So I think a portable stack in some form or another is a great help

digital pivot
#

the access control might be useful then? sou they could be able to switch xnu for cl4 , with a separate set of page tables that also maps their secure page table thingy the same way as in the xnu page tables via l1

twilit smelt
# warm pine So I think a portable stack in some form or another is a great help

i dont think callback oriented subsystem crossing would be as annoying as callbacks normally are, probably it would be a manageable level of annoying, since callbacks get annoying when you need to maintain state about the operation out-of-line for the callback to consult, but its fairly often for the implementation of a syscall to follow sort of a straight line path from one subsystem to another or remain within one subsystem (especially if you can read the data of other subsystems)

digital pivot
#

does apples hardware limit in any way which bits you can switch ?

#

for example can you switch an entry that was normally rw- into rwx

twilit smelt
#

since then you dont need to grab a lock

#

to maintain existence of the thing

#

usually you need to write to a lock to acquire it, which would violate the whole thing where another subsystem's memory is read only

warm mural
#

also does this not require tlb flushes?

twilit smelt
#

it does not

warm mural
#

ah it caches the indices

twilit smelt
#

yep

warm mural
#

damn

#

common apple engineering W

hollow musk
warm mural
#

ever since apple silicon they've been doing really cool shit

twilit smelt
digital pivot
#

iirc their security team is separate from the kernel proper one

twilit smelt
#

i dont think we've heard that

warm mural
#

well they both work on the kernel so they're both the kernel team :^)

twilit smelt
#

i mean im sure they have more security-oriented people

#

and less security-oriented people

#

but im p sure theyre all on the same team

warm mural
#

but yeah working at apple right now sounds cooler than working on NT at microsoft

twilit smelt
#

would be weird otherwise

warm mural
#

especially with MS going all in on AI while apple doesnt care that much

twilit smelt
#

slowly convincing myself to add this stuff to xrarch and have the low 5 flag bits of a PTE turn into an index 0-31 into a table like this and have the firmware initialize it to be a 1:1 mapping for compatibility with the old OSes

digital pivot
warm mural
#

What's useful about it though? Like i get the point of isolating subsystems, you can only access them fully through gates etc. but if you were to gain control of the kernel couldnt you just call into the gate and do your shit there?

digital pivot
warm mural
#

microsoft was cool in the 90s

twilit smelt
warm mural
#

doesnt calling the subsystem entry point essentially give your thread access to the entire thing?

twilit smelt
#

theres an iron curtain similar to the one between kernel and userspace on a syscall

#

except you can read across the boundary

#

since thats very convenient

warm mural
#

so like:


void subsystem_do_thing(int param) {
// I can only access read-only
enter_subsystem_gate(); // Remap write
// now i can access everything
do_thing(param);
exit_gate(); // Back to read only
}
twilit smelt
#

even that could be configurable on a fine grained basis though like you could have per-subsystem heaps and have one be globally readable and another be fully private

twilit smelt
#

crossing a subsystem gate fully transfers control to some defined entrypoint in the other subsystem

warm mural
#

what would such call look like?

twilit smelt
#

a lot like a syscall

warm mural
#

all this sounds really interesting, but I'm not sure i understand it fully

warm pine
#

Where you sleep with a "call this function when I return" routine. The kernel stack can be dropped during that sleep

twilit smelt
#

sounds useful and easy to implement

digital pivot
twilit smelt
#

something like that would be downright trivial to add to my kernel

#

before waiting you can set a field in the current thread structure for a callback pointer and another for a context

#

upon unblocking it notices that this is set and it resets your stack and sets it up to call onto the callback

#

and when the kernel stack swapper passes over you and sees that you have this set, it frees your kernel stack outright

#

any syscall that blocks at the end and does very little afterward could be implemented this way including the synchronous IO ones

#

p easily

warm pine
warm pine
twilit smelt
#

also you could have it like

#

if your kernel stack does not fall victim to the swapper thread, the wait can still just return normally

#

to avoid the overhead of redirecting the thread to the callback

#

and then it can just call the callback or something

#

normally

#

fall onto the common codepath

warm mural
#

you would still need to have a stack to call the callback though no?

twilit smelt
#

yeah you would reallocate it when the thread is unblocked

warm mural
#

ah the point is that you can free stacks for free

#

like

#

if its sleeping and it doesnt have to keep any context on the stack upon waking up you can free its stack easily

twilit smelt
#

yeah

#

theres some stuff youd have to save somewhere else

#

like the trap frame

#

which you need in order to ultimately return from the syscall

warm mural
#

normally youd have to page it out or something to keep the data if you wished you free the stack

#

but thats expensive

twilit smelt
#

i feel like a well-optimized run length encoding could be good for kernel stacks too lol

#

if you zero them out every once in a while upon entering the kernel

#

theyll be mostly zero a lot

#

or even a full compression algo of the variety used for page compression and just have it fall down the normal page compression pipeline

warm mural
#

you keep them always compressed and uncompress them when switched into?

digital pivot
twilit smelt
warm mural
#

It's just that the pager is doing compression

blissful smelt
#

mintia2 memory compression?

twilit smelt
twilit smelt
warm mural
#

Yeah well then it's the same as windows swapping but with compression

twilit smelt
#

because windows already compresses these pages

flat dust
flat dust
#

how do people even get to minecraft and all

#

we literally got OSdev monopolies trl

mortal thunder
#

and mlibc being super fucking good

flat dust
#

well the 2nd ultimate but whatever trl

mortal thunder
#

whats the first

flat dust
night needle
flat dust
#

Managerms assertos

mortal thunder
shadow ridge
#

imagine writing your libc in C++

#

what a joke

mortal thunder
#

imagine writing your os in rust

shadow ridge
#

to be fair

#

i could shit on my hard drive

#

and the bits that were randomly turned on by the shit

#

would make a better libc

#

than glibc

#

not because glibc is bad or anything

mortal thunder
#

glibc kinda sucks yes

shadow ridge
#

it's just written in GNU "style" (writeonly garbage)

mortal thunder
#

guh-noooooooooo

shadow ridge
#

what

#

isnt it read like goo nue

#

ok if you pronounce gif with j and god with j then you should pronounce gnu with a j

#

that makes lots of sense

mortal thunder
shadow ridge
flat dust
#

rust is balls for osdev because its most advertised feature isnt practical

#

i guess you just have to like the syntax

warm pine
#

I is a softening vowel

#

It has this property of modifying a previous consonant in gaelic, polish, also Italian whence i assume comes the jif pronunciation for gif

shadow ridge
#

if you think about it

#

gif should just be

#

G I F

#

nobody reads PNG like "ping"

#

or "MP4" as "umph four"

flat dust
#

you cant pronounce png as it is, you have to add a vowel

#

why does this thread get so much weird yet calm almost philosophical unrelated conversations nooo

#

its pretty nice

flat dust
#

or you say "p ng"

#

pee n gee

#

pee ng

#

im thinking gif should be pronounced as gif and not jif because in words that start with g we dont say j

jallery?

#

jabagool KEKW

warm pine
tame phoenix
#

pee en gee

tardy harbor
shadow ridge
tame phoenix
shadow ridge
#

yes

hollow musk
#

@twilit smelt @warm pine it seemed to me that you were well informed about the NT memory manager

#

I am familiar with the concept of working sets and aging, but not in the new implementation you mentioned

#

perhaps you could enlighten me about this virtual memory technique and explain to me what the concept of "thread fault clusters" is?

#

I know only that it's also subject to aging and walking (the MiThreadFaultClusterAgingThread runs alongside the working set aging thread.)

digital pivot
#

yeah that one is interesting

digital pivot
#

although i thought this thing existed for many windows versions now and im not sure how exactly it changed in modern windows

twilit smelt
twilit smelt
#

the per-thread cluster length basically says the ideal number of pages to make valid at once and is changed in various situations i forget

#

but setting it to like

#

1

#

basically disables clustering for faults taken by that thread, and indicates that random access is being performed for example

twilit smelt
#

they link the page table pages of a process into per-age lists anchored in the process structure (or somewhere, theyre per-process basically)

#

we arent sure how the age of a whole page table is determined but its probably average age of all the contained valid pages

#

i believe they pop page table pages off the oldest age list and age each PTE, invalidating them and decrementing the refcount on the page frame when the age passes the maximum

#

presumably during this process the average age of the page table is re-calculated and it is placed on the back of the appropriate list

#

they parallelize this process by having multiple threads pop page tables off of these lists and age them in parallel

#

and im pretty sure they optimize it using a bloom filter or something to avoid scanning large ranges of invalid PTEs

#

thats how im planning on doing it at least

twilit smelt
twilit smelt
#

cool screenshot of mintia1 running on all 3 of its platforms for future use

image.png
hollow musk
#

I'm making good progress with Ke, have learned a lot of new things

digital pivot
#

have you finished reversing autoboost ?

hollow musk
#

I never intended to study it in depth because I didn't know about it when I started to begin with

#

but over the past two weeks I think I've figured out most of the basics

digital pivot
#

i'd be interested to read any kind of analysis of that

#

btw , are the so called reschedule contexts needed for balancing scheduled threads or looking for a new thread ?

twilit smelt
#

i did some work on mintia2 for the first time in a couple weeks

#

refactored the loader so that it mirrors the boot node's page directory to the other nodes correctly

#

at this point i should be able to draw up a numa xr/computer platform (xr/frame) and add support for it in order to test mintia2's numa support

#

plan is a platform with up to 4 nodes and up to 4 processors per node

#

so 16 total processors

#

at max

hollow musk
blissful smelt
hollow musk
#

it's a temporary object that says, in effect that for this processor or this isolation unit, here are the CPUs involved, here is the ready queue association for each one, here is the current incumbent for each reschedule entry, and here is the place where a newly found winner will be stored

#

starting a reschedule conetext seeds each context entry with a CPU, an optional shared ready queue, and a CompareThread that is either NextThread or CurrentThreat

#

it also records per-entry state flags and the maximum currently observed isolation width

#

so, the search routine begins with a set of current "incumbents" that new candidates must beat

#

once the reschedule context exists, the scheduler begins the actual search, but before it enumerates anything, it locks every distinct shared ready queue referenced by the context

#

the search then proceeds in phases, one phase that scans ready priorities 1..31; one phase that scans SCB queues by choosing the best root SCB and then a priority within that SCB; and one final phase that scans priority 0 only

#

inside the ordinary non-SCB phase, a CPU can have the chosen priority represented in the local ready queue, in the shared ready queue, or in both

#

when only one domain has threads at that priority, the choice is trivial, and when both do, the scheduler consults "AffinitizedSelectionMask"

#

if the bit for the current priority is set, the enumerator examines the local ready queue first; if the bit is clear, it examines the shared ready queue first

#

as the enumerator yields concrete threads, each candidate must be compared against the incumbent stored in a reschedule context entry

#

this comparison is performed by a function called KiDoesThreadDominateRescheduleContextEntry, but if fair share scheduling is enabled, the function delegates to KiEvaluateGroupSchedulingPreemption

#

otherwise the rule is comparatively direct: a candidate dominates if the entry is marked as always replaceable, or if the candidate's priority is higher than the incumbent's priority, or if priorities are equal and the entry's flags or the caller's tie break request allow equal priority replacement, or if a special flag permits a non zero priority candidate to dominate

#

in other words, does this thread dominate the incumbent for this entry under the current flags

#

if CompareThread was seeded from NextThread (standby thread), then the scheduler is testing newly encountered candidates against a thread that has already won once

#

a standby thread is an already selected incumbent that later searches may still overturn if a stronger candidate appears before the commit finishes or before dispatch actually occurs

#

but not every ready thread encountered in the domain is immediately eligible for comparison

#

scheduling group constraints, core parking state, QoS, heterogeneity, and isolation width all affect whether a candidate is admissible and whether its win requires the whole context to be tightened and searched again

#

a candidate that wins is written into the entry's NewThread which a search result inside the context

#

the actual transition is performed only when the scheduler commits the reschedule context

#

in the commit step, the scheduler can keep the incumbent, choose a candidate, or use a special isolation thread as the committed thread for sibling entries in an isolated unit arrangement

#

in the end, the commit step installs NewThread into NextThread and places the thread into standby

flat dust
twilit smelt
hollow musk
#

I'm not sure about a simple average

#

I see the code repeatedly reads and writes the PFN bits at positions which match OldestWsleLeafEntries and OldestWsleLeafAge

#

and then queues the page table PFN into ActivePageTableLinks[j] for that same age j

#

when the count of oldest aged entries falls to zero, it calls MiRebuildPageTableAges

#

when a newly updated age exceeds the prior table age, it removes the PFN from the old queue and reinserts it into the newer one

#

so I tend to think that the queue key is based on the oldest age currently present in that leaf page table page plus a count of how many entries are at that age

#

I also took a look at the aging tread. MiComputeAgingNeed decides whether to age at all and fills a small control block with the age percent and trim age thresholds (I think)

#

MiAgeTargetedWorkingSet acquires the working set shared lock, calls MiAgeWorkingSet(..., 1, ...) for the aging pass but may also call MiAgeWorkingSet(.., 2, ...) again apparently when periodic accessed bit clearing is enabled

#

MiAgeWorkingSet seems to compute how many PTEs to visit as roughly: AgePerecnt / 1000 of (WorkingSetSiez - LockedEntries) and adjusted by LastAgingRemainder or LastAccessClearingRemainder

#

and it uses PteResumePoint[1] or [2] so the next pass can resume where the previous one stopped

#

inside the walk, MiAgePte is the per leaf callback function, it scans valid PTEs and handles some special cases like shadow reads and combined PTE demotion (what's that?)

#

and it either hands some addresses to per-CPU age/trim lists or calls MiAgePteWorker directly

#

the tail callback MiAgeWorkingSetTail then flushes deferred age buckets with MiFlushDeferredAgingBucket

#

there is alsoa per-age distribution over the working set as a whole, MiComputeAgingPercent uses _MMSUPPORT_INSTANCE::AgeDistribution[8] to choose how aggressively to age

digital pivot
#

not good at virtual memory , huh

twilit smelt
# blissful smelt do you plan to use a counting bloom filter to support removal operations? from m...

The exact structure I was going to use was to pack two 4 bit counters (0-15) into each byte. Each counter tracks how many PTEs are valid in a range of 16. So a byte would track a range of 32, and 4 bytes would track a range of 128 PTEs. So this makes it super fast to skip over large invalid ranges since you can test a whole 4 byte set of counter bytes for being 0 in one comparison and if they are then boom don't have to look at any of those 128. Otherwise you can look more granularly inside that byte set until eventually you find the nonzero counter (maybe with binary search) and scan that linear range of 16 PTEs. It's also memory efficient, on 32 bit where there are 1024 PTEs you'd only need 1024/32=32 bytes for the bloom filter. On 64 bit where there are 512 PTEs you need 16 bytes

digital pivot
hollow musk
#

a set of processors that the scheduler must treat as a single scheduling object during a reschedule search and commit

#

it's either one logical processor or all logical processors in a core

twilit smelt
hollow musk
#

I think I may have found a throttling mechanism for the next aging pass

hollow musk
#

the code accumulates elapsed aging time and aged pages; then, if the totals are nonzero, it sets MaximumPtesAgePerSecond = 10000000 / (AgingTime / AgedPages)

#

which is effectively a pages per second rate in 100 ns time units

#

MiComputeAgingPercent uses that field as a cap when deciding how aggressive the next pass may be

#

it reads MaximumPtesAgePerSecond, falls back to 5000000 if the value is zero, then starts with 75% of the measured rate

#

the capped work budget is then compared against the current age bucket totals, and the function returns an aging percentage in the range up to 1000

hollow musk
#

it's interesting to note that, for some reason, an AVL tree is used during working set walking and aging

hollow musk
#

yeah, the memory partition stores 2 AVL trees used during top level walking

#

there are 2 of them because the aging trhead waits on two different events, so there are 2 types of aging

#

normal aging and hard limit aging

digital pivot
#

i think @warm pine might be interested in some of the information above

#

sorry for ping if not

twilit smelt
#

all those who remember that one unix edit using at&t archival footage

#

i thought NT should get a vaporwave edit so i just wasted like an hour on that

flat dust
#

ive watched the presentation, they keep repeating that meme

#

a hot new thing to have a computer with two processors at a time

#

:P

twilit smelt
#

i dont even know the name of the song i used in that since it was an unlabeled part of a vaporwave mixtape on soundcloud

shadow ridge
#

peak LSD music

mortal thunder
shadow ridge
#

is windows 1.0 even a thing

mortal thunder
#

they had to start somewhere

shadow ridge
#

i thought the first release was just called windows nt

#

ok tbh ik jackshit about windows history

twilit smelt
rare epoch
#

maybe to mock NT troll

rare epoch
#

seriously though I hope it's obvious I'm just kidding around, it looks like a really cool kernel and a custom language makes it 2x cooler

twilit smelt
#

the cursed numa xrstation

image.png
rare epoch
#

does your kernel aim an eventual Win32 compatibility btw?

rare epoch
#

@twilit smelt another question - is your language open source

dense vigil
#

yes lol

rare epoch
#

I can't find it on GitHub

dense vigil
rare epoch
#

oh

twilit smelt
#

ok working numa support is in mintia2, xremu, and the firmware

#

"xr/frame" can have up to 4 nodes, each with up to 4 processors and 64mb RAM

#

so fully loaded you can have 16 processors and 256mb RAM

shadow ridge
#

thats legit super computer specs

rare epoch
twilit smelt
#

yeaj

#

toy risc computer

rare epoch
#

nice

#

is it based on some known ISA or your own custom?

twilit smelt
#

custom

rare epoch
#

all you need is to realize this in an FPGA or something and then you can run your OS in baremetal

twilit smelt
#

i can also just port the os to x86

rare epoch
#

or that

twilit smelt
#

the last one i was working on already got an x86 port

rare epoch
#

are you planning doing Win32 support or anything like that?

twilit smelt
#

this is it running on i386, xr17032, and fox32

image.png
twilit smelt
rare epoch
#

GNU/NT troll

twilit smelt
#

its not really an NT clone i just yoinked the ideas i liked from NT

#

on equal footing with any other ideas that i liked from any other kernels

#

it looks most like NT because i find NT's structure to be extremely pleasant

#

so the structure is a thing i yoinked

rare epoch
#

I see

#

I plan to work on an NT-like too after I finish my Windows 3.1/95-like

queen torrent
twilit smelt
#

it didnt have storage either it was just the boot rom prompt

rare epoch
mortal thunder
#

like an x86 style MMU, yeah, I get how that would be hard, but a software-refilled TLB shouldn't be that much harder than the other parts of the CPU

icy bridge
#

iirc the status handling surrounding tlb refills is fairly complicated on xr17032

night needle
warm mural
night needle
#

why does x86 not have it

delicate dome
#

Does xrstation emulate stuff like IDE or maybe even PCI?

icy bridge
#

no it has its own devices

delicate dome
#

custom bus

#

i see

delicate dome
#

More generally the more complex memory subsystems you need for CPUs of that class is where my last attempt at a higher-powered CPU broke down.

dense vigil
#

just mmio devices scattered in random places

flat dust
teal trench
twilit smelt
#

its a bit more structured than that..

twilit smelt
dense vigil
flat dust
#

i wondered if i can port my os to xrstation for the funny later, powerpc is stupid enough already but idk

dense vigil
#

"I ported Linux to my custom arch with a custom emulator"
"Fair"
KEKW

twilit smelt
#

i didnt do that! monkuous did that

flat dust
#

i feel like me saying "ok" instead wouldnt be that much better

warm pine
flat dust
twilit smelt
# dense vigil How?

its not like hyperrealistic or anything but theres 'ebus' where the phys addr space is divided into 256mb "slots", 7 of which are mapped to 7 physical slots for expansion boards and the last one is mapped to integral devices on the 'motherboard'

warm mural
flat dust
dense vigil
warm pine
flat dust
# flat dust sorta

idk navigating it is painful sometimes, some devices are partially undocumented

#

or i couldnt find the docs

#

the framebuffer device address is supposedly physical but mapping it does nothing, i should probably map it in my actual OS

twilit smelt
#

and the 'motherboard' itself has a bus called 'citron' which is an array of device registers mapped to various things (corresponds to the IO space of a toy CISC architecture i did a long time ago (~2017) and did a brain transplant on the emulator to replace it with the RISC ISA, which used MMIO, so the old IO space was made into an MMIO region)

flat dust
#

fair

twilit smelt
flat dust
twilit smelt
#

it just builds a struct in low memory describing the devices in a more static and xrstation specific way

flat dust
twilit smelt
#

the old firmware at one point had something that was a lot like fcode

flat dust
#

oh

#

now what meme

twilit smelt
#

it was like super overengineered beyond any use i had for it

#

i rewrote the firmware in jackal and the new firmware is quite simplified

flat dust
#

fair

#

is the protocol documented meme

twilit smelt
#

when u boot aisix or mintia1 (which are OSes for the old firmware) the new firmware chainloads an image of the old firmware which then boots into the OS

flat dust
#

also can you write C programs for the fartfirmware

twilit smelt
#

since they rely on the old firmware heavily and i didnt want to change it

flat dust
twilit smelt
flat dust
#

mk

flat dust
twilit smelt
#

yes monkuous wrote a custom bootloader in C for loading linux

flat dust
#

fair

dense vigil
#

Lol

flat dust
#

yeah idk i just got the idea of porting my os (which i should get it into actually existing on ANY architecture, my powerpc bootloader is taking way too long) to xrstation or whatever other weird architectures exist

twilit smelt
#

firmware docs

#

slightly outdated as of last night bc some things were extended when the numa configurations were introduced

flat dust
#

A4X

flat dust
#

also is this arch 32 bit

twilit smelt
#

yeah

flat dust
#

based

flat dust
#

this honestly gives me huge open firmware vibes idk

#

is the a3x partition table for like every OS that runs on this

twilit smelt
#

yeah but an MBR partition table and a3x partition table can be present simultaneously in the same sector

#

the structures dont overlap

#

monkuous used that for his linux images

flat dust
flat dust
#

does the client program just not get any callback functions like in ofw or whatever

twilit smelt
#

it does

flat dust
#

oh

#

i couldnt find them at a glance fair enough

twilit smelt
flat dust
#

API table

#

the bootloader needs a filesystem driver flobsh

#

or im genuinely blind

twilit smelt
#

it does

flat dust
#

oh

#

fair enough

#

does this have a custom fs too??

#

whatever the firmware uses to find and boot the OS idk

twilit smelt
#

the firmware only knows how to read the partition tables

#

so you can use whatever filesystem you want

#

i do have a custom filesystem that i tend to use

flat dust
#

fair

#

i wonder if i should write an hfs+ driver for my os just to be compatible with the mac, but thats a bit irrelevant

flat dust
twilit smelt
#

in mintia2 theres a fairly complicated bootloader (really more like a prekernel) but monkuous's linux bootloader is quite shrimple

#

it just has an ext2 driver

#

loads a kernel binary somewhere in memory

#

jumps into it

#

it builds a binary device tree in memory i think, for linux to consume

#

since linux likes having those i guess

flat dust
#

my bootloader uses firmware calls to get the kernel file that it loads into memory and pulls crap out of

#

which it kinda sucks since this firmware doesnt have firmware calls to get hard drive files pain

dense vigil
#

Unfair

flat dust
#

really unfair

#

i know who else is unfair

||XR/station firmware trl||

shadow ridge
#

still nostalgic for LIMNstation

rare epoch
#

what's the graphics hardware in XR/station? like do you have graphics cards

#

what produces the graphics

twilit smelt
#

linear framebuffer

#

there is a "framebuffer card"

#

the palette is programmable with 256 entries of 24 bit RGB

rare epoch
#

nice

#

you make me feel bad for larping as an NT fanboy and trolling you 😭

#

this is the exact same thing I've worked on but never completed - a complete computer system with a DIY CPU, graphics output and OS

#

this motives me to get back to it

#

mine was considerably simpler though, with no MMU

#

my goal was to implement it as real hardware using off-the-shelf components

#

it was technically a 1-bit serial CPU, but working in 64-bit words

twilit smelt
rare epoch
warm mural
shadow ridge
#

he needs to write his own HDL first

flat dust
shadow ridge
#

it's not that complicated anyways

flat dust
twilit smelt
flat dust
shadow ridge
#

why dont irl screens support RGBA

flat dust
#

NeXT larp meme

shadow ridge
#

i want a transparent monitor

rare epoch
shadow ridge
#

so it looks like the apps are just floating on air

#

how cool is that

#

sci fi shit

mortal thunder
twilit smelt
shadow ridge
#

my monitor is so old im pretty sure i changed the cap like 3 times now

#

i have no idea how it's still kicking

#

it's also the only monitor that actually lights up the room without straining my eyes

#

i couldnt use light mode without this

twilit smelt
#

also i was thinking of how i was going to implement numa affinitization for page allocation

#

and i came up with a scheme where i have an array attached to each numa node that lists all the other nodes in order of increasing distance, but it sounded kind of stupid

#

so i looked at what linux does

#

linux does something WAY smarter. it have an array attached to each numa node that lists all the other nodes in order of increasing distance

shadow ridge
#

dude

#

why didnt you think of that

#

thats genius

rare epoch
twilit smelt
#

i thought it was stupid because its O(n^2) in space complexity where n is number of nodes but if linux does it then its probably good

shadow ridge
#

uuh why does space complexity matter here it's not like you have soo many nodes that it would actually make a difference

twilit smelt
#

bc one day i want to run mintia on gigantic numa amd64 big iron

#

historically there have been numa machines with hundreds or thousands of nodes

shadow ridge
#

if you have 1024 nodes thats like 8 mib if you store distance as int64

#

hmm yeah it is kinda a lot

#

oh wait youre not storing the distance

#

do the nodes have ids or something

#

or do you have pointers to node structures or whatever

twilit smelt
#

the arrays will probably store 16 bit node IDs for space

shadow ridge
#

0.5 gigs for 16384 nodes

#

i think it's a little too much

#

you can def beat linux here

twilit smelt
#

there has never been a 16384 node numa machine

#

the largest ive ever heard of was like 2048 node SGI Origin

shadow ridge
#

like

#

get with the times bro

#

anything could happen

twilit smelt
#

and to instead do distributed computing over high speed network

#

like SGI Origin was a supercomputer arranged as a single computer in a massively complex NUMA configuration

#

modern supercomputers are arranged as hundreds or thousands of smaller computers (each of which may or may not be NUMA) which are connected over a network

#

this is more innately fault tolerant and it also scales better i think

#

so O(n^2) space complexity in number of numa nodes is probably fine

shadow ridge
#

i have a question

#

why cant you just sort the nodes into a single array

#

and use indices into that like

twilit smelt
#

because the array has to reflect increasing distance from a particular node

shadow ridge
#

it's not like you can have A,B,C where C is somehow closer to A than B

twilit smelt
#

theres no global distance ordering

#

wdym

shadow ridge
twilit smelt
#

keep in mind the topology of a NUMA system is often 2 dimensional, 3 dimensional, or higher

image.png
#

thats an SGI origin diagram

shadow ridge
#

use eucledian distance to sort?

twilit smelt
#

euclidean distance from what?

shadow ridge
#

origin

#

idk

twilit smelt
#

the origin is the node youre on and are trying to allocate a page from

#

therefore there are as many origins as there are nodes

#

so you need an array per node

shadow ridge
#

idk i feel like there has to be a way to store this in less than O(N^2)

raven drift
twilit smelt
#

thats a little more involved though

#

memory is easy because its just like

#

check my node. any pages? no? ok.

#

check next node. any pages? no? ok.

#

check next node. any pages? yes? grab one

#

its like a binary choice

#

scheduling is more difficult because you can just keep piling threads into a node

#

so you need to decide when its worth it to start searching for a lower load node to shove it onto

raven drift
raven drift
twilit smelt
#

since they inevitably result in pathologies in the corner cases

#

its like trying to stomp a lump out of a rug

raven drift
twilit smelt
#

also my numa support seems to be more distributed than linux's... on linux u have to pointer chase through tables on the boot node a lot including whenever you free a page frame

#

my numa node lookup table is KE_NODE_SPACE_START + ((id) * KE_NODE_SPACE_SIZE)

#

they each get their own segment of kernel space in order to separate the page tables out, and the central per-node structure is at the base of the segment, which is not a thing linux seems to do

#

we both have in common the skill issue of the page struct array being centralized though

#

i try to map it with pages from the node but this fails if page frames from multiple different nodes lie within the same page frame of page structs

#

and in any case the upper levels of the page tables are always going to be on the boot node

raven drift
#

fwiw on a real hw implementation, upper levels of kernel page tables are probably in L2 cache anyway

twilit smelt
#

i know, its probably not a huge problem in practice or linux wouldnt be doing it like that

#

i was trying to split up absolutely everything though and i failed on like just a couple of little things which annoys me

raven drift
#

does linux not try to map the struct pages with per-node memory?

twilit smelt
#

it does

twilit smelt
#

and the upper page table levels used to map it will always be on the boot node as well

raven drift
#

yeah but that (= overlapping a page containing struct pages over multiple nodes) is only a small edge case overall

twilit smelt
#

so you always risk hitting remote node memory when you touch a page struct for a local page

#

this could be "fixed" by making the page struct array be segregated per-node but this would require a less efficient indexing scheme

#

which could potentially be slower anyway

digital pivot
#

so all partitions operate on the global pfn db?

#

and each stores in some form range that can be used by this partition?

twilit smelt
#

i figured it would end up being way slower in practice to try to locate the node-local parts of the page struct array inside the node-local segments of kernel space so i just made it central and global and linux seems to have made the same choice

#

it would work if you could get some kind of cool guarantee from the hardware that like the upper N bits of the PFN are the node ID

#

thatd allow super efficient indexing

#

but i dont think thats a portable assumption lol

#

in the absence of any clean scheme to compute the node ID directly from the PFN youd have to resort to a binary search over an array of PFN ranges or something

#

which would be fast but still much much slower than directly indexing

#

also for now ive failed to replicate the phys mem for the kernel text section and read-only data

#

which is just because the way things are linked currently, it ends up all fitting inside the same 4mb range mapped by the same page table

#

so you cant really get different mappings for those pages from different nodes because they share most of the upper level page tables

#

for now

#

i could fully replicate the upper level page tables that map the range in which kernel modules fall

#

and then do it

#

and i might do that

digital pivot
#

do you already have any specific plans on numa aware cpu scheduling ?

twilit smelt
#

ill probably copy whatever ULE does

#

something ive barely been thinking at all about is per-node IO

#

modern numa configurations almost exclusively divide the nodes as groups of RAM and/or CPUs

#

with IO being shared

#

but that hasnt always been the case

#

per-node disk controllers and stuff have been a thing

#

they might still be im unsure

#

the vast majority of modern numa shares that kind of hardware though

#

the AViiON numa systems from the late 90s had per-node disk controllers that would negotiate to access a shared set of hard disks which they would dynamically divide between them

#

and change who was responsible for what disk based on demand

#

so if node 5 is accessing hard disk C that is currently being controlled by node 2's controller

#

a lot

#

it might decide to reassign hard disk C to node 5's controller so that it no longer has to go through node 2 to access it

#

this was called CLARiiON and it was the longest lived part of Data General after it got bought out because it was sick as hell

#

they were used into the early 2010s

#

im using the term "hard disk" loosely these were actually logical volumes

#

which could be comprised by several physical disks

blissful smelt
twilit smelt
#

striped and mirrored and so on

digital pivot
twilit smelt
#

yes

digital pivot
#

the original write up said it didnt

#

at the time

twilit smelt
#

it changed a lot

#

it supports arbitrary topologies now p sure

#

unless im completely misremembering

twilit smelt
blissful smelt
# digital pivot does ule support numa ?

it's a bit debated as to whether or not ULE Or Linux has a better approach of load balancing on NUMA... Linux load balancing sometimes ends up having MORE than 1 thread per logical processor (leaving some logical processors with no threads) on NUMA systems if you have N threads and N logical processors

which means some CPUs have extra work, and some have none

due to load balancing heuristics

raven drift
digital pivot
raven drift
#

Large servers have NUMA affinity for PCIe busses

twilit smelt
blissful smelt
# twilit smelt explain 2 me

it's quite simple, basically a "scheduler domain" is a group of CPUs that increases in size at different topology levels

a few examples of topology levels are
SMT
Node
Socket
Machine-wide

and the idea is that you traverse from the bottom going up to search for places to load balance

for example, you check your SMT sibling first, then your Node, then the socket, etc.

and as you go up, there are heuristics to say "How much more load must that other domain have for us to consider taking work from it" (e.g. the base for cross-node migration is a 25% discrepancy if i remember)

twilit smelt
#

this is exactly what ULE does im pretty sure

blissful smelt
#

copy cat

digital pivot
#

everyone does that

#

expanding criteria over topology

blissful smelt
#

ya they call it cpu_group there

digital pivot
#

from local as possible to the node to the N

twilit smelt
# raven drift Large servers have NUMA affinity for PCIe busses

i was probably looking at smaller numa machines and over-extrapolated to the larger ones. i was under the impression ones large enough to warrant per-node IO wouldnt have much of an existence because at that scale people now tend to use multiple machines networked rather than a single numa machine

#

but i was wrog

#

you can tell me to rtfm but can you tell me about how that affinity works

#

are there multiple physical PCIe busses

#

per-node or maybe a smaller number

icy bridge
#

you'd only have to fall back to binary search in the remote page case which is slow anyway because it's remote

twilit smelt
#

thats true

#

i still think adding that branch and also grabbing the pointer to your own node (which is something like percpu()->node) would end up being slower since youd ultimately end up with a pretty high cache hit rate for the upper page table levels which are the real problem

#

im also lazy and dont want to try it

#

im getting sick of the numa stuff since its been occupying all of my meager hours i have to work on this for like 4 months now

#

once i add memory and scheduling affinitization (currently, its fully divided and you can't schedule on or allocate from a remote node) ill be done with it for now

#

future components like the IO subsystem (which i still somehow havent started) will be written ground up with NUMA in mind so it should be fairly easy

#

per-node IO databases is gonna be a thing

#

aside from config which i wont bother with

#

like device matching information for the iokit-like drivers im gonna have

#

since thats a driver init time thing and who cares

#

thatll just be global

twilit smelt
digital pivot
#

how do you get current numa node isntead ?

twilit smelt
digital pivot
#

ah i was thinking you are doing something different

devout geyser
flat dust
devout geyser
#

i see you have a few manuals on github, when combined manuals meme

devout geyser
twilit smelt
#

this is such a good threat

#

nothing ruins technical sincerity more than... marketers...

flat dust
#

they gotta be evil

blissful smelt
#

i just remembered u sent this message and i had a neuron activation

twilit smelt
#

i thought of zonelists while thinking about how to do affinitized memory allocation and thought it sounded stupid so i went to see what linux does and it was doing zonelists

#

was gonna discard that idea as being obviously bad

#

oh well

blissful smelt
#

since CPU groups/scheduling domains were kind of brought up, i figured I would bring up my idea of potentially making them more dynamic on heterogenous numa machines by representing the processor topology as a multidimensional space and using an r*tree to represent the groups (for my project)

for example, one dimension might be CPU frequencies, one might be numa distances, one might be LLC sharers

my thought was that as topology increases in complexity in non linear ways I can just add more dimensions to represent those extra dimensions of variance

I think this is probably egregiously ridiculous but it was a little idea I had

I remember reading something somewhere that used multidimensional spaces for heterogenous load balancing

digital pivot
#

actually it was already discovered here

#

#1322494605819908156 message

hollow musk
#

well an "age list walker" seems clear enough, why you need an AVL tree of them i've got no idea yet
they could've done just [8] of them but they didn't

AgeListWalkers belongs to the top level enumeration of working sets, that is why it's stored in the partition aging control structure not in MMWSL_INSTANCE

fair jetty
#

when mintia age verification to comply with the Utah law enforcing age verification for all OSes in Utah??

flat dust
flat dust
shadow ridge
#

os level age verification is the dumbest shit ive ever heard of

#

computers dont fall out of the sky onto children's hands

tame phoenix
#

just refuse

#

if youre not in the us, never mind californa, wha they gonna do, shake their finger at you?

#

and when youre prompted by windows, linux, whatever, just enter 120

flat dust
tame phoenix
#

I would be tempted to put huge numbers in to break it

#

like MAXINT

hollow musk
#

it seems that the scheduler took a lot of inspiration from the freebsd scheduler

#

is there any specific reason?

#

I expected to see something much more similar to NT, considering that the kernel structure is very similar

flat dust
warm mural
#

It's like 10% the code of the Linux scheduler for 90% of benefits

devout geyser
hollow musk
#

that's probably a bit of an exaggeration

warm mural
#

Ok maybe 20% 80%

#

There was a CFS vs ULE paper

flat dust
warm mural
#

ULE was as good or a bit worse than CFS

devout geyser
flat dust
hollow musk
#

it's quite surprising to me that this went unnoticed

flat dust
devout geyser
#

apparently there used to be PacBSD which was arch but freebsd but its been discontinued

flat dust
#

sucks

#

i feel like archlinux is just pacman and fastfetch images pain

#

i think fastfetch images are in the binary itself

#

idk

warm mural
#

In my kernel I do exactly as freebsd for load balancing I think

#

Every second or so + a random jitter

hollow musk
warm mural
#

For the study I mean

hollow musk
#

yes, they actually ported ule to linux

warm mural
#

Was the study done on the fixed code

#

okok

hollow musk
#

the authors themselves admit that none of them became the best in all indicators

twilit smelt
#

the policy is FreeBSD's

#

you can tell im sophisticated rather than a hack fraud because i stole from TWO other projects rather than just one.

hollow musk
#

it's interesting that you inherit not only the priority, but also the interactivity class

flat dust
hollow musk
#

it turned out to be not quite what I thought

digital pivot
#

or well idr why you didnt want to borrow them from nt

twilit smelt
#

i just thought ULE seemed very efficient and nice

#

and knew whatever NT was doing was like 5x more complicated and probably not 5x better

hollow musk
#

like linux, they are probably trying to solve many more problems in their scheduler than freebsd

shadow ridge
dense vigil
#

its completely original

icy bridge
#

exactly

warm mural
#

even better programmers NIH everything and make a shitty kernel with a pretty looking userspace

dense vigil
#

^

warm mural
#

genuinely the serenityOS userpace is amazing tho

dense vigil
#

yeah it uses nih grpc

warm mural
#

The frameworks sound nice to work with and the user apps are very cool

dense vigil
#

LibMain

digital pivot
#

how fair is windows scheduler actually

blissful smelt
#

cutler cutler on the wall who is the fairest of them all

flat dust
#

NT

#

nt is a team though

#

so its different

tame phoenix
#

windows __N__ot __T__oday

flat dust
#

the userspace team came from windows 98 so thats why it sucks trl

#

con\con

tame phoenix
#

c:\con\con lol

#

and the ping of death and the fragmentation attack

flat dust
#

os/2 propaganda

cunning mortar
#

we love OS/2

tame phoenix
warm mural
#

To be fair they had compatibility restrictions

flat dust
warm mural
#

They had to run with old windows apps

tame phoenix
#

the only problem with os2 was ibm

flat dust
#

EVIL paging™

twilit smelt
#

my first favorite is su con

tame phoenix
#

yup, except PowerPC found it's way into macs, and Xbox 360s

cunning mortar
flat dust
#

also the entire OS in ring 1???

cunning mortar
#

it was fun honestly

flat dust
cunning mortar
#

yes

flat dust
craggy spire
tame phoenix
#

my first os was a 16 bit real mode os lol

warm mural
flat dust
# flat dust fair enough

im thinking of trying to make a 286 os except its even more impractical than a 386 os with segmentation

tame phoenix
#

bought to life with the power of Ralph browns interrupt list

flat dust
#

sadly

warm mural
#

You can use C

#

It'll just suck

flat dust
#

i wonder whats the i8/960 programming experience is like, its probably cursed to heck

#

risc 👍

queen torrent
#

you can probably find some ancient compiler to compile it for you if you really want to do it

flat dust