<dostoyevsky2>
netbsduser: could they just make a struct with function pointers, like .open, .readdir and so on?
<Ermine>
We don't speak like this in Russia though
<Ermine>
unless he wants to turn openbsd into GopnikBSD
<heat>
>with userbase without users is like masturbating.
gbowne1_ has joined #osdev
gbowne1_ has quit [Remote host closed the connection]
gbowne1_ has joined #osdev
gbowne1_ has quit [Client Quit]
navi has quit [Ping timeout: 268 seconds]
Left_Turn has joined #osdev
<Mondenkind>
hey. what does this mean
gog has quit [Quit: byee]
Left_Turn has quit [Read error: Connection reset by peer]
dude12312414 has joined #osdev
vdamewood has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
dude12312414 has quit [Quit: THE RAM IS TOO DAMN HIGH]
netbsduser has quit [Ping timeout: 255 seconds]
[Kalisto] has quit [Quit: No' vemo']
[Kalisto] has joined #osdev
<Ermine>
base
<Mondenkind>
mastu(se)rbase
<heat>
master linxu ekrnel operating system
<heat>
use useu se linux
dude12312414 has joined #osdev
dude12312414 has quit [Remote host closed the connection]
vdamewood has joined #osdev
oldgalileo has quit [Ping timeout: 268 seconds]
oldgalileo has joined #osdev
nikolapdp has joined #osdev
<nikolapdp>
whoop
<zid>
what have you broken now
<kof673>
http://ibiblio.org/pub/linux/kernel/linux-lite-v1.00.relnotes > you used to (maybe still can) just dd it to a floppy disk # it does not quite say, but: > Uncompressed kernel images are back (yay!) - to get one, just simply do a "make Image" instead of "make zImage". If the uncompressed image is bigger than about 524kB then you will have to use compressed kernel images. (Uncompressed ones boot a *lot* faster on old 386's). Both LILO
<kof673>
and loadlin will happily boot an uncompressed image still. # and also: > The complete source for the kernel will fit on a single 1.44MB floppy. Compared to the current 11MB or so taken up by linux-2.1
<kof673>
> There is a new boot argument "swapdev=" which should only be needed for machines with less than 1.5MB of RAM. It allows enabling of swap just after the root filesystem is mounted and before init is launched.
gildasio has quit [Ping timeout: 260 seconds]
<kof673>
"lite" ..... the budget version maybe can boot from floppy :)
gildasio has joined #osdev
oldgalileo has quit [Ping timeout: 264 seconds]
oldgalileo has joined #osdev
<Mutabah>
Interesting that uncompressed is faster, usually IO is a lot slower than decompression
vdamewood has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
nikolapdp has quit [Ping timeout: 240 seconds]
srjek has quit [Ping timeout: 268 seconds]
Nixkernal_ has joined #osdev
gildasio has quit [Remote host closed the connection]
Nixkernal has quit [Ping timeout: 272 seconds]
gildasio has joined #osdev
ski has joined #osdev
<geist>
yeah but hard to imagine how much slower a 386 is than current stuff
<zid>
It's only true these days because of multicore nonsense, there was a time until *very* recently that everything with good IO needed raid cards
<zid>
just to do 'xor' in realtime
<zid>
now you just dedicate 4 cores to it and don't even feel it
<geist>
but it's also entirely possible due to size constraints that the decompressor in the older linux stuff was pretty unoptimized. size over speed, etc
<zid>
and unless it's a real 386, it's going to be a billion times faster to do i/o
<zid>
no more waiting 100ms for a seek if it's all under qemu on a real machine
<geist>
iirc a real 3.5" high density floppy does something like about 20KB/sec
<geist>
about a track, both sides (18k) a second
<geist>
click, click, click
<geist>
20-30KB or so, a little faster than one a second
<Mutabah>
:/ 300rpm, so you'd assume 5 tracks per second? unless the processing couldn't keep up
<geist>
yeah good question. that's about what i remember. i guess it takes at least one rotation to get back to it when it switches tracks, plus the seek time
<geist>
so that might be about right: take your 5 rots/sec, then chew up at least one rot when switching tracks, after chewing up some time to move the head
<geist>
now you may be down to 2ish, which is about what i was remembering
<geist>
and that's ideal
<geist>
what i dunno is if the sophistication of the track-at-a-time mode of the floppy controller (real chip or emulated in chipset) can handle reading sectors out of order and reassembling them
<geist>
but even if it does it out of order it would probably need to wait until it got sector 0 before it signals that it's ready
<geist>
i dunno what the interleave factor is for a 3.5" HD floppy either, is it 1:1?
<geist>
oh oh and, you can only read from one head at a time, so needs two full rotations to finish a track
<geist>
since the 34 pin connector only has oine read/write data line, and a head select
<geist>
so physically best time is 200ms per side, 400ms both sides for a single track, then some number of ms to seek and resynchronize, another 400ms
<geist>
assuming no processing time, transfer time, and no needing to wait for sector 0 to come around (reading them out of order and reassembling them later)
oldgalileo has quit [Ping timeout: 268 seconds]
oldgalileo has joined #osdev
oldgalileo has quit [Ping timeout: 260 seconds]
SophiaNya has quit [Remote host closed the connection]
ptrc has quit [Remote host closed the connection]
SophiaNya has joined #osdev
ptrc has joined #osdev
snowcra5h has quit [Quit: WeeChat 4.2.2]
goliath has joined #osdev
oldgalileo has joined #osdev
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
rustyy has quit [Quit: leaving]
<osdev199>
Hi, I'm getting the stack-segment fault with error code 0 for the instruction movzbl 0x0(%rbp),%eax. The rsp = 0x67a145c0 is in canonical form.
<Mutabah>
Is the SS regeister set correctly?
<geist>
but that's rbp, not rsp
<geist>
what's in rbp?
<geist>
also fun quirk of x86: references using rbp as a base pointer implicitly use SS:
<osdev199>
rbp = 0x69ca69ca69ca69c
<geist>
there's ya problem
rustyy has joined #osdev
vdamewood has joined #osdev
<osdev199>
geist: thanks.
<osdev199>
it's the environ (environment variable) thing. It is defined as a global variable in the Glibc source file posix/environ.c. Don't know why even with -static option in gcc, it didn't include this variable?
frumon has joined #osdev
frumon has quit [Client Quit]
frumon has joined #osdev
heat has quit [Quit: Client closed]
<vdamewood>
osdev199: Did you use the variable in your code?
osdev199 has quit [Read error: Connection reset by peer]
zetef has joined #osdev
frumon has quit [Quit: Bye bye ;)]
frumon has joined #osdev
gbowne1 has quit [Quit: Leaving]
osdev199 has joined #osdev
<osdev199>
vdamewood: no.
<osdev199>
it's being accessed in the __tunables_init function
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
gog has joined #osdev
<dostoyevsky2>
Still don't really understand the purpose of the initramfs ... but I guess it's difficult to mount a real disk without init/systemd being already loaded? And on *BSD they can fully mount inside the kernel directly? (hence no need for a initramfs?)
gildasio has quit [Write error: Connection reset by peer]
foudfou has quit [Read error: Connection reset by peer]
chiselfuse has quit [Remote host closed the connection]
gildasio has joined #osdev
chiselfuse has joined #osdev
foudfou has joined #osdev
<Mutabah>
Afaik, linix initramfs contains the various kernel modules needed to mount the actual root filesystem
stolen has joined #osdev
gog has quit [Quit: byee]
<Ermine>
you can make initrd-less system as well
zetef has quit [Ping timeout: 264 seconds]
<dostoyevsky2>
Reading in the linux channels lead me to believe there is a alpine linux distribution in the initramfs, so I guess it's more than just the modules.... also, why can one mount the rootfs via the kernel/modules but other filesystems can only be mounted via systemd?
osdev199 has quit [Remote host closed the connection]
<Ermine>
it's not in initramfs
<Ermine>
and systemd is not required to mount anything
osdev199 has joined #osdev
<nikolar>
One reason is that a lot of drivers are usually packaged as modules by the distros
<nikolar>
So you need to load them for hardware to work
<nikolar>
Therefore you need initramfs
<zid>
I just build ext4 support in and then I don't need an initramfs, too lazy :P
<nikolar>
Kek
<nikolar>
I'd assume that ext4 is usually not in a module
<nikolar>
But I'm not sure
osdev199 has quit [Remote host closed the connection]
<zid>
well *ideally* I think fs's should be in modules
<nikolar>
Though a lot of hardware drivers like you or wifi cards are in modules
<zid>
or honestly even userspace
<zid>
cus like, there are thousands of possible filesystems, migth as well have the modules for em
<Ermine>
pov: you're using microkernel
<nikolar>
zid userspace is probably not a bad idea if you don't particularly care about performance
<zid>
there's no reason why it *can't* be fast, it just isn't :P
<nikolar>
But I don't think fuse is up to snuff for that :)
<dostoyevsky2>
nikolar: I guess that would make sense that initramfs only contains kernel modules... and why BSD doesn't have a initramfs, because they rather compile fs support into the kernel, and I guess have less rootfs boot options
osdev199 has joined #osdev
<Ermine>
do they support encrypted rootfsen?
<zid>
Like, if you just exposed a block read and block write syscall, and let userspace do the buffering of directory entries and stuff, you'd probably end up maybe faster from not having to enter kernel on the hot cache cases
<dostoyevsky2>
Ermine: I know OpenBSD does support to boot from an encrypted rootfs... where you enter a password, maybe even yubikey support?
<nikolar>
zid: I wonder why fuse is not great (tm)
<zid>
I think mainly just because it has to do everything twice
<Ermine>
oh lol, did they implement password entry in kernel???
<nikolar>
Ermine doesn't Linux need password entry in the kernel too
<zid>
not if you have an initramfs
<zid>
you can just have that crap in there
<Ermine>
I think no?
<nikolar>
Eh I'm not sure
<Ermine>
you have initrd for that
<Ermine>
with cryptsetup and shit
<nikolar>
Guess so
<nikolar>
I should check what inits do for crypttab
<nikolar>
Oh yeah it's just running cryptsetup open
zetef has joined #osdev
osdev199 has quit [Remote host closed the connection]
<bslsk05>
github.com: src/sys/lib/libsa/softraid.c at master · openbsd/src · GitHub
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
<dostoyevsky2>
Also, no yubikey support it seems
<dostoyevsky2>
Each time I dive into the OpenBSD kernel code I love how straightforward everything is... I guess SMP support made things a bit more complicated though
foudfou has quit [Remote host closed the connection]
foudfou has joined #osdev
osdev199 has quit [Remote host closed the connection]
vdamewood has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
GeDaMo has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
<bslsk05>
www.nextplatform.com: The Cloud Outgrows Linux, And Sparks A New Operating System
<osdev199>
the __libc_start_main copies the value of __environ to the cpu register. I tried *my_environ = 0x0 which is defined as volatile uint64_t* my_environ = 0x4b1840 in my kernel's C file in order to override the further processing of environ but turns out the cpu register doesn't copy a 0x0.
<dostoyevsky2>
GeDaMo: The datastructures present in relational Databases should become first class citizens in programming languages imho... There isn't much of a point that thousand dbs on https://dbdb.io/ often roll their own data structures and transaction mechanisms
<bslsk05>
dbdb.io: Home - Database of Databases
<GeDaMo>
Yeah, I've thought about that too
<osdev199>
(contd) the later use test instruction should set the zero flag!
<dostoyevsky2>
GeDaMo: And then you have LINQ in C# which is quite nice but not really using a database engine, and it's pretty slow because of that I heard...
netbsduser has joined #osdev
<dostoyevsky2>
Stonebraker predicted that SciDB would be the key for neural network architectures, but I guess that didn't happen. ;-)
<GeDaMo>
I'm interested in array languages because they're only a few steps away from being databases
<osdev199>
(contd) to bypass its access and to get pass the trapped instruction in my hello_world userspace program.
<dostoyevsky2>
GeDaMo: The step from array languages to a database is quite huge, though... You need a query planner that finds the most efficient way to load a dataset into memory and then process it and then also transaction mechanisms, like MVCC... that's quite difficult stuff
<GeDaMo>
You might do without the query planner if you can specify the order things happen in
zetef has joined #osdev
<dostoyevsky2>
GeDaMo: I think that's what they initially did in Spark, so you had to refactor your code when the query was inefficent... But just looking at the plan and its timings and then just adding an index here and there feels a lot smoother
<mjg>
void
<mjg>
cifs_down_write(struct rw_semaphore *sem)
<mjg>
while (!down_write_trylock(sem))
<mjg>
{
<mjg>
msleep(10);
<mjg>
}
<mjg>
:d
<mjg>
i had not seen that abuse with a sleepable lock
<dostoyevsky2>
mjg: I feel cifs is the worst remote filesystem I ever tried to use
<dostoyevsky2>
it just randomly hangs for like 10-20s like every 10mins
<netbsduser>
i don't know a great deal about CIFS
<netbsduser>
NFS is called the gold standard in network filesystems
<mjg>
nfs is called network failure system for a reason
<mjg>
i doubt cifs is any better though
<dostoyevsky2>
My remote filesystem I based on nfs and it's smooth
<netbsduser>
i searched "cifs_down_write" and found what appears to be the gnu/linux kernel's code for dealing with these filesystems
<mjg>
GeDaMo: so is that where the unikernel people went?
<mjg>
nfs works until it does not
<netbsduser>
i don't understand the defiant code style: why is there `struct cifsLockInfo` and `struct TCP_Server_Info`? did the authors decide to try out every naming convention other than what is traditional and accepted in linux?
<mjg>
it's an implementation for a microsoft-originated protocol
<dostoyevsky2>
mjg: does cifs_down_write try to lock the remote filesystem?
<mjg>
i presume it was written by people with that background as well
<netbsduser>
but microsoft style is the loud `typedef struct _TCP_SERVER_INFO { } TCP_SERVER_INFO, *PTCP_SERVER_INFO, **PPTCP_SERVER_INFO;`
<dostoyevsky2>
mjg: I wonder if trying to get a remote lock might explain why cifs tends to hang intermittently
<mjg>
i have no idea how cifs works
<dostoyevsky2>
well, it's a windows remote filesystem... windows filesystems are known for things like: can't open that file for writing because some other process has a filehandle on this file... So I think CIFS probably does stuff like that too
osdev199 has quit [Read error: Connection reset by peer]
Left_Turn has joined #osdev
srjek has joined #osdev
osdev199 has joined #osdev
navi has joined #osdev
zetef has quit [Ping timeout: 268 seconds]
<Ermine>
p o s i x fs semantics
m257 has joined #osdev
mctpyt has quit [Remote host closed the connection]
mctpyt has joined #osdev
osdev199 has quit [Ping timeout: 268 seconds]
osdev199 has joined #osdev
FreeFull has quit [Ping timeout: 264 seconds]
FreeFull has joined #osdev
oldgalileo has quit [Ping timeout: 255 seconds]
<netbsduser>
dostoyevsky2: i don't think they are
<netbsduser>
otherwise WSL (v1 not v2) would have been impossible
oldgalileo has joined #osdev
m257 has quit [Ping timeout: 250 seconds]
<dostoyevsky2>
netbsduser: I haven't tried writing to a file from WSLv1, only reading them... It's quite rare that you actually want to write to a file that an Windows Application is currently using from WSL, so not sure what you mean by impossible
<dostoyevsky2>
(writing to a non-linux file)
oldgalileo has quit [Ping timeout: 268 seconds]
<netbsduser>
dostoyevsky2: i mean that if it locked out opening for writing because someone else had it open at all, then it would not be even remotely a subsystem for linux applications
<netbsduser>
it would be deviant to an unacceptable degree
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
<dostoyevsky2>
netbsduser: WSLv1 uses normal linux filesystems for the linux part, so there is no locking, only when you want to access stuff from /mnt/c or the like
<azonenberg>
Most of my projects these days don't use a full filesystem because it's overkill for the kinds of bare metal work I do
<azonenberg>
So i created a key-value store that just maps a flat namespace of byte-string names (printable by convention but the code treats them as opaque byte[] identifiers) to arbitrarily sized data objects
<azonenberg>
It's a log-structured architecture based on two flash erase blocks (can scale to >2 but the minimum is 2) in which one block is inactive and one is active
<azonenberg>
to read an object you walk the log until you find the most recent header of the key you're looking for, then it returns a pointer to the (memory mapped) flash object
<nikolapdp>
so a linear search?
<azonenberg>
to write, you just stuff the data in the next unused spot in flash then write a block header to the metadata region that specifies the key, start address and length for the data blob, and CRC32
<azonenberg>
Yeah. this is meant for storing tiny amounts of configuration data and normally you only read the KVS once at boot and then the data is copied to in-memory data structures
<azonenberg>
So the overhead of any kind of more complex tree etc seemed pointless
<azonenberg>
the idea here is the smallest possible design in terms of code and flash space
<azonenberg>
the entire KVS fits in two flash erase blocks and just writes to empty space until it runs out
<azonenberg>
then does a "compact" operation, copying the latest version of each object to the second bank, writing a header saying the new bank is current, and erasing the old one
<azonenberg>
(For reference, this is meant to be usable on e.g. a cortex-m0 with 32 kB of total flash that has to fit both config data and application code in it)
<azonenberg>
anyway so i ran into some bugs recently related to flash that has larger than 32 byte write blocks due to hardware ECC
<azonenberg>
And i threw this board together to create a "power failure fuzzer" in order to validate atomicity of operations in real world fault situations
<azonenberg>
the left MCU controls reset and power enable to the right, which is running the filesystem and a test application that basically just reads and writes simulated config data in a loop
<azonenberg>
while being constantly rebooted at random intervals
<azonenberg>
the goal is to ensure that i never corrupt data and that all writes atomically succeed or fail
zetef has joined #osdev
<azonenberg>
in other words, if you abort midway through a write it should cleanly roll back to the most recent fully-written copy of the object, and the next write should ignore the corrupted object and write to the free space in flash after it
<azonenberg>
and you should never corrupt previously written objects or the superblock header or read any data other than the most recent or second most recent version of the object
<nikolapdp>
the whole compactification is basically how one of the first GCs worked kek
<azonenberg>
Yeah it's not architecturally new in any way
<azonenberg>
the point is more that e.g. littlefs and other stuff is still way too big for this use case
<azonenberg>
where one object might be say a single IP address or a boolean "is DHCP client enabled" flag
<azonenberg>
and i need to fit several dozen of these config settings into a couple kB of flash
<azonenberg>
To provide additional variety, the test board has both on-die flash on the microcontroller and an external SPI flash
<azonenberg>
so i can stress test both drivers and see if they have different failure modes
<azonenberg>
Really the whole design goal of microkvs was "what is the smallest, simplest persistent data store i can create that avoids data loss on power failure and provides some way to read and write named blobs of binary data?"
osdev199 has quit [Remote host closed the connection]
FreeFull has quit []
stolen has quit [Quit: Connection closed for inactivity]
osdev199 has joined #osdev
m257 has quit [Ping timeout: 250 seconds]
heat has joined #osdev
<heat>
mjg, it's missing some exponential backoff but apart from that LGTM Reviewed-by: heat
<nikolapdp>
what's that all about
<osdev199>
heat: nvme driver update: I had a bug in getting the nvme base address. After fixing that, it is working on qemu. The original bug regarding the admin command not being processed is not there. But it is still not working on my real machine!
<osdev199>
I would call that a progress, aah!
<heat>
sweet :)
<osdev199>
thanks to people who helped me and finally the one osdev on reddit :)
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
osdev199 has quit [Remote host closed the connection]
osdev199 has joined #osdev
stolen has joined #osdev
nikolapdp has quit [Ping timeout: 264 seconds]
xenos1984 has quit [Ping timeout: 260 seconds]
osdev199 has quit [Remote host closed the connection]
osdev199 has quit [Remote host closed the connection]
xal has quit []
xal has joined #osdev
Arthuria has joined #osdev
zxrom has joined #osdev
Arthuria has quit [Killed (NickServ (GHOST command used by Guest684531))]
Arthuria has joined #osdev
m257 has joined #osdev
xenos1984 has quit [Ping timeout: 268 seconds]
gog has joined #osdev
zetef has quit [Ping timeout: 268 seconds]
<gog>
so i'm fully C# wormbrained and i'm looking at some code for using it with EFI and they use OutputString to implment single-character writes and ugh. that path is painfully slow
<gog>
but native AOT is pretty cool
zetef has joined #osdev
<mjg>
i watched a youtube video where some dude was disparaging perf optimization, the usual way
<mjg>
i'm pretty sure in that video the guy defeated his own point
<gog>
what's the usual way people disparage perf optimization?
<mjg>
root of all evil (if "premature")
<mjg>
it goes like this
<mjg>
fuckign webtard code something utterly bad
<mjg>
any attempt at damage-controlling that or bringing into sanity land is met with "lol premature optimization"
<heat>
they have a point
<mjg>
no
<heat>
brb branch annotating all of my java branchen
<heat>
that unlikely will totes make a difference!!
<mjg>
for example they select * from lultable; and then filter in the app
<mjg>
you try to tell the fucker to use the where clause instead
<mjg>
"lol worked fast here, we can change that if it turns out to be a problem. premature optimizatin is the root of all evil"
<heat>
they still have a point
<heat>
if your table has like 4 entries in them
<heat>
ggez
* mjg
gives up on heat
<mjg>
what do you think gog
<heat>
am i wrong?
<heat>
select * from ligma won't be slow if you have an almost empty table
<gog>
idk why you wouldn't use the where clause in the query
<mjg>
^^^^
<mjg>
's literally n oreason to deviate from the sensible form
<gog>
we use EF Core which exposes a query interface that does all that jazz for you
<mjg>
and the code, if actually used, is bound to need to that change later
<heat>
i have a crap degree of sql competency that doesn't let me do all sorts of insanely complex queries
<heat>
a trivial WHERE is trivial, other non trivial stuff... not easy
<mjg>
adding a where clause to a simple slect is not some rocket science
<gog>
if your ORM doesn't suck it builds in the ability to do that as a predicate anyway
<gog>
abstracted away
<mjg>
i heard ORMs are webdev
<gog>
not entirely
<gog>
but mostly
<mjg>
i'm like a 10k SO rep wanker at databases, so can't argue much here
<gog>
i've learned to write pretty complicated queries
<gog>
but i don't really understand much
<mjg>
ye but do they kill the db
<mjg>
all the difficulty is making things not suck
<heat>
orms are cool
<gog>
we've prettymuch ironed out all the hot paths that have a habit of slowness with proper indexes
<gog>
but that's the former CTO who consults, he's the data engineer
<mjg>
no multiway joins?
<mjg>
or are you pretending the sql is a kv store
<mjg>
i don't know whats the fad today
<mjg>
last time i was remotely involved with dbs people were grifting hard on nosql
<gog>
we have dynamodb for our kv store
<gog>
but our business objects are in sql
<gog>
rdb
<heat>
mongodb webskell
<gog>
we do some multiway joins but they're hidden in SP's that use temporary table-valued objects
<mjg>
is there a db with fearless queries
<gog>
we should be using views more
osdev199 has joined #osdev
<gog>
idk i'm afraid of databases in general
<heat>
good
<osdev199>
Hi, my NVMe driver code for the creation of I/O completion queue is working on qemu but not on the physical system. The admin completion queue is not being written by the controller after submitting the creation entry. Possible causes?
<heat>
your caching may be hosed, your init code may be wrong
<heat>
your pci driver may not be fully enabled
<heat>
there's a plethora of status registers you can look at
<heat>
s/driver/device/
zetef has quit [Remote host closed the connection]
<osdev199>
Thanks. That's a valuable advice.
osdev199 has quit [Remote host closed the connection]
<bslsk05>
scp-wiki.wikidot.com: SCP-8601 - SCP Foundation
<sortie>
(me)
<heat>
The 05 council hereby mandates the immediate worldwide discontinuance of computer systems with 32-bit timekeeping, the use of full length years (not merely 2 or 4 digits), and the upgrade of all protocols and file formats to versions with 64-bit timestamps without overflow issues within the expected lifetime of the universe
<heat>
thank you 05 council
osdev199 has joined #osdev
FreeFull has joined #osdev
<osdev199>
heat: what do you mean by pci driver may not be fully enabled?
<nikolar>
heh good one sortie
<heat>
i meant device
<sortie>
nikolar: Don't forget to upvote and subscribe
<heat>
there are a handful of bits in the pci config space controlling memory accesses, interrupts, busmastering for the device. plus it may not even be in D0, but that's a separate problem
<heat>
(and unlikely)
<osdev199>
ok. thanks.
nikolapdp has joined #osdev
Left_Turn has quit [Remote host closed the connection]
Left_Turn has joined #osdev
Left_Turn has quit [Remote host closed the connection]
<heat>
gog i dont have money but i have hugs to give
<heat>
if you need one
<gog>
yes pls
* heat
hugs gog
* gog
hug
<heat>
gog, those ORM entities
<heat>
are they per-thread or something?
<gog>
EF Core has a context that encapsulates a unit of work which is per request
<gog>
a request can spawn many threads
<heat>
ah per request yes, that makes sense
<gog>
you can spin up a new context if you wish
<heat>
i imagine there's another level of caching between the entity and the DB?
<gog>
but in our workflow if you're doing that you might as well have a worker service and dispatch to it
<gog>
the context maintains a cache of entities is tracking
<gog>
and changes are only saved to the RDB if you call context.SaveChanges{,Async}
<gog>
so it also has an implicit transaction
<zid>
I REMEMBERED
<zid>
It was an fascinating girls via cheese meme
<heat>
gog, JPA has this weird behavior where repository.save(entity) can change the entity
<heat>
so the correct usage is entity = repository.save(entity)
<heat>
its weird
<gog>
EFCore also has this construct
<gog>
context.Save<>() or DbSet<>.Save()
<gog>
where <> denotes a generic
<gog>
you can use it synchronously in this manner
<gog>
and we do for some things
<heat>
yeah
<heat>
fun stuff
<gog>
we also have a bunch of other caches
<gog>
we have redis for caching hot request paths, elasticsearch also serves as a cache for a couple of our subsystems, we have a thumbnail cache for our image cdn
<gog>
which iirc is just nginx reverse proxy
<heat>
i wanted to see if i could find a rust ORM so i could fuck around with it some more
<heat>
and i found something but not really
FreeFull has quit [Ping timeout: 256 seconds]
<zid>
found it
<gog>
i guess our dynamodb is a sort of cache for our inventory services, which generally have to call their native API at most points during customer interaction and i kindof hate the system and wish we'd go with a live integration
<gog>
the inventory services are a constant annoyance
<gog>
over the last few weeks i got us some speedups in inventory checks and hot request paths in our sales portal and idk if it's jsut me but it feels waaaay faster now
<gog>
i did some benchmarks and i can demonstrate that it's a little faster
<gog>
but the perception of how much faster seems disproportionate
<heat>
OPTIMAL
<heat>
my java thingy i talked with you about is /really/ slow
<heat>
and i don't know why
<heat>
even with postgres at localhost
<heat>
it also likes firing off huge ass queries
<gog>
idk about java or postgres
<gog>
maybe you should use c# and asp.net core
<heat>
i dont know C#
<gog>
it's like c++ but better
<heat>
they teach us java around here, it's awful
<gog>
if you can speak c++ you can speak c#
<heat>
that's not true
<heat>
i vaguely understand C# as much as i vaguely understand every C-like language
<gog>
that's all any of us can aspire to
<gog>
vague understanding
<heat>
vague understanding is based
oldgalileo has joined #osdev
<heat>
deep understanding is beta soyboy
<gog>
yes
frumon has quit [Ping timeout: 268 seconds]
<mcrod>
hello gog
<mcrod>
may I hug you
<gog>
yes
* mcrod
hug gog
* gog
hug mcrod
voidah has quit [Remote host closed the connection]
voidah has joined #osdev
<mjg>
dude i literally copy paste all my patchen from SO
<mjg>
i'm old school
heat has quit [Remote host closed the connection]
<gog>
nice
rustyy has quit [Ping timeout: 268 seconds]
rustyy has joined #osdev
* Ermine
gives a piece of cheese to gog
xenos1984 has quit [Read error: Connection reset by peer]
<Ermine>
I've found a wiki on US emergency alert system for some reason