Common.cpp

Go to the documentation of this file.

 
#include "Common.h"
#include "CothreadPrivate.h"
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <exception>
#include <functional>
#include <memory>
#include <stdexcept>
#include <thread>
 
using namespace libcommunism;
using namespace libcommunism::internal;
 
thread_local std::array<uintptr_t, Amd64::kMainStackSize> Amd64::gMainStack;
 
Amd64::Amd64(const Entry &entry, const size_t stackSize) : 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::Amd64(const Entry &entry, std::span<uintptr_t> _stack) : CothreadImpl(entry, _stack) {
    ValidateStackSize(_stack.size() * sizeof(uintptr_t));
    Prepare(this, entry);
}
 
Amd64::~Amd64() {
    if(this->ownsStack) {
        DeallocStack(this->stack.data());
    }
}
 
void Amd64::switchTo(CothreadImpl *from) {
    Switch(static_cast<Amd64 *>(from), this);
}
 
void Amd64::CothreadReturned() {
    gReturnHandler(Cothread::Current());
}
 
void Amd64::DereferenceCallInfo(CallInfo *info) {
    info->entry();
    delete info;
}
 
 
 
CothreadImpl *libcommunism::AllocKernelThreadWrapper() {
    return new Amd64(Amd64::gMainStack);
}