project init

Author: ddeka0

ContextSwitch.S

@@ -0,0 +1,28 @@
+.globl ContextSwitch    // make the Symbol ContextSwitch available in link time
+ContextSwitch:
+
+        // According to x86_64 calling convention
+        // first argument to ContextSwitch is stored in %rdi
+        // second argument to ContextSwitch is stored in %rsi
+
+        // Therefore %rdi -> addrss of Main Conext struct
+        // Use Offset addressing to store each registers to Main Context
+        movq     %rsp, 0x00(%rdi)
+        movq     %r15, 0x08(%rdi)
+        movq     %r14, 0x10(%rdi)
+        movq     %r13, 0x18(%rdi)
+        movq     %r12, 0x20(%rdi)
+        movq     %rbp, 0x28(%rdi)
+        movq     %rbx, 0x30(%rdi)
+
+        // Therefore %rsi -> addrss of Child Conext struct
+        // Use Offset addressing to load each registers from Child Context
+        movq     0x00(%rsi), %rsp
+        movq     0x08(%rsi), %r15
+        movq     0x10(%rsi), %r14
+        movq     0x18(%rsi), %r13
+        movq     0x20(%rsi), %r12
+        movq     0x28(%rsi), %rbp
+        movq     0x30(%rsi), %rbx
+
+        ret      // rip is loaded with [rsp,rsp + 8]

config.hpp

@@ -0,0 +1,30 @@
+/**
+ * @file config.hpp
+ * @author d.deka (https://ddeka0.github.io/)
+ * @brief 
+ * @version 0.1
+ * @date 2021-02-14
+ * 
+ */
+#pragma once
+#include "threadCtx.hpp"
+
+#define N   2
+/**
+ * @brief 
+ *  Context Switch API
+ */
+extern "C" void ContextSwitch(RegisterContext* curr,RegisterContext* next);
+
+/**
+ * @brief 
+ * Each non user space thread has this variable to know 
+ * the current running thread context (user space or non user space)
+ */
+extern thread_local ThreadCtx* currContext[N];
+
+/**
+ * @brief 
+ * Limits the size of the user thread stack
+ */
+extern long long StackSize;

logger.hpp

@@ -0,0 +1,121 @@
+/**
+ * @file logger.hpp
+ * @author d.deka (https://ddeka0.github.io/)
+ * @brief 
+ * @version 0.1
+ * @date 2021-02-14
+ * 
+ */
+#pragma once
+#include <type_traits>
+#include <typeinfo>
+#ifndef _MSC_VER
+#   include <cxxabi.h>
+#endif
+#include <memory>
+#include <string>
+#include <cstdlib>
+#include <iostream>
+#include <utility>
+
+#if defined(_MSC_VER)
+#define PrintF   std::cout << __FUNCSIG__ <<" "<< __LINE__ << std::endl;
+#else
+#define PrintF   std::cout << __PRETTY_FUNCTION__<<" "<< __LINE__ << std::endl;
+#endif
+
+
+// https://stackoverflow.com/questions/29326460/how-to-make-a-variadic-macro-for-stdcout
+inline void Log(){
+    // std::cout is not thread safe
+    std::cout << std::endl;
+}
+
+template<typename First, typename ...Rest>
+void Log(First && first, Rest && ...rest) {
+    // std::cout is not thread safe
+    std::cout << std::forward<First>(first)<<" ";
+    Log(std::forward<Rest>(rest)...);
+}
+
+
+
+// C++ language standard detection
+#if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) \
+    || (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) 
+    
+    #include <string_view>
+    #include <type_traits>
+
+    template <class T> 
+    constexpr std::string_view type_name() {
+        using namespace std;
+    #ifdef __clang__
+        string_view p = __PRETTY_FUNCTION__;
+        return string_view(p.data() + 34, p.size() - 34 - 1);
+    #elif defined(__GNUC__)
+        string_view p = __PRETTY_FUNCTION__;
+    #  if __cplusplus < 201402
+        return string_view(p.data() + 36, p.size() - 36 - 1);
+    #  else
+        return string_view(p.data() + 49, p.find(';', 49) - 49);
+    #  endif
+    #elif defined(_MSC_VER)
+        string_view p = __FUNCSIG__;
+        return string_view(p.data() + 84, p.size() - 84 - 7);
+    #endif
+    }
+
+    template<typename T>
+    struct refType {
+        static constexpr std::string_view type = (std::is_lvalue_reference<T>::value) > 0 ? "lvalue":"ravlue";
+    };
+
+    #define getRefType(expr)    refType<decltype(expr)>::type
+
+    #define GetKeyTypeFromInternalLogic             std::string
+    #define GetValueTypeFromInternalLogic           int
+
+#else 
+
+
+template <class T>
+std::string
+type_name()
+{
+    typedef typename std::remove_reference<T>::type TR;
+    std::unique_ptr<char, void(*)(void*)> own
+           (
+#ifndef _MSC_VER
+                abi::__cxa_demangle(typeid(TR).name(), nullptr,
+                                           nullptr, nullptr),
+#else
+                nullptr,
+#endif
+                std::free
+           );
+    std::string r = own != nullptr ? own.get() : typeid(TR).name();
+    if (std::is_const<TR>::value)
+        r += " const";
+    if (std::is_volatile<TR>::value)
+        r += " volatile";
+    if (std::is_lvalue_reference<T>::value)
+        r += "&";
+    else if (std::is_rvalue_reference<T>::value)
+        r += "&&";
+    return r;
+}
+
+    template<typename T>
+    struct refType {
+        static constexpr const char* type = (std::is_lvalue_reference<T>::value) > 0 ? "lvalue":"ravlue";
+    };
+
+    #define getRefType(expr)    refType<decltype(expr)>::type
+
+    #define GetKeyTypeFromInternalLogic             std::string
+    #define GetValueTypeFromInternalLogic           int
+
+#endif
+
+#define BreakLine   std::cout << std::endl << std::endl;

main.cpp

@@ -0,0 +1,38 @@
+/**
+ * @file main.cpp
+ * @author d.deka (https://ddeka0.github.io/)
+ * @brief 
+ * @version 0.1
+ * @date 2021-02-14
+ * 
+ */
+
+#include <bits/stdc++.h>
+#include "task_system.hpp"
+#include "config.hpp"
+#include "logger.hpp"
+#include <chrono>
+
+thread_local ThreadCtx* currContext[N];
+long long StackSize = 0x400000;
+
+void func() {
+
+    Log("TID before yield = ",THIS_THREAD_ID);
+    
+    u_yield();
+
+    Log("TID After yield = ",THIS_THREAD_ID);
+
+    Log("Hello from func!");
+}
+
+int main(int argc,char *argv[]) {
+
+    task_system ts;
+
+    ts.submit(func);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(3000));   
+
+}

notification_queue.cpp

@@ -0,0 +1,53 @@
+/**
+ * @file notification_queue.cpp
+ * @author d.deka (https://ddeka0.github.io/)
+ * @brief 
+ * @version 0.1
+ * @date 2021-02-14
+ * 
+ */
+#include "notification_queue.hpp"
+#include "logger.hpp"
+
+/** done()
+ * @brief 
+ * Thread safe queue, where user threads are kept
+ */
+void notification_queue::done() {
+    {
+        lock_t lock{_mutex};
+        _done = true;
+    }
+    _ready.notify_all();
+}
+
+/**
+ * @brief  pop(ThreadCtx** x)
+ * 
+ * @param x 
+ * @return true 
+ * @return false 
+ */
+bool notification_queue::pop(ThreadCtx** x) {
+    lock_t lock{_mutex};
+    _ready.wait(lock,[this]() {
+        Log("Sleeping ....TID = ",THIS_THREAD_ID);
+        return !_q.empty() || _done;
+    });
+    if(_q.empty() || _done) {
+        return false;
+    }
+    *x = std::move(_q.front());
+    _q.pop_front();
+    return true;
+}
+
+/**
+ * @brief 
+ * 
+ * @return std::size_t 
+ */
+std::size_t notification_queue::get_size() {
+    lock_t lock{_mutex};
+    return _q.size();
+}

notification_queue.hpp

@@ -0,0 +1,44 @@
+/**
+ * @file notification_queue.hpp
+ * @author d.deka (https://ddeka0.github.io/)
+ * @brief 
+ * @version 0.1
+ * @date 2021-02-14
+ * 
+ */
+#pragma once
+#include <thread>
+#include <concepts>
+#include "threadCtx.hpp"
+#include <stdio.h>
+#include <deque>
+#include <condition_variable>
+
+/**
+ * @brief 
+ * Thread safe queue, where user threads are kept
+ */
+
+class notification_queue {
+private:
+	std::deque<ThreadCtx*> 				_q;
+	bool                                _done{false};
+	std::mutex                          _mutex;
+	std::condition_variable             _ready;
+	using lock_t = std::unique_lock<std::mutex>;
+	
+public:
+	void done();
+	bool pop(ThreadCtx** x);
+	// Test purpose ...
+	std::size_t get_size();
+
+	template<typename F>
+	void push(F&& f) {
+		{
+			lock_t lock{_mutex};
+			_q.emplace_back(std::forward<F>(f));
+		}
+		_ready.notify_one();
+	}
+};