I think I'm closer to the solution of the old old problem of copy-less data transmission between threads or processes.

Already, switching from one process to another is almost as easy as a Call/Return within a given process. The procedure uses 3 dedicated opcodes : IPC, IPE and IPR (InterProcess Call/Enter/Return). The real problem is how to transfer more data than what the register set can hold.

My new solution is to "mark" certain address registers to yield the ownership of the pointer to the called process.

• The caller saves all the required registers on its stack and "yields" one or more pointers with a sort of "check-out" instruction that sets the Read and Write bits, as well as changes the PID (ownership of the block) OR puts the block in a sort of "Limbo" state (still owned but some transfer of ownership is happening, in case the block is not used by the recipient and needs to be reused).
• The called process "accepts" the pointer(s) with a "check-in" instruction so the blocks can be accessed within the new context and mapped to the new process' addressing range.

This creates quite a lot of new sub-problems but I believe it is promising.

• How do you define a block ? It's basically 1)  a base pointer 2) a length 3) access rights 4) owner's PID. All of these must have some sort of HW support, merged with the paging system.
  The sizes would probably be powers-of-two, so a small number easily describes it, and binary masks checks the pointer's validity.
• Transferable blocks must come from a global "pool" located in an addressing region that is identical for everybody because we don't want to bother with translating the addresses.
• IF there is a global pool then one process must be responsible for handling the allocation and freeing of those blocks.

This affects the paging system in many ways so this will be the next thing to study...