libcommunism::internal::Amd64 Class Reference

Architecture specific methods for working with cothreads on amd64 based systems. More...

#include <Common.h>

Inheritance diagram for libcommunism::internal::Amd64:

Public Member Functions
	Amd64 (const Entry &entry, const size_t stackSize=0)
	Amd64 (const Entry &entry, std::span< uintptr_t > stack)
	Amd64 (std::span< uintptr_t > stack)
	~Amd64 ()
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 {6}
static constexpr const size_t	kMainStackSize {64}
static constexpr const size_t	kStackAlignment {64}
static constexpr const size_t	kDefaultStackSize {0x80000}

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 amd64 based systems.

Definition at line 16 of file Common.h.

Constructor & Destructor Documentation

Amd64() [1/3]

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

Allocates an amd64 thread, allocating its stack.

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 32 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);
}

Amd64() [2/3]

Amd64::Amd64	(	const Entry &	entry,
		std::span< uintptr_t >	_stack
	)

Allocates and amd64 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 56 of file Common.cpp.

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

Amd64() [3/3]

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

inline

Definition at line 31 of file Common.h.

: CothreadImpl(stack) {}

~Amd64()

Amd64::~Amd64

(

)

Release the stack if we allocated it.

Definition at line 64 of file Common.cpp.

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

Member Function Documentation

switchTo()

void Amd64::switchTo ( CothreadImpl *  from )

overridevirtual

Performs a context switch to the provided cothread.

The state of the caller is stored on the stack of the currently active thread.

Implements libcommunism::CothreadImpl.

Definition at line 75 of file Common.cpp.

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

Friends And Related Function Documentation

libcommunism::AllocKernelThreadWrapper

CothreadImpl* libcommunism::AllocKernelThreadWrapper ( )

friend

Member Data Documentation

kDefaultStackSize

constexpr const size_t libcommunism::internal::Amd64::kDefaultStackSize {0x80000}

staticconstexpr

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

Definition at line 143 of file Common.h.

kMainStackSize

constexpr const size_t libcommunism::internal::Amd64::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, as well as all of the SSE registers on Windows.

Definition at line 129 of file Common.h.

kNumSavedRegisters

const size_t Amd64::kNumSavedRegisters {6}

static

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

For System V ABI, the only saved registers are rbp, rbx, and r12-r15.

On Windows, we have to save integer registers RBX, RBP, RDI, RSI, and R12-R15. In addition, XMM6-XMM15 must be saved. Since the SSE registers are 128 bits vs. 64 bits for an integer register, we just count them twice.

Definition at line 120 of file Common.h.

kStackAlignment

constexpr const size_t libcommunism::internal::Amd64::kStackAlignment {64}

staticconstexpr

Requested alignment for stack allocations.

This is set to 64 bytes for cache line alignment. On amd64, the stack should always be at least 16 byte aligned (for SSE quantities).

Definition at line 137 of file Common.h.

---

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

• src/arch/amd64/Common.h
• src/arch/amd64/Common.cpp
• src/arch/amd64/SysV.cpp
• src/arch/amd64/Windows.cpp