6
Votes
Fresh from appreciating the awesome mathematical genius whereby various Loons have convinced themselves that the Linux kernel does not, in fact, have any bloat at all, I found this on the Pog-Blog, courtesy of Oiaohm.
I’m not sure what to make of it, really. It’s insanely detailed, to no obvious effect. Apparently, to sum it up, the Windows kernel lacks features that make Linux Linux, whereas the Linux kernel lacks features that make Windows Windows. More news at eleven.
Whatever. It is most certainly FUD, of a high and almost obsessive quality.
Comments
First off, isn’t the Windows kernel a Hybrid?
“Windows API – Y (mostly undocumented)”
/facepalm. Does this dolt think that just because he can’t read the documents, that they don’t exist? The Windows API must be documented (how well documented, I’ll leave to the good Dr. to comment) or Microsoft programmers would spend all day re-inventing wheels.
I think, technically, it’s a cross between monolithic and hybrid. The genuine NT part (even Oiaohm has admitted that “it’s a good design, but poorly implemented,” whatever that means) is monolithic. You could regard that as the kernel, if you wish.
On the other hand, the “kernel,” as exposed to developers and the like, could be MFC or Winforms or ATL or COM or whatever you like. Although they’ve lost interest in it, there’s no particular reason why it shouldn’t be Posix. Or anything else. So, in that sense, it’s hybrid.
It isn’t properly hybrid, and there’s a theoretical opening for a proper hybrid OS based on something derived from either Mach or Minix, but it’s as good as we’ve got at the moment. It would be a hell of a lot easier to build a proper HAL on top of the NT kernel than it would be on top of Linux. (I watched attempts at this when I worked for Stratus, who very nearly came up with a hardware fault-tolerant HAL on top of NT 4.0. Well, actually, they succeeded. But it bombed in the marketplace.)
The short answer is, yes, it’s pretty well documented for those that need to know. For the rest of us, read Raymond Chen.
“Windows API – Y (mostly undocumented)”
Uhm, Im not totally sure, but it’s written “MS Native API”, which I guess is the Rtl*, NtKernel*, etc. functions family. I haven’t checked if they are documented at the msdn. If Dr Loser would shed a light on this, I would be grateful.
Would someone explain to me what does “Real-Time class can be %CPU capped”“?
... mean
Sorry to disappoint you, but I can’t. All that guff is utterly irrelevant to my job, let alone my life. Now, Linux, on the other hand …
... I could probably answer a direct and specific question, but to be honest you’re better off with Raymond Chen. He lives, eats and breathes this stuff.
As to “Real-Time class can be %CPU capped”?
It’s a reference to soft real-time. You get to pick one of a multitude of cretinous schedulers, and you rely on the supposed fact that your particular scheduler implements “real-time” by what is, effectively, time-sharing.
Hard real-time involves pre-emption, guaranteed latency, and one other thing I’ve forgotten. But, basically, hard real-time doesn’t happen on the Linux kernel (it doesn’t happen on the NT kernel either).
Unless you have this fabulous thing called a “patch.” I notice that a “patch” crops up all over this nasty little piece of FUD. Real-time? Security? Why, you just need a “patch.”
Or possibly a suitable operating system.
Oh yes, priorities.
NT does this very badly indeed, from memory. (I suppose I could look up the relevant paragraph in the quoted link.)
Last time I looked, Linux doesn’t do it any better.
You can’t really have pre-emption and guaranteed latency without a proper model of priorities. I recommend QNX for that, but what would I know?
@Ted
I’m pretty sure the Windows API has to be documented… after all, wasn’t that a requirement of the antitrust case? Microsoft would leave parts of the documentation out so they could have the upperhand over third parties.
Thank you, Dr Loser, maybe I’ll try my luck with Mr Chen. I like his profuse style of writing.
“ ... hard real-time doesn’t happen on the Linux kernel (it doesn’t happen on the NT kernel either).”
Yes, indeed, I was quite surprised when I saw talk in the link about real time stuff.
Tell him I sent you.
snork
I’m a mere contractor at Microsoft: I could do with the networking.
Well, that crap is definitely a product of some kind of obsession. I wouldn’t use the word “quality” when I speak about lists like that.
First I though to point out all mistakes, but then I’ve found so many, that I just cannot find enough “obsession” to go after all of it.
Few things.
First of all, NT is technically a monolithic. Which means monolithic address space. “Hybrid” is the term, used to describe monolithic kernel that have microkernel-ish design, but for some reasons (performance is the main one) were implemented as monolithic.
And speaking of hard realtime. It’s not possible on monolithic kernels. PERIOD. There are projects to HOST both Linux and Windows inside microkernel, but it doesn’t make either Linux or Windows hard RTOS. If it does, then hosting Linux in Hyper-V would make Linux to become Windows.
> development process – simpleYN
WUT? How com
> modularity – highYN
This guy REALLY thinks that conditional compilation means modularization. Surprise: module is an entity that hides its data and implementation details and communicates with outside world through well defined (preferable stable) interfaces. Just for the sake of maintainability modules are usually “physically” separated into different directories (or in case of one-file-per-module 0 different files).
Linux kernel is the biggest tightly coupled piece of junk ever created by humankind: you include (in)famous LSM “interface” (http://lxr.linux.no/linux+v3.1.4/include/linux/security.h) – you end up coupled to implementation details of memory manager, scheduler, etc (just try to recurse into includes). Given the fact, that almost everything includes that security.h (to provide superior MAC security) – we have everything-to-everything kind of coupling and zero cohesion. Keep in mind that it’s not one-off example – it’s actually just good example of general DEVELOPMENT PRACTICE.
But what about that “make fooconfig” thing? It’s just conditional compilation. I can’t remember ANY modular design that could be implemented through conditional compilation.
BTW, Wikipedia article on data hiding has very interesting reading on modular designs http://www.cs.umd.edu/class/spring2003/cmsc838p/Design/criteria.pdf
> estimated bug error rate per line0.02%'100.2% 10, 16’
> i.e. estimated bugs total1400 10’ * '34000 10, 16’ * '
Who the fsck estimated this? 34k (63k in the reference right after this number: http://widefox.pbworks.com/w/page/8042314/Notes#n16 which only adds credibility to these numbers) bugs in W2k kernel ALONE? Really? Care to provide sources?
1400 bugs in Linux kernel? Really?
Well, and after this
> files – kernel mode (no drivers25, 29)vmlinuz11, 12’NTOSKRNL.EXE, HAL.DLL, GDIPLUS.DLL, WIN32K.SYS’'
And it’s not a typo – it’s repeated:
> files kernel mode – multiprocessor, no PAE (no drivers25, 29)vmlinuz11, 12NTKRNLMP.EXE, HAL.DLL, GDIPLUS.DLL, WIN32K.SYS
> files kernel mode – uniprocessor, PAE (no drivers25, 29)vmlinuz11, 13NTKRNLPA.EXE, HAL.DLL, GDIPLUS.DLL, WIN32K.SYS
> files kernel mode – multiprocessor, PAE (no drivers25, 29)vmlinuz11, 13NTKRPAMP.EXE, HAL.DLL, GDIPLUS.DLL, WIN32K.SYS
You can safely stop reading (gdiplus in kernel, really?) – this guy has no clue (I’ve actually read to the end and yes, he doesn’t).
Ah, so my confusion wasn’t just me.
I hope the 20000 word essay explains more …
NT Kernel is actually hybrid. By design, even Win32 was a separate subsystem on top of the kernel, and it got executed in user space.
Later on (with 3.51?) Win32 subsystem got partially into kernel mode, to improve performance. The client-server calls between the Win32 subsystem and the NT kernel brought quite some performance penalty, especially with hardware-accelerated graphics.
However, it is still possible to put other subsystems on top of the kernel.
That aricle got it wrong from the very start. It becomes only worse after that. I admit I didn’t make it further than page 6.
@Phenom
It’s not even about user mode subsystems (and csrss in particular), it’s also (and in my opinion for most part) about Kernel/Executive Services distinction in ntoskrnl itself. Everything is modularized with extensive usage of message passing (IRP/APC/DPC, KQUEUEs, etc) to achieve intermodule communication. It should be said, that performance was a priority over being a microkernel, so many things are still communicated as raw pointers.
So, hybrid kernel is technically a monolithic one (meaning that lots of things live in a single kernel address space and execute on the same trust level as kernel itself), but after reading more of this guy, I don’t think he actually realized any of these.
@Linsuxoid:
Incidentally, I’m sorry I sort of encouraged you to read the twit. It’s sort of like dealing with a version of Adam who’s prepared to back up his statements with actual, if bogus, information, isn’t it?
If it makes everybody feel happier, I should point out that the last update to this masterful Wiki was in 2009. Apparently even obsessional insanity has its limits.
@Phenom:
Try the security bit. It’s a peach.
Quote: “immunity from viruses (given common usage)”
Omg. This is as cheap as it can get.
You must be signed in to leave comments.