from the ground up
My current bus activity is AROS hacking. I’ve actually been doing at least an hour a day for the last couple of months, so I’m making plenty of progress, but I’m off on a long and exciting tangent so it all seems quite different to what I was doing before.
I started thinking about what it would take to make cairo a “first-class” graphics system, sitting directly on top of the graphics drivers, bypassing
graphics.library completely. This isn’t a crazy idea - a major part of
graphics.library is providing drawing and font rendering primitives, similar conceptually to what cairo does (though cairo is of course far more advanced). My thought is that we make the graphics system at the bottom of the stack for apps do all sorts of crazy compositing and whatever other eyecandy effects, and the whole desktop benefits. Initially it could operate alongside
graphics.library, but it’d also probably be reasonable to implement
graphics.library functions on top of cairo at some later time.
From there I started looking at the graphics driver API. What we have works well enough (despite the deficiencies that I’ve complained about in the past), but its not a particularly good fit to the cairo backend API, and from what I understand, not a great match for a modern 2D hardware interface either. So the next thing I started thinging about was to change the graphics drivers to have the exact same interface as the cairo backend API. From there, a driver and/or the hardware could directly accelerate cairo drawing operations. The cairo software fallbacks are pretty heavily tested and optimised (including some tight assembly versions of things where necessary), so I’d expect that even a graphics card or whatever that doesn’t offer a lot of function could still go faster than, say, the current SDL driver (which uses the
graphics.hidd fallbacks for just about everything currently).
So now I’m looking at drivers. As you know, I work in hosted, so my two examples are the X11 and SDL drivers. Something I hate about the X11 driver is how closely tied to the underlying kernel implementation. I took some steps to deal with this when I wrote the SDL driver with
hostlib.resource, but its not perfect, and lately something has changed in the X11 driver to require it to be linked with the kernel once again. Besides that, the X11 driver is ancient, hailing from a time where AROS windows were X11 windows, and it retains a lot of that structure even though its no longer the way the world works. Also, it relies on the X11 “backing store” feature, which is usually disabled and will shortly be removed from Xorg. In short, the thing needs a rewrite.
So yay, rewriting one, maybe two, graphics drivers. Down a level to figure out what’s going on the core, and sure enough, more work required there. In the last few years the structure of an AROS kernel has changed to be a minimal
kernel.resource which implements the absolute minimum required to initialise the memory and task-switching hardware and hand control to
exec.library. The loader (typically GRUB) can optionally get whatever modules (libraries, resources, devices, etc) into memory and make them available to
exec when it starts. This is the basic idea behind the so-called “modular kernel”, which has been implemented in the
x86_64, Efika, SAM (both PPC), and more recently,
mingw32 ports. The only ports that don’t do this are the first two - Linux hosted and
mingw32 port is particularly interesting. Its a hosted port to Windows, and in essence uses the OS threading system to implement a minimal virtual machine, all within
kernel.resource. It has a small bootloader that loads an ELF kernel, making it so that stock AROS i386 code can be used even on Windows which doesn’t use ELF itself. The other thing it does is neatly split modules into host-side and AROS-side parts. The AROS parts are handled as normal modules, but in their initialisation they call into
hostlib.resource (which is now contained within
kernel.resource) to load and link the host-side part. These are standard shared libraries (ie DLLs) which can bring in any library dependencies they need, neatly avoiding the problem contained within the X11 and SDL drivers in that its kinda painful to find the needed libraries at runtime. This way, you just find what you need at link time.
And so, after all this, I’m doing a new port of AROS to Linux, based on the structure used for the
mingw32 port. I’m improving on it a bit though. There’s still too much arch-specific code in
exec.library (like thread context manipulation) which I’m hiding inside
kernel.resource. I’m also adding a
host.resource which will provide ways for modules to hook into the system main loop inside
kernel.resource to do things like “virtual” hardware and the like (ie faking interrupts and such). The
mingw32 port did this via special architecture-specific calls in
kernel.resource, but I want to try to make
kernel.resource have a standard interface across all ports, so they can all run an
exec.library that is substantially the same.
So that’s some kind of plan. I’m currently at the point where the
kernel.resource boots and gets
exec.library online. The next thing I need to do is reimplement my task switching and interrupt core which I never tested. If you feel like googling something, it turns out that
ucontext_t is not particularly easy to copy or cache on Linux due to the Linux people messing up the way they store the floating point state. I need to rewrite it based on the wonderful context_demo.c example, which never requires an explicit context copy and should do much better. After that I should be able to hook DOS up and get something interesting happening.
I’ll keep working and maybe let you know some more in another month or two :)