| ▲ | anarazel 2 hours ago |
| It is somewhat interesting that the most widely used "big" OS that doesn't use fork, i.e. Windows, has dog slow process creation... I agree that there should be non-fork primitives, I'm just not that sure that performance is the best argument. |
|
| ▲ | mort96 2 hours ago | parent | next [-] |
| The problem with fork isn't really that it's slow. The problem is that if you want it to be not-slow, it locks you into a bunch of OS design decisions: you more or less need a memory subsystem where all writable pages are refcounted and copy-on-write when the refcount is bigger than 1, and you need overcommit. Now these decisions aren't objectively bad, but they have significant trade-offs and it's probably not a good idea that they're forced simply because we use fork()+exec() for process creation. |
| |
| ▲ | marcosdumay an hour ago | parent | next [-] | | CoW is probably a good idea whether you use fork or not. Or rather, fork is probably a better option than just exec exactly because it can benefit from CoW. At least on systems with virtual addressing. If you want to go into physical addressing, then yes, maybe it's a problem. But Linux will never touch anything with physical addressing, so I don't see what people are complaining about. | |
| ▲ | theK an hour ago | parent | prev | next [-] | | Didn't he just say that fork turns out to be comparatively faster to the non-fork samples we get? Ie Linux spawns processes faster than Microsoft's kernels? | | |
| ▲ | mort96 an hour ago | parent | next [-] | | Didn't I just say that "the problem with fork isn't really that it's slow"? It's all the other OS design choices it forces on you if you want it to be fast. | | | |
| ▲ | nvme0n1p1 an hour ago | parent | prev [-] | | We don't have any broadly used non-fork samples. Windows, macOS, and Linux all have fork. So the presence of fork can't be the reason for the performance difference. (Windows's fork is called ZwCreateProcess) | | |
| ▲ | dcrazy 39 minutes ago | parent [-] | | NtCreateProcess does not implement a forking model. It is analogous to posix_spawn. |
|
| |
| ▲ | dapperdrake 21 minutes ago | parent | prev [-] | | How else does consistency work, then? Only being half facetious here. Maybe you or someone else really has a better take. | | |
|
|
| ▲ | pjmlp 2 hours ago | parent | prev | next [-] |
| Because that OS best practices is to use threads. Traditionally Windows applications that create processes all the time come from UNIX heritage. Contrary to UNIX, Windows NT was designed with threads first mentality, from the get go. While on UNIX they were added after fact, and to this day there are gotchas mixing posix threads with signals, fork and exec. |
| |
| ▲ | PaulDavisThe1st 35 minutes ago | parent | next [-] | | A more accurate way to describe this is that Windows' (NT onward) core execution context model is a bunch of threads that by default share memory, whereas Unixen have a core task context model of a bunch of threads that by default do not share memory. Both systems are implemented using threads as the execution context, but in Unix, the history means that that you fork+exec most of the time, resulting in a two tasks that do not share memory any more. By contrast, on Windows (NT onward) the common case when creating a new execution context is to create a thread that shares memory with others in its process. Both systems allow the easy use of the other's core abstraction. On Unix, you can either code like its 1986 and use fork without exec, or use clone(3) or any of its higher level abstractions like pthreads. You're right that POSIX semantics get tangled when using threads. | | |
| ▲ | pjmlp 10 minutes ago | parent | next [-] | | Well, Windows before NT isn't the same design as Windows 16 bit, it only shares the name for all practical purposes, and has more influence from OS/2 than Windows 16 bit. Which is why I took the effort to explicitly refer to Windows NT on my comment, already expecting some traditional answers from UNIX folks. Also due to historical reasons POSIX threads are the outcome of every UNIX going their own way implementing threads, finally coming to an agreement years later, with all the plus and minus of relying in POSIX for portable code. | |
| ▲ | snozolli 6 minutes ago | parent | prev [-] | | whereas Unixen have a core task context model of a bunch of threads that by default do not share memory. How are those not simply child processes? I don't understand your use of the word 'threads' here. Does the Unix world not distinguish between threads and processes? In Win32, threads exist within processes, and you can create new threads or child processes. |
| |
| ▲ | sunshowers 4 minutes ago | parent | prev | next [-] | | The problem is that threads are not fault boundaries but processes are. So they're not interchangeable when you care about resilience and misbehaving code. | |
| ▲ | knome 5 minutes ago | parent | prev | next [-] | | the only difference between a thread and a process on linux is how many structures they share. the function is identical. | |
| ▲ | zozbot234 2 hours ago | parent | prev [-] | | Windows was designed with threads-first mentality because on pre-386 machines you don't have viable process memory protection, so your tasks share memory by necessity. This is not a great argument. | | |
| ▲ | JdeBP an hour ago | parent | next [-] | | Windows NT was never designed with pre-386 machines in mind. That was the territory of the old DOS+Windows. Windows NT from the get-go was for machines with page-based virtual memory. * https://computernewb.com/~lily/files/Documents/NTDesignWorkb... | | | |
| ▲ | epcoa an hour ago | parent | prev | next [-] | | This is not true. NT never had fork, was always based on the assumption of an MMU and Dave Cutler was a well known fork hater in the 80s long before this paper came out and made it cool to be so. By the time Windows 95 was out, the baseline was 386 with an MMU. CreateThread was initially designed for NT in 1993 though (which didn’t support pre-386 CPUs). | | | |
| ▲ | pjmlp an hour ago | parent | prev [-] | | Windows NT! Misread on purpose to make a point? |
|
|
|
| ▲ | aseipp 2 hours ago | parent | prev | next [-] |
| I suspect it's a long tail sort of thing; it mostly doesn't matter except when it really matters. It's interesting that the stated motivation for the patch is in the context of agentic tools spawning subcommands. There's some related prior art in this area where the payoffs could be much greater, like fuzzing: https://gts3.org/assets/papers/2017/xu:os-fuzz.pdf is an example. It would be very interesting to see this patch applied to e.g. AFL++ |
|
| ▲ | 2 hours ago | parent | prev | next [-] |
| [deleted] |
|
| ▲ | nvme0n1p1 2 hours ago | parent | prev [-] |
| That's not the reason for the performance difference. Windows does have a fork primitive (ZwCreateProcess) and it's still slower than Linux's equivalent. |
| |
| ▲ | dcrazy 26 minutes ago | parent [-] | | Again, NtCreateProcess does not implement fork(). The fundamental characteristic of fork is that the child is an exact replica of the parent, down to the instruction pointer. Windows does not have a way to create a process object with such a configuration. Also, using the Zw prefix doesn’t make you look more knowledgeable, it makes you look like you’re trying way too hard to borrow credibility. |
|
