xqemu VS ComLightInterop

These projects are called compatibility layers, or "translation layers" sometimes. I think XQEmu (OG XBox on PC) works the same.

Yes:

https://xemu.app/

https://xqemu.com/

Are both original Xbox emulators built off of QEMU. I've only used Xemu, but performance was pretty good for the games I tried on it (it doesn't have a way to upscale rendering yet though).

It's indeed a bit like a kexec.

On system initialization, kernel routines are copied into RAM by the bootloader[1]. Executables run in ring 0, and have a jump table to call kernel routines in their own address space (IIRC) [2].

As such, loading any executable counts as a soft reboot.

Also, there is a functioning open source emulator, Xqemu [3] (and its sibling/fork focused on speed and compatibility more than accuracy, xemu [4])

I recommend reading "17 mistakes Microsoft made in the Xbox security system", which is very informative [5].

[1]: https://xboxdevwiki.net/Boot_Process

[2]: https://xboxdevwiki.net/Kernel

[3]: https://xqemu.com/

[4]: https://xemu.app/

[5]: https://xboxdevwiki.net/17_Mistakes_Microsoft_Made_in_the_Xb...

There is one emulator currently that does do that, the "XQEMU" emulator for the original Xbox https://xqemu.com/

It's in its infant stages at the moment according to the "Emulation General" wiki and focuses heavily on "accuracy" over performance

Other emulators such as CXBX-Reloaded have made larger strides, currently emulating roughly 10% of the software library

It's also worth stating, while the Xbox seems like an "easy" target, being based on an ia-32 (Pentium III) PC with an Nvidia GeForce chip (somewhere between a Geforce 2 and 3 at the time) it is an absolutely monstrous beast with minimal documentation about its hardware and numerous "gotchas"

It also has a very small library of 'exclusive' content which detracts from gaining many developers

I have once made something remotely similar, to interop between C++ and C#: https://github.com/Const-me/ComLightInterop

I took different approach. Because I only needed to support these two languages, there’s no separate interface definition language, and no code generator for interfaces. Instead, users are expected to write both language projections manually.

Then there’s a runtime code generator on the .NET side of the interop which builds runtime callable proxy types for interfaces implemented in C++, also virtual tables for C# objects consumed by C++.

It’s pretty fast. Likely reason for that, MS designed both language and runtime this way since version 1.0. They needed that for their Windows Forms which consumes huge chunk of WinAPI.

I benchmarked a while ago when testing this library https://github.com/Const-me/ComLightInterop#performance On the computer I was using at that time (probably Ryzen 5 3600 CPU) the overhead was 15-20 nanoseconds per call.

That thing is COM, which is a small subset of C++ ABI. Technically it’s about the same as on Windows, i.e. C ABI with extra first argument for this pointer.

Once upon a time I made this library https://github.com/const-me/comlightInterop/ The native side of the interop is idiomatic C++, here’s an example https://github.com/Const-me/ComLightInterop/blob/master/Demo... The C# side of the interop is implemented through the built-in C interop, here’s the relevant part of the library https://github.com/Const-me/ComLightInterop/blob/master/ComL... I’ve tested Linux version of that library on AMD64, ARMv7, and ARM64 CPUs, but only with gcc compiler on the native side.

I like many parts of COM, but I believe that example mostly demonstrates bad parts, with IDL, registrations, and over-engineered support libraries.

There's nothing wrong with exporting factory functions from DLLs. Microsoft does it all the time, APIs like Direct3D, DirectDraw and Media Foundation don't come with type libraries are they aren't registered anywhere.

Speaking about support libraries, I once made my own: https://github.com/Const-me/ComLightInterop/tree/master/ComL... Compare examples from that article with this one: https://github.com/Const-me/ComLightInterop/blob/master/Demo... That source file is the complete DLL which implements a minimalistic COM object.

> Does it feel "brittle" to use

Yes and no.

No because when you try to do unsupported things like calling a method on an object which doesn’t support one, you gonna get an appropriate runtime exception.

Yes because if you fail lower-level things like local parameter allocation, you gonna get an appropriate runtime exception but that one is (1) too late, I’d prefer such things to be detected when you emit the code, not when trying to use the generated code (2) Lacks the context.

Overall, when I can I’m using that higher-level System.Linq.Expressions for runtime codegen. Things are much nicer at that level. I only using the low-level thing when I need to emit new types, like there: https://github.com/Const-me/ComLightInterop/blob/master/ComL...

> Do you have any good resources on writing dlls to consume via .net like you’re talking about?

For C APIs i.e. functions, structures and strings, the good resource is Microsoft documentation, the support is built-in, see “Consuming Unmanaged DLL Functions” section: https://docs.microsoft.com/en-us/dotnet/framework/interop/

For COM APIs i.e. sharing objects around see this library + demos: https://github.com/Const-me/ComLightInterop It’s only really needed on Linux because the desktop version of the framework has COM support already built-in, but it can be used for cross-platform things just fine, I tested that quite well i.e. not just with these simple demos.

> How do you deal with the managed memory when using the gc from .net

Most of the time, automatically.

When you calling C++ from C#, the runtime automatically pins arguments like strings or arrays. Pinning means until the C++ function returns, .NET GC won’t touch these things. This doesn’t normally make any copies: C++ will receive raw pointers/native references to the .NET objects.

Sometimes you do want to retain C# objects from C++ or vice versa i.e. keep them alive after the function/method returns. An idiomatic solution for these use cases is COM interop. IUnknown interface (a base interface for the rest of COM interfaces) allows to retain/release things across languages.

C++ interop is not supported in modern .NET out of the box, but wasn't too hard to implement as a library: https://github.com/Const-me/ComLightInterop