OSDev.org

Sorry for being rude. I just don't think it's a good idea.

If you aren't going to interpret it, that might be more feasible. However, it sounds a lot more complicated to write. But I suppose if you're writing a real-time OS, the speed-up might be important enough. I guess I prefer a more traditional, time-tested approach to OS development.

I respect your views, of course, and since it's your own OS you may do as you please (you have my permission ;D )

BTW, I wouldn't write an OS in C++ (I'm not very skilled at C++) but I do think it's a good idea. Having re-read your post a bit I'm starting to see that it might work. I wouldn't want to go to the extra trouble of writing a JIT compiler myself, but it's your OS...

Just remember, you could have some problems.

Since everything runs at RING-0, your JIT compiler had better check for problems- some 'bad person' might write a malicious program, and the JIT compiler would have to recognize the code and disallow it from going through.

Also, although sychronization might be eliminated by using "CLI", you'll probably have some other IPC problems.

These can all be fixed, but writing a JIT compiler for that purpose could become as difficult as writing the rest of the OS. So while it could, in theory, be faster, you'll have difficulties writing it.

NotTheCHEAT wrote:Sorry for being rude.

Your efforts to be more polite are noted and appreciated.

NotTheCHEAT wrote:Since everything runs at RING-0, your JIT compiler had better check for problems- some 'bad person' might write a malicious program, and the JIT compiler would have to recognize the code and disallow it from going through.

Preventing malicious or simply borked code from running in ring 0 is the main reason to go with a JIT in the first place:

Colonel Kernel wrote:My understanding of IL is that it has a "safe" subset that only deals in object references and field offsets, not directly with memory addresses. This means that for a certain class of programs, you can prove whether or not the program is typesafe simply by looking at the IL and corresponding class metadata.

Basically, the idea is to disallow direct memory access at the language level, and maintain that same type-safety in the intermediate language as well.

And yes, it would be hard to implement. The question is how desperate are we to avoid address-space switching overhead (if you go with a microkernel) or BSODs/panics (if you go monolithic).

NotTheCHEAT wrote: You'll always need to write some parts of the OS in assembly, and assembly and Java/C++ are like polar opposites.

*gasp*

Don't throw Java and C++ into one box. Please. They're simply not playing in the same league.

NotTheCHEAT wrote: These can all be fixed, but writing a JIT compiler for that purpose could become as difficult as writing the rest of the OS. So while it could, in theory, be faster, you'll have difficulties writing it.

It might be true that other systems don't need a JIT, but a system based on this idea does not some need things that other operation systems need (different protected address spaces and then ways to pass information from space to space etc.)

Probably someone doesn't need to do more for a JIT-based OS, doing different things fits better!

NotTheCHEAT wrote: If you aren't going to interpret it, that might be more feasible. However, it sounds a lot more complicated to write. But I suppose if you're writing a real-time OS, the speed-up might be important enough. I guess I prefer a more traditional, time-tested approach to OS development.

Remember that this was just a design idea, I don't think I will have that implemented within the next few months. Currently, I'm working on something different (have a look at the 'OS design' thread) and 'more traditional' anyway, to get something done, at least.

BTW, I wouldn't write an OS in C++ (I'm not very skilled at C++) but I do think it's a good idea. Having re-read your post a bit I'm starting to see that it might work. I wouldn't want to go to the extra trouble of writing a JIT compiler myself, but it's your OS...

Writing an OS in object oriented C++ is currently being done by (I guess) many people on this board, and has even been done by commercial and widely accepted projects around the world. Don't confuse C++ and Java, C++ by itself has nothing to do with virtual machines, JIT compilation, garbage collection and the like. It's a low level language like C, only that it has extensions for object oriented programming.

Writing a JIT compiler might of course be a difficult task when you don't have much knowledge of compilers and optimizers at all (I don't have, yet). But I hope the 'building compilers' course at the university, which I'm going to attend in the next few seasons, will shed some light on this issue.

cheers Joe

I've just "read" most of this thread and the originating thread (http://www.mega-tokyo.com/forum/index.php?board=1;action=display;threadid=2741).

I was suprised to find how much the object (namespaces) method and virtual abstraction seem to mirror the Singularity research OS

Do check out their technical report!

I was suprised to find how much the object (namespaces) method and virtual abstraction seem to mirror the Singularity research OS

Can you be sure who is mirroring who? The only thing I'm certain of is that we're very probably not mirroring them since they're not as public as we are.

Well, in fact the Singularity OS goes into the very same direction, yes, and I was surprised about that too. I don't know how old the project actually is, but I can tell you that I hadn't heard anything about it until, say, august this year.


Just look at how Microsoft centralizes more and more areas of software development around the .net platform, I believe it was a rather logical step for them to take on a .net-based OS...

And about namespaces - plan9 already showed the concept years ago, so if there is an originator, they are.

cheers Joe

Yep, i've been talking with hobby OSdevers for about 4 years now through forums and the like ... Ideas like having a database of documents rather than a filesystem, of having 3D textured windows, of having a shell that integrates better with the running components are quite long-lived ... I don't think you can blame people that talk about that of "mirroring" MS's latest announcements: they just happened to follow the same track of thougts ...

I don't say people at MS research do just mirror ideas submitted in public board ... Seeing the same "good ideas" popping up independently in many minds is just the natural way things go, what probably worth keeping an eye on is that MS keeps actively trying to push those ideas to the masses.

Yet, i think it would be a thread-killer to argue *that* in this very thread.

Hi,

Pype.Clicker wrote:Seeing the same "good ideas" popping up independently in many minds is just the natural way things go...

Well said. Now if you could only explain this to patent advocates...


Cheers,

Brendan

I didn't mean anything bad by the "mirror" thing . Just how similar certain ideas looked. It doesn't really matter either. It is very nice to see where things are going (including thoughts), or might be going.

From what I understand the Singularity OS is around 2 years old. It really developed in the last year or so. The technical report is a great read on certain design choices they made (JIT, safe verifiable code, messaging, no shared memory, namespaces, contracts etc.).

It would be interesting to see the system combined with an object store (perhaps similar to the WinFS system they are working on for XP/Vista, except without any other underlying filesystem) etc.