Cothread.cpp

Go to the documentation of this file.

#include <libcommunism/Cothread.h>
 
#include "AllocImpl.h"
#include "CothreadImpl.h"
#include "CothreadPrivate.h"
 
#include <exception>
#include <iomanip>
#include <iostream>
 
namespace libcommunism::internal {
static void DefaultCothreadReturnedHandler(Cothread *);
}
 
using namespace libcommunism;
using namespace libcommunism::internal;
 
std::function<void(Cothread *)> internal::gReturnHandler{DefaultCothreadReturnedHandler};
 
thread_local Cothread *Cothread::gCurrent{nullptr};
 
 
 
static void libcommunism::internal::DefaultCothreadReturnedHandler(Cothread *thread) {
    std::cerr << "[libcommunism] Cothread $" << std::hex << thread << std::dec;
    if(thread) {
        const auto &label = thread->getLabel();
        if(!label.empty()) {
            std::cerr << " (" << thread->getLabel() << ")";
        } else {
            std::cerr << " (unnamed cothread)";
        }
    }
 
    std::cerr << " returned from entry point!" << std::endl;
    std::terminate();
}
 
Cothread::Cothread(const Entry &entry, const size_t stackSize) {
    this->impl = AllocImpl(this->implBuffer, this->implBufferUsed, entry, stackSize);
}
 
Cothread::Cothread(const Entry &entry, std::span<uintptr_t> stack) {
    this->impl = AllocImpl(this->implBuffer, this->implBufferUsed, entry, stack);
}
 
 
Cothread::~Cothread() {
    if(this->implBufferUsed) {
        reinterpret_cast<CothreadImpl *>(this->implBuffer.data())->~CothreadImpl();
    } else {
        delete this->impl;
    }
    this->impl = nullptr;
}
 
Cothread *Cothread::Current() {
    if(!gCurrent) {
        auto impl = AllocKernelThreadWrapper();
        if(!impl) {
            std::cerr << "failed to allocate kernel cothread wrapper!" << std::endl;
            std::terminate();
        }
 
        gCurrent = new Cothread(impl);
    }
    return gCurrent;
}
 
void Cothread::SetReturnHandler(const std::function<void (Cothread *)> &handler) {
    gReturnHandler = handler;
}
 
void Cothread::ResetReturnHandler() {
    gReturnHandler = DefaultCothreadReturnedHandler;
}
 
void Cothread::switchTo() {
    auto from = Current()->impl;
    gCurrent = this;
    this->impl->switchTo(from);
}
 
void *Cothread::getStack() const {
    return this->impl->getStack();
}
 
size_t Cothread::getStackSize() const {
    return this->impl->getStackSize();
}