libcommunism::internal::x86 Class Reference

Architecture specific methods for working with cothreads on x86 systems. More...

#include <Common.h>

Inheritance diagram for libcommunism::internal::x86:

Public Member Functions
	x86 (const Entry &entry, const size_t stackSize=0)
	x86 (const Entry &entry, std::span< uintptr_t > stack)
	x86 (std::span< uintptr_t > stack)
	~x86 ()
void	switchTo (CothreadImpl *from) override
Public Member Functions inherited from libcommunism::CothreadImpl
	CothreadImpl (const Cothread::Entry &entry, const size_t stackSize=0)
	CothreadImpl (const Cothread::Entry &entry, std::span< uintptr_t > stack)
	CothreadImpl (std::span< uintptr_t > stack)
virtual	~CothreadImpl ()=default
virtual size_t	getStackSize () const
virtual void *	getStack () const

Static Public Attributes
static const size_t	kNumSavedRegisters {4}
static constexpr const size_t	kMainStackSize {64}
static constexpr const size_t	kStackAlignment {16}
static constexpr const size_t	kDefaultStackSize {0x40000}

Friends
CothreadImpl *	libcommunism::AllocKernelThreadWrapper ()

Additional Inherited Members
Public Types inherited from libcommunism::CothreadImpl
using	Entry = Cothread::Entry
Protected Attributes inherited from libcommunism::CothreadImpl
std::span< uintptr_t >	stack
	Stack used by this cothread, if any. More...

Detailed Description

Architecture specific methods for working with cothreads on x86 systems.

This implementation exploits the fact that clang and GCC both support Microsoft's fastcall calling convention, so we can get away with one implementation for both System V and Windows platforms, albeit with differing assembly syntaxes.

In operation, this is identical to the Amd64 implementation; thread state is stored on the stack and the cothread's stackTop pointer actually points to the stack pointer of the cothread when it is switched out.

Definition at line 29 of file Common.h.

Constructor & Destructor Documentation

x86() [1/3]

x86::x86	(	const Entry &	entry,
		const size_t	stackSize = 0
	)

Allocate an x86 cothread instance, allocating the stack as part of this.

Parameters

entry	Method to execute on entry to this cothread
stackSize	Size of the stack to be allocated, in bytes. it should be a multiple of the machine word size, or specify zero to use the platform default.

Exceptions

std::runtime_error	If the memory for the cothread could not be allocated.
std::runtime_error	If the provided stack size is invalid

Definition at line 40 of file Common.cpp.

                                                   : CothreadImpl(entry, stackSize) {
    void *buf{nullptr};
 
    // round down stack size to ensure it's aligned before allocating it
    auto allocSize = stackSize & ~(kStackAlignment - 1);
    allocSize = allocSize ? allocSize : kDefaultStackSize;
 
    buf = AllocStack(allocSize);
 
    // create it as if we had provided the memory in the first place
    this->stack = {reinterpret_cast<uintptr_t *>(buf), allocSize / sizeof(uintptr_t)};
    this->ownsStack = true;
 
    Prepare(this, entry);
}

x86() [2/3]

x86::x86	(	const Entry &	entry,
		std::span< uintptr_t >	stack
	)

Allocates an x86 cothread with an already provided stack.

Parameters

entry	Method to execute on entry to this cothread
stack	Buffer to use as the stack of the cothread

Exceptions

std::runtime_error

If the provided stack is invalid

Definition at line 64 of file Common.cpp.

                                                     : CothreadImpl(entry, stack) {
    x86::ValidateStackSize(stack.size() * sizeof(uintptr_t));
    Prepare(this, entry);
}

x86() [3/3]

libcommunism::internal::x86::x86 ( std::span< uintptr_t >  stack )

inline

Definition at line 44 of file Common.h.

: CothreadImpl(stack) {}

~x86()

x86::~x86

(

)

Deallocate the stack.

Definition at line 72 of file Common.cpp.

          {
    if(this->ownsStack) {
        x86::DeallocStack(this->stack.data());
    }
}

Member Function Documentation

switchTo()

void x86::switchTo ( CothreadImpl *  from )

overridevirtual

Perform a context switch to this cothread.

The currently executing cothread's state is saved to its buffer, then this cothread's state is restored.

Implements libcommunism::CothreadImpl.

Definition at line 78 of file Common.cpp.

                                     {
    x86::Switch(static_cast<x86 *>(from), this);
}

Friends And Related Function Documentation

libcommunism::AllocKernelThreadWrapper

CothreadImpl* libcommunism::AllocKernelThreadWrapper ( )

friend

Member Data Documentation

kDefaultStackSize

constexpr const size_t libcommunism::internal::x86::kDefaultStackSize {0x40000}

staticconstexpr

Platform default size to use for the stack, in bytes, if no size is requested by the caller. We default to 256K.

Definition at line 103 of file Common.h.

kMainStackSize

constexpr const size_t libcommunism::internal::x86::kMainStackSize {64}

staticconstexpr

Size of the stack buffer for the "fake" initial cothread, in machine words. This only needs to be large enough to fit the register stack frame. This must be a power of two.

It must be sufficiently large to store the callee-saved general purpose registers

Definition at line 90 of file Common.h.

kNumSavedRegisters

const size_t libcommunism::internal::x86::kNumSavedRegisters {4}

static

Number of registers saved by the cothread swap code. This is used to correctly build the stack frames during initialization.

Definition at line 82 of file Common.h.

kStackAlignment

constexpr const size_t libcommunism::internal::x86::kStackAlignment {16}

staticconstexpr

Requested alignment for stack allocations.

This is set to only 16 byte alignment as that's the most stringent of any x86 platform.

Definition at line 97 of file Common.h.

---

The documentation for this class was generated from the following files:

• src/arch/x86/Common.h
• src/arch/x86/Common.cpp