Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
Dead_Bush_Sanpai has joined #osdev
<kof673>
hmm...i will add space for: (foo(bar(baz))) versus if ( foo( bar( baz() ) ) ) it depends on nested parens
<kof673>
i would not do: if ( SSIZE_MAX < size ) or if ( bar ) only if nested parens
<kof673>
# ( 0 > fork() ) a supposed "valid" use is it is supposed to catch = typo versus == (0 = foo) will fail, (foo = 0) will not.
bradd has quit [Ping timeout: 265 seconds]
Gooberpatrol66 has quit [Quit: Konversation terminated!]
Gooberpatrol66 has joined #osdev
heat_ has joined #osdev
heat has quit [Read error: Connection reset by peer]
mubluekoor has quit [Remote host closed the connection]
alpha2023 has quit [Ping timeout: 260 seconds]
alpha2023 has joined #osdev
memset has quit [Ping timeout: 260 seconds]
voidah has quit [Ping timeout: 246 seconds]
levitating_ has joined #osdev
Gooberpatrol_66 has joined #osdev
memset has joined #osdev
Gooberpatrol66 has quit [Ping timeout: 276 seconds]
bradd has joined #osdev
memset has quit [Remote host closed the connection]
memset has joined #osdev
netbsduser has joined #osdev
vai has quit [Ping timeout: 252 seconds]
xenos1984 has quit [Read error: Connection reset by peer]
netbsduser has quit [Ping timeout: 248 seconds]
xenos1984 has joined #osdev
goliath has joined #osdev
xal has quit [Quit: bye]
xal has joined #osdev
alpha2023 has quit [Read error: Connection reset by peer]
alpha2023 has joined #osdev
levitating_ has quit [Remote host closed the connection]
levitating has joined #osdev
janemba has quit [Read error: Connection reset by peer]
mubluekoor has joined #osdev
janemba has joined #osdev
mubluekoor has quit [Remote host closed the connection]
mubluekoor has joined #osdev
mubluekoor has quit [Client Quit]
mubluekoor has joined #osdev
mubluekoor has quit [Client Quit]
mubluekoor has joined #osdev
mubluekoor has quit [Quit: mubluekoor]
bradd has quit [Ping timeout: 248 seconds]
masoudd has joined #osdev
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
Dead_Bush_Sanpai has joined #osdev
GeDaMo has joined #osdev
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
Dead_Bush_Sanpa1 has joined #osdev
Dead_Bush_Sanpa1 is now known as Dead_Bush_Sanpai
levitating has quit [Read error: Connection reset by peer]
memset has quit [Remote host closed the connection]
memset has joined #osdev
levitating has joined #osdev
levitating has quit [Max SendQ exceeded]
levitating has joined #osdev
levitating has quit [Max SendQ exceeded]
levitating has joined #osdev
levitating has quit [Read error: Connection reset by peer]
levitating has joined #osdev
fedaykin has joined #osdev
<heat_>
mjg, where do you buy your perfumes, at the freebsd mall?
strategictravele has joined #osdev
fedaykin has quit [Ping timeout: 246 seconds]
strategictravele has quit [Ping timeout: 252 seconds]
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
Dead_Bush_Sanpai has joined #osdev
spareproject has joined #osdev
<mjg>
heat_: the openbsd mall
jjuran has quit [Quit: Killing Colloquy first, before it kills me…]
jjuran has joined #osdev
CaptainIRS has joined #osdev
bradd has joined #osdev
memset has quit [Remote host closed the connection]
memset has joined #osdev
memset has quit [Remote host closed the connection]
memset has joined #osdev
xenos1984 has quit [Read error: Connection reset by peer]
levitating has quit [Remote host closed the connection]
frkazoid333 has quit [Ping timeout: 276 seconds]
<sortie>
<zid> sortie: gcc 10 ish switched from -fcommon to -fno-common also
<sortie>
<zid> which tends to give you.. multiple definition errors
<sortie>
That's good to know. I never knew about that option. Always thought that was the default lol
levitating has joined #osdev
<mjg>
ye the common thing is a massive port build fallout provider
xenos1984 has joined #osdev
<sortie>
I imagine yeah
<sortie>
The whole -Werror=implicit-function-declaration thing is way worse than that in terms of port breakage
<mjg>
so funny bit is that a lot of c code out there is just straight up dead weight
<sortie>
Fun fact: I did this myself for pain and glory years ago by injecting it into CFLAGS and suffered through all of the breakage and fixed it
<mjg>
these ports happen to compile and some twat insists of of not migrating
<mjg>
the thing to do for anything de facto unamintained upstream for (say) 10+ years is to whack it
<sortie>
People need to maintain their stuff or it doesn't belong in the core system
<mjg>
instead things keep getting patched up as the compiler getss updated
<mjg>
there is regular fallout in freebsd as some old and equally bad c code trips on a new clang warn
<mjg>
in the ports tree
<mjg>
the project boasts something like 30k_ ports
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
<mjg>
except at least 20% of that is total garbage
<sortie>
Yeah I imagine
<sortie>
I have just 90 ports and they are quite core
Dead_Bush_Sanpai has joined #osdev
<kof673>
> implicit-function-declaration i see tons of this with old binutils and gcc, libiberty, doesn't like semi-"modern" systems seemingly.....but unless it causes a crash at run-time, just not worth the time to patch it IMO
<mjg>
well i think "port" in sortix context is not really a port in the same sense
<mjg>
more like a 3rd party software for inclusion in the base system
<kof673>
or they helpfully provide their own "declarations" just in case some ancient system does not have headers? :/
<mjg>
lemme tell you a funny story kof673
<mjg>
there was a transition period, and it probably still happens somewhere, where utter garbage 32-bit binaries got recompiled to 64
<sortie>
mjg: The editorial guidelines are a bit more like that yeah. My ports are quite core things. I don't want to include 30k ports in this system. I'll want an extra community level ports tree for people's random shit
<mjg>
they notoriously don't include the header to malloc
<sortie>
The ports here are the ones that go into the base system
<kof673>
i'm guessing data pointer is different size?
<mjg>
so when you happen to get an allocation which happens to give you a pointer above 3G...
<sortie>
mjg: I do still use the port word because the ports system is actually quite BSD like in terms of how it's done (metadata + patches) and goes on top of the base system which is standalone (but not fully self-hosting, needs a few ports).
<mjg>
there is the sign extensnion and you crash
<mjg>
with 0xffffff....
<mjg>
sortie: as is usual with "it", terms are overloaded to fuck, so i have no qualms :p
<mjg>
(i mean who can tell me what a THREAD is, go on)
<sortie>
I am going intentionally for a BSD vibe here even if a bit different :)
<sortie>
Sortix actually has a thread concept that makes sense lol
<mjg>
(here is a better one: what is a HARDWARE THREAD)
<mjg>
(ask a webdev, go ahead)
<nikolar>
lol
<mjg>
no, really
<mjg>
lemme tell you waht i heard their take is: it's what systems people would consider an actual thread
<mjg>
something you created with clone, pthread_create or whatever the fuck
<mjg>
nothing to do with cpu
<nikolar>
why would that ever be a HARDWARE thread
<mjg>
cause webtard
<nikolar>
i mean fair enough
<mjg>
the term 'thread' is borderline meaningless in the webland
<mjg>
so they had to add *something* except chose poorly
<nikolar>
lol very poorly
<mjg>
hey, nikolar
<nikolar>
oi mjg
<mjg>
what do you think "a system call" is in the webland
<nikolar>
do i want to know
<mjg>
i'm gonna tell you: an invocation of system()
<nikolar>
:|
<kof673>
*just in case some ancient system has the function but not the header lol
<nikolar>
don't tell me they actually do that mjg
<the_oz>
my threads are green :( >green pants
<mjg>
i don't know how widespread it is, but they totally do
<sortie>
^^^^^^ ugh. Definitely trash -fno-common issues in libreadline.
<kof673>
emx is os/2 innit ? :D
<nikolar>
mjg: i hope it doesn't mean that you actually git commit once a day
<sortie>
You ever see a block like that and you just know it's pain for new operating systems
<mjg>
nikolar: depeonds on webdev, the worst is literally commit to master
<mjg>
nikolar: whatever you got
<the_oz>
I've worked at a "webdev" shop. Means upload to winscp my local directory
<the_oz>
peak tier retardation
<nikolar>
mjg: oh yeah what was the thing called
<nikolar>
like "always having your project in a state you can release it in"
<the_oz>
>it can always be worse
<sortie>
nikolar: I do believe in that but it does require persistent quality testing
<nikolar>
sortie: you might believe in it, but it definitely doesn't mean "push everything you've got to master daily"
Left_Turn has joined #osdev
<sortie>
nikolar: It certainly does not. Where's the code review?
<nikolar>
lol
memset has quit [Remote host closed the connection]
<mjg>
sortie: bro
memset has joined #osdev
<mjg>
so what the advice means is the thing here -- it depends on the person
<sortie>
For Sortix, I don't have many code reviewers, so where I do is commit daily to my history unstable staging branch, then that is automatically rebuilt every night as a full system rebuild. Lots of coverage that way. I then do more testing and rebase and rewrite history until the code is perfect and then I merge.
<mjg>
part of my complaint about things being ambiguous
<mjg>
so for example sortie, there are people who genuinely don't use any VCS
<sortie>
Not great, but it does get a high bar of quality when I don't have many reviewers.
<mjg>
then you force them to, say, git
<mjg>
and you get committing to master whatever shit they got going
<mjg>
you basically cannot assume any sanity upfront
<sortie>
Code. Review.
<mjg>
and when a statement is made with numerous implicit assumptions, you are losinig
<sortie>
It's the magical tool for getting junior people better
<mjg>
lol what code review, there is no time, besides it's not part of the customer story
<nikolar>
^ lol
<sortie>
My job was literally to make it impossible for developers, including myself the admin, to bypass code review without breaking glass and setting off loud alarm bells
strategictravele has joined #osdev
<the_oz>
is it normal to not assume master is not bleeding edge?
<the_oz>
what do you assume if not that
<sortie>
master/main usually is yeah
<sortie>
If not, then it's project specific
<nikolar>
at work, master is production
<nikolar>
other branches for dev
<sortie>
Probably some experimental branches not yet merged
<sortie>
For work, we have the stable/beta/dev branches where master is merged at special release times
<the_oz>
I suggest renaming master to prod so you can be explicit about holy areas
<mjg>
sortie: you may be living in a bubble
<the_oz>
keep master as a catcher, so you can razz the newb etc
<sortie>
mjg: My job was literally engineering productivity, building the highest levels of quality in testing, code review, supply chain security, benchmarking.
<sortie>
If you need a job well done, I'm your man.
<mjg>
12:17 < mjg> sortie: you may be living in a bubble
<nikolar>
kek
<mjg>
would you like a more commonsly seen approach
<nikolar>
the average dev/company doesn't work like that at all
<sortie>
I'm literally building the bubble
<nikolar>
sorry, webtard
<mjg>
cause it boils down to doing shit in stupidest way imaginable
<nikolar>
^
Turn_Left has joined #osdev
<sortie>
mjg, my job was taking a poor development situation and turning it into a world class workflow with the highest qualities :)
<the_oz>
you know how to avoid conflicts in webtard shop land?
<nikolar>
at work we hired a consulting firm to help us move to ci/cd, and their first suggestion was to basically refactor all of our code to be "oop"
<the_oz>
rename top level directories with your name
<kof673>
mjg: that lack of malloc() declaration probably will happen with old gcc/binutils toolchains built on 64-bit :D
<mjg>
sortie: solid
Left_Turn has quit [Ping timeout: 246 seconds]
<mjg>
well i may have been a little overblowing the problem, so here a more accurate take:
<sortie>
wtf is ssh now failing to include netinet/in_systm.h after upgrading gcc, ssh is unconditionally including it and I had the header all along
<mjg>
vast majority of so-called devs don't know much and don't give a shit either, they will do stuff which provides them with lowest friction
<mjg>
but this also means plenty of times they are going to do something stupid
<mjg>
there is no understanding of the landscape of anything, they get some bullshit they can live with and roll with it
<mjg>
finally, should you present a real workload but which also happens to add extra steps, you are going to get pushback literally on those grounds
<sortie>
It doesn't even use those n_short/n_long/n_time typedefs
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
Dead_Bush_Sanpa1 has joined #osdev
<sortie>
mjg: I definitely had some pushback rolling out improvements but my team was actually incredibly understanding, as long as I had a good rationale and had a clear new workflow ready for them, they were willing to change and upgrade as long as they had clear instructions and it was thought out
<sortie>
I adored that in the team.
<the_oz>
I appreciate that mindset muchly comparatively to the tryhards at decidedly the worst solution. Like someone who suggests emacs/vim opposed to a visual editor with NOMODES
<mjg>
12:18 < mjg> 12:17 < mjg> sortie: you may be living in a bubble
<mjg>
good for you man
<sortie>
mjg, more like, you know, good people doing quality work.
<mjg>
while you were doing that, a fucking twat at red hat cargo culted dumbfuck code
<sortie>
Which is better for profit and long term sdtuff
<mjg>
and when i pointed how this is avoidable, he thanked for feedback and left it in
Dead_Bush_Sanpa1 is now known as Dead_Bush_Sanpai
<sortie>
It's okay there's lots of stuff out there that isn't that good
<mjg>
it then landed in prod
<mjg>
:d
<sortie>
Leave the important stuff to the professionals
<mjg>
that's your general red hat experience
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
Dead_Bush_Sanpa1 has joined #osdev
<mjg>
ey sortie, i just remembered this doozy
Dead_Bush_Sanpa1 has quit [Read error: Connection reset by peer]
<mjg>
there was a big repo for scripts
<mjg>
everyone and their dog could commit there
<mjg>
so
Dead_Bush_Sanpai has joined #osdev
<mjg>
a new hire decided to practice git on it
<mjg>
they added a bunch of bullshit files with bullshit commit messages just for that reason
<mjg>
all pushed
<mjg>
404 sanity not found
<mjg>
not many people know this but "rh" stands for "regrettable hire" and they achieved liek 80% coverage
<mjg>
there was literally no oversight or any sort of leadership either. everyone competent was mentally checked out
<mjg>
the idiots were left to their own devices, you just made sure they don't mess with your code
<mjg>
which is why you kept it separate
<mjg>
of course heat_ would tell you they were all doing their best
<mjg>
which if true would make my opinion or them go even lower
<mjg>
of*
<mjg>
anyway time to do some productive (in this case grab lunch)
<nikolar>
enjoy lunch mjg
craigo has joined #osdev
_rink has quit [Quit: leaving]
Left_Turn has joined #osdev
levitating has quit [Remote host closed the connection]
Turn_Left has quit [Ping timeout: 246 seconds]
Turn_Left has joined #osdev
Turn_Left has quit [Remote host closed the connection]
Turn_Left has joined #osdev
Left_Turn has quit [Ping timeout: 246 seconds]
Left_Turn has joined #osdev
strategictravele has quit [Ping timeout: 246 seconds]
Turn_Left has quit [Ping timeout: 260 seconds]
strategictravele has joined #osdev
strategictravele has quit [Max SendQ exceeded]
strategictravele has joined #osdev
strategictravele has quit [Quit: strategictravele]
strategictravele has joined #osdev
Left_Turn has quit [Ping timeout: 265 seconds]
edr has joined #osdev
<immibis>
i commit to master on all my personal projects because *why the heck wouldn't i* because i am the only one who cares
<immibis>
as your organization gets bigger you find more needs for more processes, but the smallest have very few needs
<immibis>
(organization != company)
<immibis>
(also half the time the commit message is "did stuff" because the main purpose of even having a repo is to create an undo point *before* i possibly fuck it up, not to record what happened *after* i did it)
<mjg>
bro all my contributions to everything are "wip", "fix" and "revert" (or "fix by revert")
<mjg>
past that the diff speaks for itself!
<immibis>
half the time it's "unknown changes since i last committed 6 months ago"
<mjg>
well you do you mon, but i argue that's bad
<mjg>
even my own personal stuff has at least a skeleton commit message
<mjg>
notably with BUGS:
<mjg>
so that i don't have remember
* immibis
wonders why resize2fs needs to run one thread per hardware thread
<mjg>
? :D
<immibis>
sure... if you actually have something to write
<mjg>
how is that multithreaded to begin with
<immibis>
i noticed on iotop resize2fs runs 48 threads
<immibis>
exactly!
<mjg>
it is an anti-idiom tho
<mjg>
you want a "thread pool"., so how many?
<mjg>
you grab nproc and that's how many~!
<immibis>
this is logical if your work is CPU-bound
<mjg>
it is not
<mjg>
works great on a laptop
<immibis>
upgrading my CPU does not make my drive have more IOPS
<mjg>
goes to shit when you try to run on someting bigger
<immibis>
why doesn't it make sense to do CPU-bound work on each CPU?
<immibis>
nproc is a good number for `make -j`
<immibis>
assuming your compiler isn't amazingly fast
<bslsk05>
discourse.llvm.org: Avoidable overhead from threading by default - LLD - LLVM Discussion Forums
<mjg>
as for make -j specifically, i have another one
<mjg>
people i know elsewhere have a big build box
<mjg>
something like 192 threads
<mjg>
but the build process de facto maxes out at ~60 in terms of usable parallelism
<mjg>
past that they literally waste cpu time by having higher -j
<mjg>
it's not i/o but lock contention
<mjg>
(and on linux at that)
<immibis>
that is about spawning 100 threads to do ~0 work
<immibis>
when you have work to occupy 100 threads, and 100 hardware threads, you should use 100 threads. 50 in some instances where SMT makes things worse.
memset has quit [Remote host closed the connection]
<immibis>
"For your 48 core Cascade Lake, ninja will start ~48 jobs. If many of them are lld, you will completely oversubscribe the machine." - hey isn't managing this sort of thing supposed to be what an OS does?
memset has joined #osdev
<mjg>
well suppose you work program has enough work to occupy youre ntire laptop
<mjg>
then it gets to run on a bigger machine
<mjg>
and does not have the work to occupy everyone, even if it was a good idea to do it
<mjg>
and this is how spawning as many threads as nproc says are available is bad
masoudd has quit [Read error: Connection reset by peer]
masoudd has joined #osdev
X-Scale has joined #osdev
voidah has joined #osdev
spareproject has quit [Remote host closed the connection]
<heat_>
hi mjg how was it killing itanium
<heat_>
did you feel the adrenaline
<mjg>
haha ahahah haha ahah maybe ask people who actually did it
<PublicWiFi>
ive sparked a small debate on threading methodologies on the internet and maybe you guys can help me decide lol
<mjg>
PublicWiFi: 1. don't do threading
<mjg>
yer welcome
<heat_>
i know the guy who pulled the trigger actually
<PublicWiFi>
im working with a z80 so its super old tech, no protected mode and all that
<PublicWiFi>
co-op vs preemp :P
<PublicWiFi>
mjg: :(
<heat_>
for a z80 maybe coop makes more sense than in a normal system
<PublicWiFi>
all the old timers argue co-op best, but other say time-slice is better if you suck at asm
<heat_>
however preemptive is far superior like it's literally 2024 dude we've gone past ms-dos for 25-30 years
<PublicWiFi>
cause its easier to add bugs to co-op
<heat_>
what old timers? UNIX people would advocate for preemptive as well
<PublicWiFi>
well co-op also means you gotta add in yields and shit to all of your routines/executables
<PublicWiFi>
which is annoying, with preemp i can just write a program
<PublicWiFi>
lol
<heat_>
well, there you go
<PublicWiFi>
old timers as in peoplpe who mess with vintage electronics
<heat_>
use preemptive
<PublicWiFi>
do modern OS's use a hybrid system? like if a thread is done it can just yield/end and let the next one run?
<heat_>
what?
<heat_>
thread is done what?
<PublicWiFi>
<- is dumb
<heat_>
modern OSes use preemption
<PublicWiFi>
ah ok
<heat_>
although as a peculiarity UNIX kernels switch somewhat into a cooperative mode when in the kernel
<mjg>
normally there is no such thing as a thread being done with stuff
<mjg>
rather you go off cpu as a side effect
<PublicWiFi>
ah I see
<mjg>
sayy ou want to read a file
X-Scale has quit [Ping timeout: 256 seconds]
<mjg>
but actual i/o needs to be issued
<mjg>
so yo uare off cpu until that's done
<nikolar>
or you can wait on a mutex
<nikolar>
and go off cpu
<heat_>
>wait on a mutex
<heat_>
downvoted by mjg
<nikolar>
kek
<PublicWiFi>
lol
<mjg>
heat_: correct
<nikolar>
i am giving examples of going off cpu
<heat_>
DONT SLEEP
<heat_>
STAY HARD
<nikolar>
not for scalable code
<nikolar>
heat_: for (;;) ;
<PublicWiFi>
you know i was naive thinking that I could learn how to make an 8-bit kernel and OS from scratch
<mjg>
at this point i don't even synchronize
<PublicWiFi>
cause its 8-bit right? it has to be easier
<immibis>
of course when a thread has nothing to do the system doesn't just wait for its time slice to finish for no reason
<PublicWiFi>
DUMB
<PublicWiFi>
DUMB DUMB DUMB
<heat_>
oh i'd say it's harder
<PublicWiFi>
now im hip deep in thread theory and shit
<heat_>
i can't write 8-bite code lol
<PublicWiFi>
idk wtf im doing lol
<immibis>
8-bit machines don't really have separate kernels so much because there is no protected mode
<mjg>
idk man, 8 bit is 1/4th the rouble
<PublicWiFi>
yeah but you can just design your routines and such to never enter kernel space
<immibis>
well you can but all the protection systems don't apply
<heat_>
PublicWiFi, hint: skip it all and do preemptive
<PublicWiFi>
but yeah its an honor system
<PublicWiFi>
and mem leaks can ruin your kernel lol
<nikolar>
if you want to do it for fun, then go cooperative, but if you want to do it "properly" go preempiteve
<nikolar>
preemptive
<PublicWiFi>
yeah I had preemp running on a 60hz timer but the old timers convinced me to change
<PublicWiFi>
but i think ima go back lol
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
<immibis>
and if you don't have that hard protection barrier do you really need as much separation? a lot of those machines had roms full of useful routines - the rom/ram separation was more important than kernel/notkernel
<PublicWiFi>
i think cause its such old tech co-op is likely better for effieicny but mehhh
<heat_>
Ermine, why does minix larp netbsd everywhere except the network stack? lwip seems like a weird option for a supposedly desktop OS
Dead_Bush_Sanpai has joined #osdev
<heat_>
PublicWiFi, let the old timers expire!
<immibis>
you can still have preemptive multitasking without memory protection
<PublicWiFi>
heat_: LOL
<PublicWiFi>
I was thinking of doing a hybrid solution anyway
<PublicWiFi>
allowing threads to yield early if they want, but otherwise just stick to the time slice
<heat_>
well that's the normal idea
<PublicWiFi>
like int he event they are waiting for i/o or something
<heat_>
that is literally preemptive
<PublicWiFi>
oh
<PublicWiFi>
i thought preemptive was just straight up time slicing
<PublicWiFi>
lol
<heat_>
no
<PublicWiFi>
look at me reinventing the wheel
xenos1984 has quit [Read error: Connection reset by peer]
<heat_>
linux has a yield call and you can block on $stuff
<PublicWiFi>
I think the worst part about designing this shit from the ground up is figuring out what you want it to do
<PublicWiFi>
like... how many thread statuses do i wanna support?
<heat_>
it's actually pretty rare that threads stick to their full timeslice
<PublicWiFi>
too many and you risk runaway stuff
<PublicWiFi>
yeah that makes sense heat_ !
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
Dead_Bush_Sanpai has joined #osdev
<Ermine>
heat_: (I may be wrong but that's what I know) minix devs once decided to adopt netbsd userspace to supposedly reduce maintenance burden
memset has quit [Remote host closed the connection]
<heat_>
i was looking at a PR that replaced minix's network stack back in 2017. basically ripped out all of their userspace network utils with NetBSDs, but then replaced their old lwip stack with a new... lwip stack? bizarre
memset has joined #osdev
<Ermine>
further plan was to somehow introduce RUMP thing to minix, because that would make it easier to port netbsd drivers
<Ermine>
and lwip was some contigency thing to replace homemade tcp/ip stack which became unmaintainable
<PublicWiFi>
I found a super neat z80 project called SymbOS
<heat_>
in any case it's interesting to me if the netbsd network stack could easily be ported. i see the freebsd has a disgusting port into userspace that brings in a bunch of junk, apparently
frkazoid333 has joined #osdev
<heat_>
i think rump is dead?
<PublicWiFi>
but his tech documentation is limited. there's a dev handbook but it doesn't go into the super details about the circuitry I guess cause its based on existing systems
<Ermine>
apparently
<Ermine>
they choose netbsd out of {free,open,net}bsd because of portability afaik
<sortie>
I accidentally made sshd a oneshot service and removed its execution command ... lol ... no wonder the latest volatile build isn't passing the smoketest, you can't ssh into it.
<PublicWiFi>
okay last noob question and ill leave you guys alone lol. One place I'm really stuck is my message/queue system for threads to communicate.. I get the idea but I'm not sure about the execution...
<PublicWiFi>
like should I have a max msg length and let them send raw data, or should the messages pass pointers to data somewhere?
<immibis>
if you have only one address space anyway, why copy the data more than you have to
<PublicWiFi>
right
<sortie>
PublicWiFi: One important aspect is the lifetime of the data and what happens when you run out of memory. Is stuff preallocated ahead of time?
<immibis>
especially when you only have 64K of it
<sortie>
Do you make a copy and pass it around? Or do you pass pointers around?
<PublicWiFi>
it makes more sense to do pointers to conserve mem
<sortie>
Do you actually want threads to communicate with message passing? Or maybe they just do their work and lock stuff appropriately?
<sortie>
Threads with message queue processing is very Windows API
<PublicWiFi>
so should the message struct be like, sender thread ID, recepient thread ID, pointer to data?
<PublicWiFi>
im not sure to be hoinest
<sortie>
Perhaps you just want a worker thread pool where you can add tasks and some thread dispatches the task and locks the data structures
<PublicWiFi>
remember this is a z80 system haha
<PublicWiFi>
im stuck in design hell rn xD
<PublicWiFi>
i cant get started until I define all my criteria :(
<sortie>
PublicWiFi, honestly there's no better way to find out than start building
<sortie>
See what works, adjust, learn
<PublicWiFi>
yeah makes sense haha
<GeDaMo>
You don't know how to write a program until you've already written it
<PublicWiFi>
I'm just having trouble finding an abstract overview of a message queue system is all
<PublicWiFi>
just trying to find a small place to start haha
<sortie>
For stuff like this, the exact implementation is the key thing and it's hard to plan it ahead without a lot of experience
<PublicWiFi>
yeah :(
<PublicWiFi>
i can always adjust the message table as I go I geuss
voidah has quit [Ping timeout: 276 seconds]
<PublicWiFi>
ok thanks guys
<PublicWiFi>
ima just do the dang thing and see what happens haha
<PublicWiFi>
i had my threading working, so ill jsut experiment with messages
<PublicWiFi>
have*
npc has joined #osdev
<immibis>
are you in the trap of a solution looking for a problem? you want to use a message queue system but you don't have a reason to?
xenos1984 has joined #osdev
bauen1 has quit [Ping timeout: 252 seconds]
frkazoid333 has quit [Read error: Connection reset by peer]
goliath has quit [Quit: SIGSEGV]
memset has quit [Remote host closed the connection]
memset has joined #osdev
memset has quit [Remote host closed the connection]
memset has joined #osdev
memset has quit [Remote host closed the connection]
memset has joined #osdev
linear_cannon has quit [Ping timeout: 252 seconds]
linear_cannon has joined #osdev
gog has joined #osdev
<heat_>
PublicWiFi, fwiw if you're looking for an easier experience and haven't started yet, ditch the z80 for something saner
<heat_>
smaller definitely doesn't mean easier
<PublicWiFi>
naw
<PublicWiFi>
its part of the whole appeal
<PublicWiFi>
the difficulty and limitations
<PublicWiFi>
im designing the whole thing from the ground up, hardware and software :D
<Ermine>
you're still not designing the hardware though
<nikolar>
maybe he's desiging a z80 based computer
hwpplayer1 has joined #osdev
goliath has joined #osdev
<geist>
yeah always fun
<sbalmos>
Be like Usagi Electric and design it around a 1-bit industrial microcontroller
<bslsk05>
web.archive.org: The Gray-1, a homebrew CPU exclusively composed of memory – Unusual projects
<zid>
just treat each transistor in a 6502 as an actual transistor ^
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
Dead_Bush_Sanpai has joined #osdev
Dead_Bush_Sanpai has quit [Read error: Connection reset by peer]
Dead_Bush_Sanpa1 has joined #osdev
Dead_Bush_Sanpa1 is now known as Dead_Bush_Sanpai
xenos1984 has quit [Ping timeout: 248 seconds]
xenos1984 has joined #osdev
<sbalmos>
geist: I never have contacted him (Steve?), but the Centurion parts that he was gathering a few months ago, from the Butler Tech school... That school is literally 5 minutes away from me.
<geist>
oh neat
<sbalmos>
geist: I know a few teachers there, and do a joint first-flight thing with some of their Aviation students every so often
levitating has joined #osdev
valshaped7424880 has quit [Ping timeout: 264 seconds]
flom84 has joined #osdev
flom84 has quit [Remote host closed the connection]
valshaped7424880 has joined #osdev
memset has quit [Remote host closed the connection]
memset has joined #osdev
xenos1984 has quit [Ping timeout: 246 seconds]
xenos1984 has joined #osdev
Gooberpatrol_66 has quit [Quit: Konversation terminated!]
Gooberpatrol_66 has joined #osdev
Gooberpatrol66 has joined #osdev
Gooberpatrol_66 has quit [Ping timeout: 252 seconds]
<kof673>
PublicWiFi, what language(s) are you using and what compiler/etc. ?
<PublicWiFi>
ASM
<PublicWiFi>
z80 asm :D
<PublicWiFi>
i found some random assembler, but there's a bunch out there
<kof673>
i built zcc for ti83 plus (no longer own) i think you get like 8k for malloc lol
<kof673>
*z80 ^^^
<sortie>
You wanna do multi threaded message queue passing in z80 assembly?
<kof673>
so i do not plan to do anything with it, but it should be enough to run like wc, tr, etc. type programs just to ensure they work lol
<kof673>
*z88dk zcc is just the name of the compiler
netbsduser has joined #osdev
Gordinator has joined #osdev
GordinatorG has joined #osdev
GordinatorG has quit [Remote host closed the connection]
Left_Turn has joined #osdev
Turn_Left has joined #osdev
voidah has joined #osdev
Left_Turn has quit [Ping timeout: 244 seconds]
Matt|home has joined #osdev
strategictravele has quit [Quit: strategictravele]
voidah has quit [Ping timeout: 255 seconds]
<heat_>
tcp my dudez
<zid>
ICMP for life
<sbalmos>
I live at quic speed
<Matt|home>
hello.
frkazoid333 has joined #osdev
<heat_>
virgin quic user vs chad tcp enjoyer
<heat_>
http3? more like httpnothanks
levitating has quit [Ping timeout: 248 seconds]
<kof673>
this one goes to 11....mhz [*] #pragma output GimmeSpeed [*] joke is not necessarily accurate, pragma from z88dk