7 ms·
The road to Zettalinux
- PaulHoule 4y agoOn one hand The IBM System/38 used 128 bit pointers in the 1970s, despite having a 48 bit physical address bus. These were used to manage persistent objects on disk or network with unique ids a lot like uuids. On the other hand, filling out a 64 bit address space looks tough. I struggled to find something of the same magnitude of 2^64 and I got ‘number of iron atoms in an iron filing’, From a nanotechnological point of view a memory bank that size is feasible (fits in a rack at 10,000 atoms per bit) but progress in semiconductors is slowing down. Features are still getting smaller but they aren’t getting cheaper anymore.
- mhh__ 4y agoIBM i is still in development and also has a 128 bit pointer.
- protomyth 4y agoThe AS/400 and iSeries also use 128-bit pointers. 128-bit would be useful for multiple pointers already in common use such as ZFS and IP6 addresses. I expect it will the last hop for a long time.
- EvanAnderson 4y agoIn the context of the AS/400's single-level store architecture the 128-bit pointers make a lot of sense, too.
- skissane 4y agoOnly 64 of those 128 bits are the actual address. The first byte indicates the type of object the pointer points to. The next seven bytes are (for some pointer types) used to encode security permissions (capabilities); for other types they are just reserved (all zeroes). So taking up 128 bits is more about capability-based security and type safety than the single-level store per se; the single-level store would have worked about as well with only 64-bit pointers. There is also a 129th bit (tag bit) which helps detect unsafe pointer modification. (The tag bit is stored using ECC memory’s extra bits for storing the error correction, which happen to have one spare bit per every 16 bytes.) Conceptually similar to ARM Morello/CHERI’s 129 bit pointers; although that is a much more sophisticated implementation than IBM 38/400/i.
- PaulHoule 4y agoThose are evolved from the System/38.
- protomyth 4y agoYeah, IBM is one company that shows how to push the models down the road. They do take their legacy seriously.
- deleted 4y ago[deleted]
- lloeki 4y ago> filling out a 64 bit address space looks tough. I struggled to find something of the same magnitude of 2^64 and I got ‘number of iron atoms in an iron filing’ Reminded me of Jeff Bonwick's answer to the following question about his 'boiling the oceans' quip related to ZFS being a "128 bit filesystem": > 64 bits would have been plenty ... but then you can't talk out of your ass about boiling oceans then, can you? Sadly his Sun hosted blog was eaten by the migration to Oracle, so thanks to the Internet Archive again: http://web.archive.org/web/20061111054630/http://blogs.sun.com/bonwick/date/20040925 http://web.archive.org/web/20061111054630/http://blogs.sun.c... That one dives into some of the "handwaving" a bit: https://hbfs.wordpress.com/2009/02/10/to-boil-the-oceans/ https://hbfs.wordpress.com/2009/02/10/to-boil-the-oceans/ And that one goes into how much energy it would take to merely spin enough disks up: https://www.reddit.com/r/DataHoarder/comments/71p8x4/reaching_the_limit_from_zfs/ https://www.reddit.com/r/DataHoarder/comments/71p8x4/reachin...
- PaulHoule 4y agoOne absolute limit of computation is that it takes (1/2) kT of energy to delete one bit of information where k is the Boltzmann constant and T is the temperature. Let T = 300° K (room temperature) I multiplied that by 2¹²⁸, and got 1.41×10¹⁸ J of energy. 1 ton of TNT is 4.2×10¹² J, so that is a 335 kiloton explosion worth of energy just to boot. That's not impossible, that much heat is extracted from a nuclear reactor in a few months. If you want to go faster you need a bigger system, but a bigger system will be slower because of light speed latency. (You do better, however, at a lower temperature, say 1° K but heat extraction gets more difficult at lower temperatures and you spend energy on refrigeration unless you wait long enough for the Universe to grow colder.)
- turtletontine 4y agoIn fairness, the need for 128-bit addressable systems will be when 64 address bits is not enough. That will be long before people are using 2^128 bytes on one system. So doing the calculation with 2^65 bytes would be a more even handed estimate of the machine that would require this
- 4y ago
- bdn_ 4y agoI thought up a few ways to visualize 2^64 unique items: - You could give every ant on Earth ~920 unique IDs without any collisions - You could give unique IDs for every brain neuron for all ~215 million people in Brazil - The ocean contains about 20 × (2^64) gallons of water (3.5267 × 10^20 gallons total) - There are between 100-400 billion stars in the Milky Way, so you could assign each star between 46,000,000–184,000,000 unique IDs each - You could assign ~2.5 unique IDs to each grain of sand on Earth - If every cell of your body contained a city with 500,000 people each, every "citizen" of your body could have a unique ID without any collisions Calculating these figures is actually a lot of fun!
- Eduard 4y agoThere are only ~368 grains of sand per ant?
- ManuelKiessling 4y agoNo wonder I keep reading about sand shortages.
- fragmede 4y agoWell no. See there's this one ant, Jeff, that's hogging them all for itself, so each ant only gets 50 grains grains of sand.
- jwilk 4y agoThe common claim that there are ~7.5E18 (~2.5 × 2⁶⁴) grains of sand seems to originate from this back-of-the-envelope calculation: https://web.archive.org/web/19990117001023/http://www2.hawaii.edu/suremath/jsand.html https://web.archive.org/web/19990117001023/http://www2.hawai... It takes only beach sand into account, and of course there's a lot of guessing involved. It could be easily off by many orders of magnitude.
- tonnydourado 4y agoThose are great examples
- tuatoru 4y ago> On one hand The IBM System/38 used 128 bit pointers in the 1970s, despite having a 48 bit physical address bus. And the original processor was 24 bits, then it was upgraded to 36 bits (not a typo: 36 bits), and then to POWER 64 bits. (When that last happened, it was re-badged AS/400. Later, marketing renamed the AS/400 to iSeries, and then to IBM i, without changing anything significant. Still uses Power CPUs, AFAIK). For users, upgrades were a slightly longer than usual backup and restore. What's the hard part here?
- Blikkentrekker 4y ago> How would this look in the kernel? Wilcox had originally thought that, on a 128-bit system, an int should be 32 bits, long would be 64 bits, and both long long and pointer types would be 128 bits. But that runs afoul of deeply rooted assumptions in the kernel that long has the same size as the CPU's registers, and that long can also hold a pointer value. The conclusion is that long must be a 128-bit type. Can anyone explain the rationale for not simply naming types after their size? In many programming languages, rather than this arcane terminology, “i16”, “i32”, “i64”, and “i128” simpy exist.
- m0RRSIYB0Zq8MgL 4y agoThat is what was suggested in the next paragraph. > But a better solution might just be to switch to Rust types, where i32 is a 32-bit, signed integer, while u128 would be unsigned and 128 bits. This convention is close to what the kernel uses already internally, though a switch from "s" to "i" for signed types would be necessary. Rust has all the types we need, he said, it would be best to just switch to them.
- deleted 4y ago[deleted]
- masklinn 4y agoLegacy, there’s lots of dumb stuff in C. As you note, in modern languages the rule is generally to have fixed-size integers. Though I think there are portability issues concerns, that world is mostly gone (it remains in some corners of computing e.g. dsps) but if you’re only using fixed-size integers what do you do when a platform doesn’t have that size? With a more flexible scheme, you have less issues there, however as the weirdness landscape contracts the risk of making technically incorrect assumptions (about relations between type sizes, or the actual limits and behaviour of a given type) start increasing dramatically. Finally there’s the issue at hand here: even with fixed-size integers, “pointer” is a variable-size datum. So you still need a variable-size integer to go with it. C historically lacking that (nowadays it’s called uintptr_t), the kernel made assumptions which are incorrect. Note that you can still get it wrong even if you try e.g. Rust believes and generally assumes that usize and pointers correspond, but that gets iffy with concepts like pointer provenance, which decouple pointer size and address space.
- LinkLink 4y agoFor reference 2^64 = ~10^19.266 I don't think this is unreasonable at all, its unlikely that computers will largely stay the same in the coming years. I believe we'll see many changes to how things like mass addressing of data and computing resources is done. Right now our limitations in these regards are addressed by distributed computing and databases, but in a hyper-connected world there may come a time when such huge address space could actually be used. It's an unlikely hypothetical but imagine if fiber ran everywhere, and all computers seamlessly worked together sharing computer power as needed. Even 256 bits wouldn't be out of the question then. And before you say something like that will never happen consider trying to convince somebody from 2009 that in 13 years people would be buying internet money backed by nothing.
- est31 4y agoThe extra bits might be used for different things like e.g. in CHERI. The address space is still 64 bits, but there are 64 bits in metadata added to it, so you get a 128 bit architecture.
- Tsarbomb 4y agoNot agreeing or disagreeing for the most part, but in 2009 all of the prerequisite technology for cryptocurrency existed: general purpose computers for the average person, accessible internet, cryptographic algorithms and methods, and cheap storage. For 256 bit computers, we need entirely new CPU architectures and updated ISAs for not just x86/AMD64, but for other archs increasing in popularity such as ARM and even RISC-V. Even then compilers, build tools, and dependant devices with their drivers need updates too. On top of all of this technical work, you have the political work of getting people to agree on new standards and methods.
- mhh__ 4y ago256 bits in the case of a worldwide mega-computer would be such a huge departure from current architectures and more importantly latency-numbers that we can barely even speculate about it. It may be of note that hypothetically one can have a soft-ISA 128 bit virtual address (a particularly virtual virtual address) which is JITed down into a narrower physical address by the operating system. This is as far as I'm aware how IBM i works.
- teddyh 4y agoMaybe we can finally fix maxint_t to be the largest integer type again.
- wongarsu 4y agoWhat's the average lifespan of a line of kernel code? I imagine by starting this project 12 years before its anticipated use case they can get very far just by requiring that any new code is 128-bit compatible (in addition to doing the broader infrastructure changes needed like fixing the syscall ABI)
- trasz 4y agoNot sure about those 12 years - 128-bit registers are already there, and CHERI Morello prototype is at a “physical silicon using this functionality under CheriBSD” stage.
- rwmj 4y ago> What's the average lifespan of a line of kernel code? There's a fun tool called "Git of Theseus" which can answer this question! You can see some graphs of Linux code on the web page: https://github.com/erikbern/git-of-theseus https://github.com/erikbern/git-of-theseus Named after the Ship of Theseus: https://en.wikipedia.org/wiki/Ship_of_Theseus https://en.wikipedia.org/wiki/Ship_of_Theseus
- forgotpwd16 4y agoThere're some more in the presentation article: https://erikbern.com/2016/12/05/the-half-life-of-code.html#:~:text=the%20monster%20repo%20of%20them%20all https://erikbern.com/2016/12/05/the-half-life-of-code.html#:... A (Linux) kernel line has half-life 6.6 years. The highest of the projects analyzed. The lowest went to Angular with half-life 0.32 years.
- jmillikin 4y agoThe section about 128-bit pointers being necessary for expanded memory sizes is unconvincing -- 64 bits provides 16 EiB (16 x 1024 x 1024 x 1024 x 1 GiB), which is the sort of address space you might need for byte-level addressing of a warehouse full of high-density HDDs. Memory sizes don't grow like they used to, and it's difficult to imagine what kind of new physics would let someone fit that many bytes into a machine that's practical to control with a single Linux kernel instance. CHERI is a much more interesting case, because it expands the definition of what a "pointer" is. Most low-level programmers think of pointers as just an address, but CHERI turns it into a sort of tuple of (address, bounds, permissions) -- every pointer is bounds-checked. The CHERI folks did some cleverness to pack that all into 128 bits, and I believe their demo platform uses 128-bit registers. The article also touches on the UNIX-y assumption that `long` is pointer-sized. This is well known (and well hated) by anyone that has to port software from UNIX to Windows, where `long` and `int` are the same size, and `long long` is pointer-sized. I'm firmly in the camp of using fixed-size integers but the Linux kernel uses `long` all over the place, and unless they plan to do a mass migration to `intptr_t` it's difficult to imagine a solution that would let the same C code support 32-, 64-, and 128-bit platforms. (comedy option: 32-bit int, 128-bit long, and 64-bit `unsigned middle`) The article also mentions Rust types as helpful, but Rust has its own problems with big pointers because they inadvisably merged `size_t`, `ptrdiff_t`, and `intptr_t` into the same type. They're working on adding equivalent symbols to the FFI module[0], but untangling `usize` might not be possible at this point. [0] https://github.com/rust-lang/rust/issues/88345 https://github.com/rust-lang/rust/issues/88345
- mhh__ 4y agoSystems for which pointers are not just integers have come and gone, sadly. Many mainframes had function pointers which were more like a struct than a pointer.
- masklinn 4y agoTechnically that’s still pretty common on the software side, that’s what tagged pointers are. The ObjC/Swift runtime uses that for instance, the class pointer of an object also contains the refcount and a few flags.
- rmorey 4y agothis seems just a bit too early - so that probably means it’s exactly the right time!
- marktangotango 4y agoI was wondering if this (128bit memory) are on the radar of any of the BSDs. Will they forever be stuck at 64bit?
- fanf2 4y agoCheriBSD might be the first unix-like with 128 bit pointers
- tayistay 4y agoIs 128 bit the limit of what we would need? We use 128 bit UUIDs. 2^256 seems to be more than the number of atoms on Earth.
- wongarsu 4y agoThe article does talk about just making the pointer type used in syscalls 256 bit wide to "give room for any surprising future needs". The size of large networked disk arrays will grow beyond 64 bit addresses, but I don't think we will exceed 2^128 bits of storage of any size, for any practical application. Then again, there's probably people who thought the same about 32 bit addresses when we moved from 16bit to 32bit addresses. The most likely case for "giant" pointers (more than 128 bits) will be adding more metadata into the pointer. With time we might find enough use cases that are worth it to go to 256bit pointers, with 96bit address and 160 bit metadata or something like that.
- dylan604 4y ago>Then again, there's probably people who thought the same about 32 bit addresses when we moved from 16bit to 32bit addresses. There's a fun "quote" about 384k being all anyone would ever need, so clearly everyone just needs to settle down and figure out how to refactor their code.
- shadowofneptune 4y agoThe IBM PC's 20-bit addressing was 16 times the size of 16-bit addresses. From 20-bit to 32-bit, 4096 times larger. 32 to 64 is 4,294,967,296 times larger (!). The scale alone makes using all this space unlikely on a PC.
- gwbas1c 4y ago> Matthew Wilcox took the stage to make the point that 64 bits may turn out to be too few — and sooner than we think Let's think critically for a moment. I grew up in the 1980s and 1990s, when we all craved more and more powerful computers. I even remember the years when each generation of video games was marketed as 8-bit, 16-bit, 32-bit, ect. BUT: We're hitting a point where, for what we use computers for, they're powerful enough. I don't think I'll ever need to carry a 128-bit phone in my pocket, nor do I think I'll need a 128-bit web browser, nor do I think I'll need a 128-bit web server. (See other posts about how 64-bits can address massive amounts of memory.) Will we need 128-bit computing? I'm sure someone will find a need. But let's not assume they'll need an operating system designed in the 1990s for use cases that we can't imagine today.
- wongarsu 4y agoWe are talking about the OS kernel that supports 4096 CPU cores. The companies who pay their engineers to do linux kernel development tend to be the same ones that have absurd needs.
- p_l 4y agoAnd that's not enough to boot on some platforms that linux runs on (even with amd64 ISA) unless one partitions the computer into smaller cpu counts
- uluyol 4y agoSupercomputers? Rack-scale computing? See some of the work being done with RDMA and "far memory".
- gwbas1c 4y agoYes... And do you need that in the same kernel that goes into your phone and your web server?
- mikepurvis 4y agoIMO there's an important distinction to be made between high-bit addressing and high-bit computing. Like, no one has enough memory to need more than 64 bits for addressing, and that is likely to remain the case for the foreseeable future. However, 128- and 256-bit values are commonly used in domains like graphics, audio, and so-on, where you need to apply long chains of transformations and filters, but retain as much of the underlying dynamic range as possible.
- zasdffaa 4y agoSounds nuts. Does anyone know how much power a 32GB DIMM draws? How much would a fully populated 64-bit address space therefore pull? Edit, if a 4GB (32-bits used) DRAMM pulls 1 watt, the rest of the memory space is 32 bit = 4E9 so your memory is pulling ~4Gwatts alone. That's not supportable, given the other electronics needed to go around it.
- munro 4y agoThere was a post awhile back from NASA saying how many digits of Pi they actually need [1]. import math pi = 3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360 sign_bits = 1 sig_bits = math.ceil(math.log2(pi)) exp_bits = math.floor(math.log2(sig_bits)) assert sign_bits + sig_bits + exp_bits == 1209 I'm sure I got something wrong here, def off-by-one, but roughly it looks like it would need 1209-bit floats (2048-bit rounded up!). IDK, mildly interesting. :> [1] https://www.jpl.nasa.gov/edu/news/2016/3/16/how-many-decimals-of-pi-do-we-really-need/ https://www.jpl.nasa.gov/edu/news/2016/3/16/how-many-decimal...
- vanderZwan 4y agoThe value of Pi you mention was the one in the question, the one in the answer is: > For JPL's highest accuracy calculations, which are for interplanetary navigation, we use 3.141592653589793. Let's look at this a little more closely to understand why we don't use more decimal places. I think we can even see that there are no physically realistic calculations scientists ever perform for which it is necessary to include nearly as many decimal points as you present. That's sixteen digits, so a quick trip to the dev tools tels me:: >> Math.log2(3141592653589793) -> 51.480417552782754 The last statement of the text I quoted is more interesting though. Although not surprising to me, given how many astronomers I know who joke that Pi equals three all the time.
- munro 4y agoLol I should RTFA ;D
- vanderZwan 4y agoNah, just claim you were invoking Cunningham's Law ;)
- 4y ago
- bitwize 4y agoPointers will get fat (CHERI and other tagged pointer schemes) well before even server users will need to byte-address into more than 2^64 bytes' worth of stuff. So we should probably be realistically aiming for 256-bit architectures...
- t-3 4y agoAre there operations that vector processors are inherently worse at or much harder to program for? Nowadays they seem to be mainly used for specialized tasks like graphics and machine learning accelerators, but given the expansion of SIMD instruction sets, are general purpose vector CPUs in the pipeline anywhere?
- Beltiras 4y agoI would think by now any bunch of clever people would be trying to fix the generalized problem of supporting n-bit memory addressing instead of continually solving the single problem of "how do we go from n*2 to (n+1)*2". I guess it's more practical to just let the next generation of kernel maintainers go through all of this hullabaloo again in 2090.
- PaulDavisThe1st 4y agoI remember a quote from the papers about Opal, an experimental OS that was intended to use h/w protection rather than virtual memory, so that all processes share the same address space and can just exchange pointers to share data. "A 64 bit memory space is large enough that if a process allocated 1MB every second, it could continue doing this until significantly past the expected lifetime of the sun before it ran into problems"
- jaimehrubiks 4y ago
- dredmorbius 4y agoAs long as the posting of subscriber links in places like this is occasional, I believe it serves as good marketing for LWN - indeed, every now and then, I even do it myself. We just hope that people realize that we run nine feature articles every week, all of which are instantly accessible to LWN subscribers. -- Jonathan Corbet, LWN founder & and grumpy editor in chief <https://news.ycombinator.com/item?id=1966033 https://news.ycombinator.com/item?id=1966033> Multiple other approvals: <https://hn.algolia.com/?dateRange=all&page=0&prefix=false&query=by%3Acorbet%20links&sort=byPopularity&type=comment https://hn.algolia.com/?dateRange=all&page=0&prefix=false&qu...> Jon's own submissions: <https://news.ycombinator.com/submitted?id=corbet https://news.ycombinator.com/submitted?id=corbet> And if we look for SubscriberLink submissions with significant (>20 comments) discussion ... they're showing up every few weeks, largely as Jon had requested. <https://hn.algolia.com/?dateRange=all&page=0&prefix=true&query=lwn.net%2FSubscriberLink%2F%20comments%3E20&sort=byDate&type=story https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que...> That said, those who are able to comfortably subscribe and find this information useful: please do support the site through subscriptions.
- nequo 4y agoWhether the posting of subscriber links is “occasional” as of late is debatable.[1] Most of LWN’s paywalled content is posted on HN. [1] https://news.ycombinator.com/item?id=32926853 https://news.ycombinator.com/item?id=32926853
- dredmorbius 4y agojaimehrubiks stated unequivocally without substantiation that "Somebody asked before to please not share lwn's SubscriberLinks". LWN's founder & editor has repeatedly stated otherwise, hasn't criticised the practice, and participates in the practice himself, as recently as three months ago. SubscriberLinks are tracked by the LWN account sharing them. Abuse can be managed through LWN directly should that become an issue. Whether or not that's occurred in the past I've no idea, but the capability still exists and is permitted. No link substantiating jamiehrubiks' assertion seems to have been supplied yet. I'm going to take Corbet's authority on this.
- t3estabc 4y ago
- wdutch 4y agoHi GPT3, I didn't expect to see you here.
- Majestic121 4y agoWhy are you posting GPT3 responses here?
- krackout 4y agoI think the article is very shortsighted. By 2035-40 we'll probably have memory only (RAM) computers massively available. No disks means no current OS capable of handling these computers. A change of paradigm needing new platforms and OSes. These future OSes may be 128bit, but I don't think the current ones will make it to the transition.
- alpb 4y agoThere are plenty of OSes today capable of booting and running from RAM. Pretty sure we wouldn't be burning all the prominent OSes for something like that.
- krackout 4y agoForget the concept of booting. Boot transfers the kernel OS from disk to RAM. No such thing would be needed on a RAM memory only computer.
- Aqueous 4y agoIf we're going to go for 128- why not just go for 256-? that way we won't have to do this again for a while. or better yet, design a new abstraction for not having to hard-code the limit of the pointer size but instead allow it to be extensible as more addressable space becomes a reality, instead of having to transition over and over. is this even possible? if it is, shouldn't we head in that direction?
- kmeisthax 4y agoThe problem with variable-sized pointers is that... 1. Any abstraction you could make will have worse performance than a fixed-size machine pointer 2. In order to support any kind of variably-sized type you need machine pointers to begin with, and those will always be fixed-size because variable size is even harder to support in hardware than native code And furthermore going straight to 256 has its own problems. Each time you double the pointer size you also significantly increase the size of structures with a lot of pointers. V8 notably uses "pointer compression" - i.e. using 32-bit offsets instead of 64-bit pointers, because it never needs >4GB of JavaScript objects at once and JS objects are very pointer-ridden. There's two forces at play here: pointers need to be small enough to embed in any data structure and large enough to address the entire working set of the program. Larger pointers are not inherently better[0], and neither are smaller pointers. It's a balancing act. [0] ASLR, PAC, and CHERI are exceptions, as mentioned in the original article.
- MikeHalcrow 4y agoI recall sitting in a packed room with over a hundred devs at the 2004 Ottawa Linux Symposium while the topic of the number of filesystem bits was being discussed (link: https://www.linux.com/news/ottawa-linux-symposium-day-2/ https://www.linux.com/news/ottawa-linux-symposium-day-2/). I recall people throwing out questions as to why we weren't just jumping to 128 or 256 bits, and at one point someone blurted out something about 1024 bits. Someone then made a comment about the number of atoms in the universe, everyone chuckled, and the discussion moved on. I sensed the feeling in the room was that any talk of 128 bits or more was simply ridiculous. Mind you this was for storage. Fast-forward 18 years, and it's fascinating to me to see people now seriously floating the proposal to support 256-bit pointers.
- hughw 4y agoThe difference between "number of atoms in the universe" and "number of possible states of a system" are vastly different. The latter is a combinatorial problem, and if you're trying to to track the possible combinations of 100 variables that can take on 10 states each, you've got 10^100 combinations and are already beyond atoms in the universe (10^80). You can never enumerate them all, but the ability to work on large subspaces would be a help.
- ghoward 4y agoIt would be sad if we, as an industry, do not take this opportunity to create a better OS. First, we should decide whether to have a microkernel or a monolithic kernel. I think the answer is obvious: microkernel. This is much safer, and seL4 has shown that performance need not suffer too much. Next, we should start by acknowledging the chicken-and-egg problem, especially with drivers. We will need drivers. So let's reuse Linux drivers by implementing a library for them to run in userspace. This should be difficult, but not impossible, and the rewards would be massive, basically deleting the chicken-and-egg problem for drivers. To solve the userspace chicken-and-egg problem (having applications that run on the OS), implement a POSIX API on top of the OS. Yes, this will mean that some bad legacy like `fork()` will exist, but it will solve that chicken-and-egg problem. From there, it's a simple matter of deciding what the best design is. I believe it would be three things: 1. Acknowledging hardware as in [1]. 2. A copy-on-write filesystem with a transactional API (maybe a modified ZFS or BtrFS). 3. A uniform event API like Windows' handles and Wait() functions or Plan 9's file descriptors. For number 3, note that not everything has to be a file, but receiving events like signals and events from child processes should be waitable, like in Windows or Linux's signalfd and pidfd. For number 2, this would make programming so much easier on everybody, including kernel and filesystem devs. And I may be wrong, but it seems like it would not be hard to implement. When doing copy-on-write, just copy as usual, and update the root B-tree node; the transaction commits when the root B-tree node is flushed to disk, and the flush succeeds. (Of course, this would also require disks that don't lie, but that's another problem.) [1]: https://www.usenix.org/conference/osdi21/presentation/fri-keynote https://www.usenix.org/conference/osdi21/presentation/fri-ke...
- warinukraine 4y agoWould you like to mention what kind of expertise you have to state that a microkernel is obviously better, and in what sense it's better? And also explain how is it that microkernels already exist and no one cares? Especially the ones older than Linux?
- ghoward 4y agoSmaller Trusted Computing Base (TCB). Easier to audit and if necessary, prove correct. I want better security in computing more than I want performance.
- torginus 4y agoOn a bit tangential note, RAM price for a given cost used to increase exponentially until the 2010s or so. Since then, it only roughly halved. What happened? https://jcmit.net/memoryprice.htm https://jcmit.net/memoryprice.htm I know it's not process geometry, since we went from 45nm->5nm in the time, a roughly 81x decrease. Is is realistic to assume scaling will resume?
- hnuser123456 4y agoWe decided to slow down giving programmers excuses to make chat applications as heavy as web browsers
- tomcam 4y agoJust wanted to say I love this discussion. Have been pondering the need for a 128-bit OS for decades but several of the issues raised were completely novel to me. Fantastic to have so many people so much smarter than I am hash it out informally here. Feels like a master class.
- znpy 4y agoI wonder if with 128-bit wide pointers it would make sense to start using early-lisp-style tagged pointers.
- tonnydourado 4y agoThe "In my shoes?" bit was hilarious
- jupp0r 4y ago"The problem now is that there is no 64-bit type in the mix. One solution might be to "ask the compiler folks" to provide a __int64_t type. But a better solution might just be to switch to Rust types, where i32 is a 32-bit, signed integer, while u128 would be unsigned and 128 bits. This convention is close to what the kernel uses already internally, though a switch from "s" to "i" for signed types would be necessary. Rust has all the types we need, he said, it would be best to just switch to them." Does anybody know why they don't use the existing fixed size integer types [1] from C99 ie uint64_t etc and define a 128 bit wide type on top of that (which will also be there in C23 IIRC)? My own kernel dev experience is pretty rusty at this point (pun intended), but in the last decade of writing cross platform (desktop, mobile) userland C++ code I advocated exclusively for using fixed width types (std::uint32_t etc) as well as constants (UINT32_MAX etc).
- brenns10 4y agoThis question came up in the discussion at the conference. There are several reasons: 1. The format specifiers for those types differ from the ones currently in use for the kernel. Nobody uses or wants to use PRId64 and PRIu64. If they did, they'd need to change thousands of occurrences (which is admittedly not too hard with tools like Coccinelle). 2. The stdint.h types are just typedefs (it's not like the compiler understands them intrinsically). And they're defined in terms of short, int, long, etc. The sizes of these are platform and compiler dependent. On the other hand, the Linux kernel tells the compiler "you must make long 64 bits if you are a 64 bit system" which may conflict with the defaults and throw those types out of whack. (at least, that's how I interpreted one of the points in the room, I could be wrong here) 3. Kernel is already using u32/s32, it's a smaller and easier change to go to u32/i32 in Rust style. People tend to find the stdint.h names to be verbose. 4. stdint.h brings in additional headers. I'm not sure if that's a problem or how - maybe in the Linux uapi headers? There seemed to be general concensus in the room that stdint.h wasn't used for good reasons, so if these don't sound right, it's probably because I misinterpreted them.
- jupp0r 4y agoAwesome summary, thanks and all good points.
- amelius 4y agoPerhaps it's an idea to make Linux parameterized in the pointer/word size, and let the compiler figure it out in the future.
- cobbaut 4y agoAnd do this again in 2050 to get to 256-bit computing? And then 512-bit around 2070? Can we not play it save and immediately jump to for 65536-bit :) We could call it 16-bit-bit.