Quark (kernel)
In computing, Quark is an operating system kernel used in MorphOS. It is a microkernel designed to run fully virtualized computers, called boxes (see sandbox). , only one box is available, the ABox, that lets users run extant AmigaOS software compiled for Motorola 68000 series (MC680x0 or 68k) and PowerPC central processing units (CPUs).

Design goals

The Quark microkernel is not a member of the L4 microkernel family, but borrows concepts from it, including: the clan (group of tasks), ID concept, and recursive address mapping. Quark also has an asynchronous/synchronous message interface similar to Amiga's Exec kernel but adapted to an environment with memory protection.

Other Quark features include:
 High super/usermode switch speed
 Low interrupt latency
 Interrupt threads (IntThreads) and Int P-code abstraction
 Symmetric multiprocessing (SMP)
 Models task/thread and clan/chief
 Resource tracking
 Virtual memory (optional)
 Distributed computing
 No access to kernel structures
 Clean design with an elegant application programming interface (API)
 Micro/pico kernel mix

For this new kernel, a hardware abstraction layer is used which provides the needed hardware resource information like scanning all Amiga Zorro II bus boards, Peripheral Component Interconnect (PCI) boards, and local hardware resources.

Functions

 SYS_AddLinkMessage
 SYS_AttemptSemaphore
 SYS_AttemptSemaphoreShared
 SYS_CopyCPUHalConfig
 SYS_CreateMemList
 SYS_CreateTask
 SYS_DeletePort
 SYS_DeleteSemaphore
 SYS_DumpMemHeader
 SYS_FindFreeMemArea
 SYS_FindSkipSize
 SYS_GetLinkMessage
 SYS_GetMessageAttr
 SYS_GetNextCPU
 SYS_Init
 SYS_InsideClan
 SYS_IsClanMember
 SYS_MMUAddPage
 SYS_MMUGetEntry
 SYS_MoveRomModuleToMemoryEnd
 SYS_ObtainPort
 SYS_ObtainSemaphore
 SYS_ObtainSemaphoreShared
 SYS_ReleaseSemaphore
 SYS_ReplyMessage
 SYS_SendMessage
 SYS_SetMessageAttr
 SYS_SetupPageTable
 SYS_ShowExceptionThreads
 SYS_ShowForbidThreads
 SYS_ShowIntThreads
 SYS_ShowQuarkState
 SYS_ShowReadyThreads
 SYS_ShowRunThreads
 SYS_ShowThreads
 SYS_ShowWaitIntThreads
 SYS_ShowWaitThreads
 SYS_Start
 SYS_StartNextThread
 SYS_StartThread
 SYS_WaitPort

Trance JIT
Trance JIT is a MorphOS just-in-time (JIT) compiler, or code translator, for running 68k applications within the MorphOS environment. It has been part of the MorphOS operating system since MorphOS 1.4.

MorphOS has a fully integrated 68k emulator to run many Amiga applications, which were almost exclusively compiled for the 68k processor, though MorphOS runs on PowerPC. Trance supplements this function by adding JIT compiling, increasing the speed of the emulation. It does not interfere with the full integration of 68k and PowerPC tasks MorphOS provides.

Trance exists in the form of an executable, run during boot, and a shared library. Although it is not technically part of the kernel, and MorphOS can be run without it, Trance is considered a fundamental part of MorphOS and one of its most powerful features.

Compatibility of Trance is considered to be very high and there are few to no 68k instruction sequences or applications which cause it any problems. It is also considered to be very fast, with users noticing few differences between 68k programs and native PowerPC code.

Trance was developed by Ralph Schmidt and Teemu Suikki, with minor support from other MorphOS team members, Mark Olsen, Sigbjørn Skjæret, and Harry Sintonen.

ABox
Under the Quark kernel, a PowerPC native reimplementation of the OS known from the Commodore International A1000, A500(+), A600, A2000, A1200, A3000(T), and A4000(T) systems runs as a mix of a virtual emulation and a driver. This OS driver is called an ABox.

The 68k emulation is written in C and uses GNU Compiler Collection (GCC) assembly language macros where needed to speed up some complex instructions.

A JIT engine named Trance is also available for MorphOS, to speed up old 68k programs beyond the current state of the traditional emulation.

The PPC native Exec supports the PowerPC register model which means there is no difference for this Exec if it runs 68k or PowerPC code. PowerPC code does not block multitasking inside the OS box like in emulations where the 68k code is just emulated in some host system's task (then every access outside this environment would stop the multitasking in the emulated environment).

For applications running under this new PowerPC ABox kernel 68k code runs as subroutines inside PowerPC tasks. For 68k or PowerPC applications it's fully transparent if some library, hook, interrupt is still 68k or already using PowerPC code.

References

Microkernels
MorphOS