diff --git a/3rdparty/musl b/3rdparty/musl
index 9680582a..790bd394 160000
--- a/3rdparty/musl
+++ b/3rdparty/musl
@@ -1 +1 @@
-Subproject commit 9680582a257de9d20b94ee26ddf6f9dc10df948e
+Subproject commit 790bd3943e419933cf56366197b9f6668ae8c53e
diff --git a/Makefile.user b/Makefile.user
index bf438808..56127727 100644
--- a/Makefile.user
+++ b/Makefile.user
@@ -10,6 +10,7 @@ CPPFLAGS+= -DMLOG_PORTAL=FilterError
 CPPFLAGS+= -DMLOG_SCHED=FilterError
 CPPFLAGS+= -DMLOG_SYSCALL=FilterError
 CPPFLAGS+= -DMLOG_TASKLET=FilterError
+CPPFLAGS+= -DMLOG_PROCESSORMGMT=FilterWarning
 #CPPFLAGS+= -DTRACE
 #CPPFLAGS+= -DNDEBUG
 
diff --git a/kernel-amd64.config b/kernel-amd64.config
index 76a8bc4f..d311f6d9 100644
--- a/kernel-amd64.config
+++ b/kernel-amd64.config
@@ -19,6 +19,7 @@
       "plugin-rapl-driver-intel",
       "app-init-example",
       "test-synchronous-task",
+      "plugin-processor-allocator"
     ]
 
 [config.vars]
diff --git a/kernel/app/init-example/app/init.cc b/kernel/app/init-example/app/init.cc
index 5a009a4f..8b6045da 100644
--- a/kernel/app/init-example/app/init.cc
+++ b/kernel/app/init-example/app/init.cc
@@ -28,6 +28,7 @@
 #include "mythos/invocation.hh"
 #include "mythos/protocol/CpuDriverKNC.hh"
 #include "mythos/PciMsgQueueMPSC.hh"
+#include "mythos/InfoFrame.hh"
 #include "runtime/Portal.hh"
 #include "runtime/ExecutionContext.hh"
 #include "runtime/CapMap.hh"
@@ -36,6 +37,7 @@
 #include "runtime/PageMap.hh"
 #include "runtime/KernelMemory.hh"
 #include "runtime/SimpleCapAlloc.hh"
+#include "runtime/ProcessorAllocator.hh"
 #include "runtime/tls.hh"
 #include "runtime/mlog.hh"
 #include "runtime/InterruptControl.hh"
@@ -56,7 +58,7 @@
 #include <sys/time.h>
 
 
-mythos::InvocationBuf* msg_ptr asm("msg_ptr");
+mythos::InfoFrame* info_ptr asm("info_ptr");
 int main() asm("main");
 
 extern char process_test_image_start SYMBOL("process_test_image_start");
@@ -65,7 +67,7 @@ constexpr uint64_t stacksize = 4*4096;
 char initstack[stacksize];
 char* initstack_top = initstack+stacksize;
 
-mythos::Portal portal(mythos::init::PORTAL, msg_ptr);
+mythos::Portal portal(mythos::init::PORTAL, info_ptr->getInvocationBuf());
 mythos::CapMap myCS(mythos::init::CSPACE);
 mythos::PageMap myAS(mythos::init::PML4);
 mythos::KernelMemory kmem(mythos::init::KM);
@@ -73,6 +75,7 @@ mythos::KObject device_memory(mythos::init::DEVICE_MEM);
 mythos::SimpleCapAlloc< mythos::init::APP_CAP_START
   , mythos::init::SIZE-mythos::init::APP_CAP_START> capAlloc(myCS);
 mythos::RaplDriverIntel rapl(mythos::init::RAPL_DRIVER_INTEL);
+mythos::ProcessorAllocator pa(mythos::init::PROCESSOR_ALLOCATOR);
 
 char threadstack[stacksize];
 char* thread1stack_top = threadstack+stacksize/2;
@@ -103,7 +106,7 @@ void test_Portal()
   MLOG_ERROR(mlog::app, "test_Portal begin");
   mythos::PortalLock pl(portal); // future access will fail if the portal is in use already
   MLOG_INFO(mlog::app, "test_Portal: allocate portal");
-  uintptr_t vaddr = mythos::round_up(uintptr_t(msg_ptr) + 1,  mythos::align2M);
+  uintptr_t vaddr = mythos::round_up(info_ptr->getInfoEnd(),  mythos::align2M);
   // allocate a portal
   mythos::Portal p2(capAlloc(), (void*)vaddr);
   auto res1 = p2.create(pl, kmem).wait();
@@ -185,7 +188,9 @@ void test_tls()
   auto tls = mythos::setupNewTLS();
   MLOG_INFO(mlog::app, "test_EC: create ec1 TLS", DVARhex(tls));
   ASSERT(tls != nullptr);
-  auto res1 = ec1.create(kmem).as(myAS).cs(myCS).sched(mythos::init::SCHEDULERS_START + 1)
+  auto sc = pa.alloc(pl).wait();
+  TEST(sc);
+  auto res1 = ec1.create(kmem).as(myAS).cs(myCS).sched(sc->cap)
     .prepareStack(thread1stack_top).startFun(threadFun, nullptr)
     .suspended(false).fs(tls)
     .invokeVia(pl).wait();
@@ -193,6 +198,7 @@ void test_tls()
   TEST(ec1.setFSGS(pl,(uint64_t) tls, 0).wait());
   mythos::syscall_signal(ec1.cap());
   MLOG_INFO(mlog::app, "End test tls");
+  capAlloc.free(ec1.cap(), pl);
 }
 
 
@@ -201,7 +207,7 @@ void test_heap() {
   mythos::PortalLock pl(portal);
   auto size = 4*1024*1024; // 2 MB
   auto align = 2*1024*1024; // 2 MB
-  uintptr_t vaddr = mythos::round_up(uintptr_t(msg_ptr) + 1,  align);
+  uintptr_t vaddr = mythos::round_up(info_ptr->getInfoEnd() + align2M,  align2M);
   // allocate a 2MiB frame
   mythos::Frame f(capAlloc());
   auto res2 = f.create(pl, kmem, size, align).wait();
@@ -322,7 +328,9 @@ void test_ExecutionContext()
 
     auto tls1 = mythos::setupNewTLS();
     ASSERT(tls1 != nullptr);
-    auto res1 = ec1.create(kmem).as(myAS).cs(myCS).sched(mythos::init::SCHEDULERS_START)
+    auto sc1 = pa.alloc(pl).wait();
+    TEST(sc1);
+    auto res1 = ec1.create(kmem).as(myAS).cs(myCS).sched(sc1->cap)
     .prepareStack(thread1stack_top).startFun(&thread_main, nullptr)
     .suspended(false).fs(tls1)
     .invokeVia(pl).wait();
@@ -331,7 +339,9 @@ void test_ExecutionContext()
     MLOG_INFO(mlog::app, "test_EC: create ec2");
     auto tls2 = mythos::setupNewTLS();
     ASSERT(tls2 != nullptr);
-    auto res2 = ec2.create(kmem).as(myAS).cs(myCS).sched(mythos::init::SCHEDULERS_START+1)
+    auto sc2 = pa.alloc(pl).wait();
+    TEST(sc2);
+    auto res2 = ec2.create(kmem).as(myAS).cs(myCS).sched(sc2->cap)
     .prepareStack(thread2stack_top).startFun(&thread_main, nullptr)
     .suspended(false).fs(tls2)
     .invokeVia(pl).wait();
@@ -345,6 +355,11 @@ void test_ExecutionContext()
   MLOG_INFO(mlog::app, "sending notifications");
   mythos::syscall_signal(ec1.cap());
   mythos::syscall_signal(ec2.cap());
+  {
+    mythos::PortalLock pl(portal); 
+    TEST(capAlloc.free(ec1, pl));
+    TEST(capAlloc.free(ec2, pl));
+  }
   MLOG_INFO(mlog::app, "End Test ExecutionContext");
 }
 
@@ -357,7 +372,9 @@ void test_InterruptControl() {
   mythos::ExecutionContext ec(capAlloc());
   auto tls = mythos::setupNewTLS();
   ASSERT(tls != nullptr);
-  auto res1 = ec.create(kmem).as(myAS).cs(myCS).sched(mythos::init::SCHEDULERS_START + 2)
+  auto sc = pa.alloc(pl).wait();
+  TEST(sc);
+  auto res1 = ec.create(kmem).as(myAS).cs(myCS).sched(sc->cap)
     .prepareStack(thread3stack_top).startFun(&thread_main, nullptr)
     .suspended(false).fs(tls)
     .invokeVia(pl).wait();
@@ -480,21 +497,45 @@ void test_CgaScreen(){
   MLOG_INFO(mlog::app, "Test CGA finished");
 }
 
+void test_processor_allocator(){
+  MLOG_INFO(mlog::app, "Test processor allocator");
+  mythos::PortalLock pl(portal);
+  auto sc = pa.alloc(pl).wait();
+  TEST(sc);
+  auto res = pa.free(pl, sc->cap).wait();
+  TEST(res);
+  MLOG_INFO(mlog::app, "Test processor allocator finished");
+}
+
 void test_process(){
   MLOG_INFO(mlog::app, "Test process");
 
   mythos::PortalLock pl(portal);
+
   Process p(&process_test_image_start);
   p.createProcess(pl); 
 
   MLOG_INFO(mlog::app, "Test process finished");
 }
 
+void test_userMem(){
+  MLOG_INFO(mlog::app, "Test user memory");
+  auto ranges = &info_ptr->memRanges;
+
+  // All memory that exceeds kernel memory address range (4G) will be provided directly to user.
+  // Run mythos (qemu/IHK) with more than 4G of memory to get some output
+  for(auto& r : *ranges){
+    MLOG_INFO(mlog::app, "range", DMRANGE(r.getStart(), r.getSize()));
+  }
+
+  MLOG_INFO(mlog::app, "Test user memory finished");
+};
+
 int main()
 {
   char const str[] = "Hello world!";
   mythos::syscall_debug(str, sizeof(str)-1);
-  MLOG_ERROR(mlog::app, "application is starting :)", DVARhex(msg_ptr), DVARhex(initstack_top));
+  MLOG_ERROR(mlog::app, "application is starting :)", DVARhex(info_ptr), DVARhex(initstack_top));
 
   test_float();
   test_Example();
@@ -506,7 +547,9 @@ int main()
   //test_HostChannel(portal, 24*1024*1024, 2*1024*1024);
   test_ExecutionContext();
   test_pthreads();
-  //test_Rapl();
+  test_userMem();
+  test_Rapl();
+  test_processor_allocator();
   test_process();
   //test_CgaScreen();
 
diff --git a/kernel/app/process_test/process_test/process_test.cc b/kernel/app/process_test/process_test/process_test.cc
index 10a09766..1a23ffa0 100644
--- a/kernel/app/process_test/process_test/process_test.cc
+++ b/kernel/app/process_test/process_test/process_test.cc
@@ -26,6 +26,7 @@
 
 #include "mythos/init.hh"
 #include "mythos/invocation.hh"
+#include "mythos/InfoFrame.hh"
 #include "runtime/Portal.hh"
 #include "runtime/ExecutionContext.hh"
 #include "runtime/CapMap.hh"
@@ -34,6 +35,7 @@
 #include "runtime/PageMap.hh"
 #include "runtime/KernelMemory.hh"
 #include "runtime/SimpleCapAlloc.hh"
+#include "runtime/ProcessorAllocator.hh"
 #include "runtime/tls.hh"
 #include "runtime/mlog.hh"
 #include "runtime/InterruptControl.hh"
@@ -43,14 +45,14 @@
 #include "runtime/Mutex.hh"
 
 
-mythos::InvocationBuf* msg_ptr asm("msg_ptr");
+mythos::InfoFrame* info_ptr asm("info_ptr");
 int main() asm("main");
 
 constexpr uint64_t stacksize = 4*4096;
 char initstack[stacksize];
 char* initstack_top = initstack+stacksize;
 
-mythos::Portal portal(mythos::init::PORTAL, msg_ptr);
+mythos::Portal portal(mythos::init::PORTAL, info_ptr->getInvocationBuf());
 mythos::CapMap myCS(mythos::init::CSPACE);
 mythos::PageMap myAS(mythos::init::PML4);
 mythos::KernelMemory kmem(mythos::init::KM);
@@ -58,11 +60,13 @@ mythos::KObject device_memory(mythos::init::DEVICE_MEM);
 mythos::SimpleCapAlloc< mythos::init::APP_CAP_START
   , mythos::init::SIZE-mythos::init::APP_CAP_START> capAlloc(myCS);
 mythos::RaplDriverIntel rapl(mythos::init::RAPL_DRIVER_INTEL);
+mythos::ProcessorAllocator pa(mythos::init::PROCESSOR_ALLOCATOR);
 
 
 int main()
 {
   MLOG_ERROR(mlog::app, "New process started :)");
+  MLOG_INFO(mlog::app, "info frame", DVARhex(info_ptr), DVAR(info_ptr->getNumThreads()), DVAR(info_ptr->getPsPerTSC()));
 
   return 0;
 }
diff --git a/kernel/async/monitor-common/async/Place.hh b/kernel/async/monitor-common/async/Place.hh
index 571bbb8f..8b60fe9a 100644
--- a/kernel/async/monitor-common/async/Place.hh
+++ b/kernel/async/monitor-common/async/Place.hh
@@ -113,6 +113,8 @@ public:
   /** true if the hardware thread is currently in kernel mode and processing tasks. */
   bool isActive() const { return nestingMonitor.load(std::memory_order_relaxed); }
 
+  cpu::ThreadID getThreadID(){ return threadID; }
+
 protected:
   void pushPrivate(TaskletBase* msg) {
     ASSERT(isLocal());
diff --git a/kernel/boot/init-loader-amd64/boot/load_init.cc b/kernel/boot/init-loader-amd64/boot/load_init.cc
index 5e00f6f3..26c81c7a 100644
--- a/kernel/boot/init-loader-amd64/boot/load_init.cc
+++ b/kernel/boot/init-loader-amd64/boot/load_init.cc
@@ -44,11 +44,14 @@
 #include "boot/mlog.hh"
 #include "boot/memory-root.hh"
 #include "boot/DeployHWThread.hh"
+#include "mythos/InfoFrame.hh"
 
 
 namespace mythos {
     
 Event<boot::InitLoader&> event::initLoader;
+Event<boot::InitLoader&> event::initLoaderEarly;
+Event<InfoFrame*> event::initInfoFrame;
     
 namespace boot {
 
@@ -59,6 +62,9 @@ InitLoader::InitLoader(char* image)
   , capAlloc(init::CAP_ALLOC_START,
         init::CAP_ALLOC_END-init::CAP_ALLOC_START)
   , memMapper(&capAlloc, mythos::init::KM)
+  // default: no processor allocator present
+  , processorAllocatorPresent(false)
+  , initSC(init::SCHEDULERS_START)
 {
   MLOG_INFO(mlog::boot, "found init application image at", (void*)image);
 }
@@ -69,13 +75,17 @@ optional<void> InitLoader::load()
 {
   if (!_img.isValid()) RETURN(Error::GENERIC_ERROR);
 
+  event::initLoaderEarly.emit(*this);
+
   // order matters here
   optional<void> res(Error::SUCCESS);
   if (res) res = initCSpace();
   auto ipc_vaddr = loadImage();
   res = ipc_vaddr;
-  if (res) MLOG_INFO(mlog::boot, "init invokation buffer", DVARhex(*ipc_vaddr));
-  if (res) res = createPortal(*ipc_vaddr, init::PORTAL);
+  if (res) MLOG_INFO(mlog::boot, "init info frame/invokation buffer", DVARhex(*ipc_vaddr));
+  auto infoFramePtr = createInfoFrame(*ipc_vaddr);
+  res = infoFramePtr;
+  if (res) res = createPortal(*infoFramePtr, init::PORTAL);
   if (res) res = createEC(*ipc_vaddr);
   RETURN(res);
 }
@@ -157,12 +167,14 @@ optional<void> InitLoader::initCSpace()
     if (!res) RETHROW(res);
   }
 
-  ASSERT(cpu::getNumThreads() <= init::SCHEDULERS_START - init::APP_CAP_START);
-  MLOG_INFO(mlog::boot, "... create scheduling context caps in caps",
-        init::SCHEDULERS_START, "till", init::SCHEDULERS_START+cpu::getNumThreads()-1);
-  for (cpu::ThreadID id = 0; id < cpu::getNumThreads(); ++id) {
-    auto res = csSet(init::SCHEDULERS_START+id, boot::getScheduler(id));
-    if (!res) RETHROW(res);
+  if(!processorAllocatorPresent){
+    ASSERT(cpu::getNumThreads() <= init::SCHEDULERS_START - init::APP_CAP_START);
+    MLOG_INFO(mlog::boot, "... create scheduling context caps in caps",
+          init::SCHEDULERS_START, "till", init::SCHEDULERS_START+cpu::getNumThreads()-1);
+    for (cpu::ThreadID id = 0; id < cpu::getNumThreads(); ++id) {
+      auto res = csSet(init::SCHEDULERS_START+id, boot::getScheduler(id));
+      if (!res) RETHROW(res);
+    }
   }
 
   ASSERT(cpu::getNumThreads() <= init::INTERRUPT_CONTROL_START - init::APP_CAP_START);
@@ -178,20 +190,39 @@ optional<void> InitLoader::initCSpace()
   RETURN(Error::SUCCESS);
 }
 
+optional<CapPtr> InitLoader::createInfoFrame(uintptr_t ipc_vaddr)
+{
+    auto size = round_up(sizeof(InfoFrame), align2M);
+    MLOG_INFO(mlog::boot, "... create info frame");
+    auto frameCap = memMapper.createFrame(init::INFO_FRAME, size, align2M);
+    if (!frameCap) RETHROW(frameCap);
+    MLOG_INFO(mlog::boot, "... map info frame",
+        DVAR(*frameCap), DVARhex(ipc_vaddr));
+    memMapper.mmap(ipc_vaddr, size, true, false, *frameCap, 0);
+
+    auto frameEntry = capAlloc.get(*frameCap);
+    if (!frameEntry) RETHROW(frameEntry);
+    TypedCap<IFrame> frame(frameEntry);
+    if (!frame) RETHROW(frame);
+    auto info = new(reinterpret_cast<InfoFrame*>(frame.getFrameInfo().start.logint())) InfoFrame();
+    info->numThreads = cpu::getNumThreads();
+
+    //register user memory
+    info->memRanges = _mem->getUserMem();
+
+    event::initInfoFrame.emit(info);
+
+    return frameCap;
+}
 
-optional<void> InitLoader::createPortal(uintptr_t ipc_vaddr, CapPtr dstPortal)
+optional<void> InitLoader::createPortal(CapPtr infoFrame, CapPtr dstPortal)
 {
-    auto size = 2*1024*1024;
     MLOG_INFO(mlog::boot, "... create portal in cap", dstPortal);
     auto portal = create<Portal,PortalFactory>(capAlloc.get(dstPortal));
     if (!portal) RETHROW(portal);
 
-    auto frameCap = memMapper.createFrame(size, 2*1024*1024);
-    if (!frameCap) RETHROW(frameCap);
-    MLOG_INFO(mlog::boot, "... map invocation buffer",
-        DVAR(*frameCap), DVARhex(ipc_vaddr));
-    memMapper.mmap(ipc_vaddr, size, true, false, *frameCap, 0);
-    auto res = portal->setInvocationBuf(capAlloc.get(*frameCap), 0);
+    // ensure ib is the first member in InfoFrame -> frame offset == 0
+    auto res = portal->setInvocationBuf(capAlloc.get(infoFrame), 0);
     if (!res) RETHROW(res);
 
     _portal = *portal; // TODO return this?
@@ -281,7 +312,7 @@ optional<void> InitLoader::createEC(uintptr_t ipc_vaddr)
   optional<void> res(Error::SUCCESS);
   if (res) res = ec->setCapSpace(capAlloc.get(init::CSPACE));
   if (res) res = ec->setAddressSpace(capAlloc.get(init::PML4));
-  if (res) res = ec->setSchedulingContext(capAlloc.get(init::SCHEDULERS_START));
+  if (res) res = ec->setSchedulingContext(capAlloc.get(initSC));
   if (!res) RETHROW(res);
   ec->getThreadState().rdi = ipc_vaddr;
   ec->setEntryPoint(_img.header()->entry);
diff --git a/kernel/boot/init-loader-amd64/boot/load_init.hh b/kernel/boot/init-loader-amd64/boot/load_init.hh
index 7a0c489b..fa180f2f 100644
--- a/kernel/boot/init-loader-amd64/boot/load_init.hh
+++ b/kernel/boot/init-loader-amd64/boot/load_init.hh
@@ -32,6 +32,7 @@
 #include "objects/CapEntry.hh"
 #include "objects/IPageMap.hh"
 #include "util/events.hh"
+#include "mythos/InfoFrame.hh"
 #include "boot/MemMapper.hh"
 #include "boot/CapAlloc.hh"
 
@@ -55,9 +56,10 @@ namespace mythos {
       optional<void> load();
 
       optional<void> initCSpace();
-      optional<void> createPortal(uintptr_t ipc_vaddr, CapPtr dstPortal);
+      optional<void> createPortal(CapPtr infoFrame, CapPtr dstPortal);
       optional<uintptr_t> loadImage();
       optional<void> createEC(uintptr_t ipc_vaddr);
+      optional<CapPtr> createInfoFrame(uintptr_t ipc_vaddr);
 
       optional<void> loadProgramHeader(
         const elf64::PHeader* ph, CapPtr frameCap, size_t offset);
@@ -78,12 +80,18 @@ namespace mythos {
       MemMapper memMapper;
 
       Portal* _portal;
+
+      /* to be manipulated by optional processor allocator */
+      bool processorAllocatorPresent;
+      CapPtr initSC;
     };
 
   } // namespace boot
 
   namespace event {
     extern Event<boot::InitLoader&> initLoader;
+    extern Event<boot::InitLoader&> initLoaderEarly;
+    extern Event<InfoFrame*> initInfoFrame;
   }
 
 } // namespace mythos
diff --git a/kernel/boot/kernel-amd64-ihk/boot/ihk-entry.cc b/kernel/boot/kernel-amd64-ihk/boot/ihk-entry.cc
index a642ebf3..1a8a19bb 100644
--- a/kernel/boot/kernel-amd64-ihk/boot/ihk-entry.cc
+++ b/kernel/boot/kernel-amd64-ihk/boot/ihk-entry.cc
@@ -55,6 +55,7 @@
 #include "objects/InterruptControl.hh"
 #include "boot/memory-root.hh"
 #include "boot/load_init.hh"
+#include "mythos/InfoFrame.hh"
 
 #include "boot/ihk-entry.hh"
 
@@ -342,14 +343,23 @@ void _start_ihk_mythos_(
 
 class IhkInitLoaderPlugin
    : public EventHook<InitLoader&>
+   , public EventHook<InfoFrame*>
 {
 public:
-    IhkInitLoaderPlugin() { event::initLoader.add(this); }
+    IhkInitLoaderPlugin() { 
+      event::initLoader.add(this); 
+      event::initInfoFrame.add(this); 
+    }
+    
     void processEvent(InitLoader& /*loader*/) override {
       // map arbitrary memory into the init application:
       // virtual addr, size, writable, executable, physical address
       //loader.memMapper.mmapDevice(vaddr, size, true, false, physaddr);
     }
+
+    void processEvent(InfoFrame* infoFrame) override {
+      infoFrame->psPerTsc = boot_param->ns_per_tsc; 
+    }
 };
 
 IhkInitLoaderPlugin ihkinitloaderplugin;
diff --git a/kernel/mythos/infoFrame/mcconf.module b/kernel/mythos/infoFrame/mcconf.module
new file mode 100644
index 00000000..8868f017
--- /dev/null
+++ b/kernel/mythos/infoFrame/mcconf.module
@@ -0,0 +1,3 @@
+# -*- mode:toml; -*-
+[module.mythos-info-frame]
+    incfiles = [ "mythos/InfoFrame.hh" ]
diff --git a/kernel/mythos/infoFrame/mythos/InfoFrame.hh b/kernel/mythos/infoFrame/mythos/InfoFrame.hh
new file mode 100644
index 00000000..70dc72fa
--- /dev/null
+++ b/kernel/mythos/infoFrame/mythos/InfoFrame.hh
@@ -0,0 +1,55 @@
+/* -*- mode:C++; -*- */
+/* MIT License -- MyThOS: The Many-Threads Operating System
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Copyright 2020 Philipp Gypser, BTU Cottbus-Senftenberg
+ */
+#pragma once
+
+#include "mythos/InvocationBuf.hh"
+#include "util/RangeSet.hh"
+
+#define PS_PER_TSC_DEFAULT (0x180)
+
+namespace mythos {
+
+typedef RangeSet<uintptr_t, 30> umem_range_t;
+
+class InfoFrame{
+  public:
+    InfoFrame()
+      : psPerTsc(PS_PER_TSC_DEFAULT)
+      , numThreads(1)
+    {}
+
+    InvocationBuf* getInvocationBuf() {return &ib; }
+    uint64_t getPsPerTSC() { return psPerTsc; }
+    size_t getNumThreads() { return numThreads; }
+    uintptr_t getInfoEnd () { return reinterpret_cast<uintptr_t>(this) + sizeof(InfoFrame); }
+
+    InvocationBuf ib; // needs to be the first member (see Initloader::createPortal)
+    uint64_t psPerTsc; // picoseconds per time stamp counter
+    size_t numThreads; // number of hardware threads available in the system
+    umem_range_t memRanges; // memory ranges that exceed kernel memory space
+};
+
+} // namespace mythos
diff --git a/kernel/mythos/init/mythos/init.hh b/kernel/mythos/init/mythos/init.hh
index 06c56ffd..6da39c12 100644
--- a/kernel/mythos/init/mythos/init.hh
+++ b/kernel/mythos/init/mythos/init.hh
@@ -53,6 +53,8 @@ namespace init {
     SCHEDULERS_START,
     CPUDRIVER = SCHEDULERS_START+256,
     RAPL_DRIVER_INTEL,
+    PROCESSOR_ALLOCATOR,
+    INFO_FRAME,
     INTERRUPT_CONTROL_START,
     INTERRUPT_CONTROL_END = INTERRUPT_CONTROL_START+256,
     APP_CAP_START = 1024,
diff --git a/kernel/mythos/invocation/mythos/protocol/common.hh b/kernel/mythos/invocation/mythos/protocol/common.hh
index d20db802..2214f382 100644
--- a/kernel/mythos/invocation/mythos/protocol/common.hh
+++ b/kernel/mythos/invocation/mythos/protocol/common.hh
@@ -45,6 +45,7 @@ namespace mythos {
       EXAMPLE,
       CPUDRIVERKNC,
       RAPLDRIVERINTEL,
+      PROCESSORALLOCATOR,
       INTERRUPT_CONTROL,
     };
 
diff --git a/kernel/objects/capability-spinning/objects/RevokeOperation.hh b/kernel/objects/capability-spinning/objects/RevokeOperation.hh
index abbfe817..6ad3a33c 100644
--- a/kernel/objects/capability-spinning/objects/RevokeOperation.hh
+++ b/kernel/objects/capability-spinning/objects/RevokeOperation.hh
@@ -101,7 +101,7 @@ public:
   };
 
 private:
-
+  friend class ProcessorAllocator; //need to directly access _revoke in deallocation sequence (todo: do it better!)
   void _revoke(Tasklet* t, result_t* res, CapEntry& entry, IKernelObject* guarded);
   void _delete(Tasklet* t, result_t* res, CapEntry& entry, IKernelObject* guarded);
   void _deleteObject(Tasklet* t);
diff --git a/kernel/objects/common/objects/mlog.cc b/kernel/objects/common/objects/mlog.cc
index 215e56ac..8ff32955 100644
--- a/kernel/objects/common/objects/mlog.cc
+++ b/kernel/objects/common/objects/mlog.cc
@@ -33,4 +33,5 @@ namespace mlog {
   Logger<MLOG_EC> ec("ec");
   Logger<MLOG_KM> km("km");
   Logger<MLOG_IRQ> irq("irq");
+  Logger<MLOG_PROCESSORMGMT> pm("pm"); //processor management
 } // namespace mlog
diff --git a/kernel/objects/common/objects/mlog.hh b/kernel/objects/common/objects/mlog.hh
index c83f41ec..6545e605 100644
--- a/kernel/objects/common/objects/mlog.hh
+++ b/kernel/objects/common/objects/mlog.hh
@@ -59,4 +59,9 @@ namespace mlog {
 #endif
   extern Logger<MLOG_IRQ> irq;
 
+#ifndef MLOG_PM
+#define MLOG_PM FilterWarning
+#endif
+  extern Logger<MLOG_PROCESSORMGMT> pm; //processor management
+
 } // namespace mlog
diff --git a/kernel/objects/execution-context/objects/ExecutionContext.cc b/kernel/objects/execution-context/objects/ExecutionContext.cc
index 444e97a4..4f04b690 100644
--- a/kernel/objects/execution-context/objects/ExecutionContext.cc
+++ b/kernel/objects/execution-context/objects/ExecutionContext.cc
@@ -55,7 +55,7 @@ namespace mythos {
                 DVARhex(flags.load()), isReady());
     if (needPreemption(prev) && !isReady()) {
         auto place = currentPlace.load();
-        ASSERT(place != nullptr);
+        //ASSERT(place != nullptr);
         /// @todo is place->preempt() sufficient without waiting?
         if (place) synchronousAt(place) << [this]() {
             MLOG_DETAIL(mlog::ec, "suspended", DVAR(this));
@@ -597,6 +597,7 @@ namespace mythos {
             auto place = currentPlace.load();
             if (place) synchronousAt(place) << [this]() {
                 this->saveState();
+                this->_sched.reset();
                 MLOG_DETAIL(mlog::ec, "preempted and unloaded state", DVAR(this));
             };
             _as.reset();
diff --git a/kernel/objects/kernel-memory/objects/KernelMemory.cc b/kernel/objects/kernel-memory/objects/KernelMemory.cc
index 630448be..03ba3a54 100644
--- a/kernel/objects/kernel-memory/objects/KernelMemory.cc
+++ b/kernel/objects/kernel-memory/objects/KernelMemory.cc
@@ -100,13 +100,35 @@ void KernelMemory::free(MemoryDescriptor* begin, MemoryDescriptor* end)
 
 void KernelMemory::addRange(PhysPtr<void> start, size_t length)
 {
-  if (!start.kernelmem()) return;
-  Range<uintptr_t> add = Range<uintptr_t>::bySize(start.logint(), length);
-  Range<uintptr_t> own =
-    Range<uintptr_t>::bySize(PhysPtr<void>(_range.getStart()).logint(), _range.getSize());
-  add = add.cut(own);
-  if (add.isEmpty()) return;
-  heap.addRange(add.getStart(), add.getSize());
+  MLOG_INFO(mlog::km, "addRange: chunk = ", DVARhex(start.physint()), DVAR(length));
+  // if not in kernel memory address range put it to user mem 
+  if (!start.kernelmem()){
+    MLOG_INFO(mlog::km, "addRange: completely to user mem (physical)", DVARhex(start.physint()), DVAR(length));
+    Range<uintptr_t> umem = Range<uintptr_t>::bySize(start.physint(), length);
+    _umem.add(umem); 
+  }
+  // if it begins in kernel memory range split range according to kernel memory limit
+  else{
+    //logical address range for kmem
+    Range<uintptr_t> kmem = Range<uintptr_t>::bySize(start.logint(), length);
+    Range<uintptr_t> krange =
+      Range<uintptr_t>::bySize(PhysPtr<void>(_range.getStart()).logint(), _range.getSize());
+    kmem = kmem.cut(krange);
+    if (!kmem.isEmpty()){
+      MLOG_INFO(mlog::km, "addRange: to kernel mem (logical)", DVARhex(kmem.getStart()), DVAR(kmem.getSize()));
+      heap.addRange(kmem.getStart(), kmem.getSize());
+    }
+
+    //physical address range for umem
+    Range<uintptr_t> umem = Range<uintptr_t>::bySize(start.physint(), length);
+    Range<uintptr_t> urange =
+      Range<uintptr_t>::bySize(_range.getStart() + _range.getSize(), length);
+    umem = umem.cut(urange);
+    if (!umem.isEmpty()){
+      MLOG_INFO(mlog::km, "addRange: to user user mem (physical)", DVARhex(umem.getStart()), DVAR(umem.getSize()));
+      _umem.add(umem);
+    } 
+  }
 }
 
 
diff --git a/kernel/objects/kernel-memory/objects/KernelMemory.hh b/kernel/objects/kernel-memory/objects/KernelMemory.hh
index 092faae0..5fe2ff7f 100644
--- a/kernel/objects/kernel-memory/objects/KernelMemory.hh
+++ b/kernel/objects/kernel-memory/objects/KernelMemory.hh
@@ -35,6 +35,7 @@
 #include "objects/ops.hh"
 #include "objects/IFactory.hh"
 #include "mythos/protocol/KernelMemory.hh"
+#include "mythos/InfoFrame.hh"
 
 #include "async/mlog.hh"
 #include "objects/mlog.hh"
@@ -99,6 +100,10 @@ namespace mythos {
     void invoke(Tasklet*, Cap, IInvocation* msg) override;
     Error invokeCreate(Tasklet* t, Cap self, IInvocation* msg);
 
+    umem_range_t getUserMem(){
+      return _umem; 
+    }
+
   private:
     LinkedList<IKernelObject*>::Queueable del_handle = {this};
     IAsyncFree* _parent;
@@ -107,6 +112,7 @@ namespace mythos {
     /** for deletion: the managed range and then the own object */
     std::array<MemoryDescriptor, 2> _memory;
     async::NestedMonitorDelegating monitor;
+    umem_range_t _umem;
   };
 
 class KernelMemoryFactory : public FactoryBase
diff --git a/kernel/objects/processor-allocator/mcconf.module b/kernel/objects/processor-allocator/mcconf.module
new file mode 100644
index 00000000..634a47fb
--- /dev/null
+++ b/kernel/objects/processor-allocator/mcconf.module
@@ -0,0 +1,5 @@
+# -*- mode:toml; -*-
+[module.plugin-processor-allocator]
+    incfiles = [ "objects/PluginProcessorAllocator.hh", "objects/ProcessorAllocator.hh", "mythos/protocol/ProcessorAllocator.hh" ]
+    kernelfiles = [ "objects/ProcessorAllocator.cc", "objects/PluginProcessorAllocator.cc"]
+
diff --git a/kernel/objects/processor-allocator/mythos/protocol/ProcessorAllocator.hh b/kernel/objects/processor-allocator/mythos/protocol/ProcessorAllocator.hh
new file mode 100644
index 00000000..ab7a2571
--- /dev/null
+++ b/kernel/objects/processor-allocator/mythos/protocol/ProcessorAllocator.hh
@@ -0,0 +1,91 @@
+/* -*- mode:C++; indent-tabs-mode:nil; -*- */
+/* MIT License -- MyThOS: The Many-Threads Operating System
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Copyright 2020 Philipp Gypser and contributors, BTU Cottbus-Senftenberg
+ */
+#pragma once
+
+#include "mythos/protocol/common.hh"
+
+namespace mythos {
+  namespace protocol {
+
+    struct ProcessorAllocator {
+      constexpr static uint8_t proto = PROCESSORALLOCATOR;
+
+      enum Methods : uint8_t {
+        ALLOC,
+        RETALLOC,
+        FREE,
+        RETFREE
+      };
+
+      struct Alloc : public InvocationBase {
+        constexpr static uint16_t label = (proto<<8) + ALLOC;
+        Alloc(CapPtr dstMap = null_cap) : InvocationBase(label,getLength(this)) {
+          addExtraCap(dstMap);
+        }
+
+        // target cap map
+        CapPtr dstSpace() const { return this->capPtrs[0]; }
+      };
+
+      struct RetAlloc : public InvocationBase {
+        constexpr static uint16_t label = (proto<<8) + RETALLOC;
+        RetAlloc(CapPtr sc) : InvocationBase(label,getLength(this)) {
+          addExtraCap(sc);
+        }
+
+        // allocated scheduling context
+        CapPtr sc() const { return this->capPtrs[0]; }
+      };
+
+      struct Free : public InvocationBase {
+        constexpr static uint16_t label = (proto<<8) + FREE;
+        Free(CapPtr sc) : InvocationBase(label,getLength(this)) {
+          addExtraCap(sc);
+        }
+
+        // scheduling context to be freed
+        CapPtr sc() const { return this->capPtrs[0]; }
+      };
+
+      struct RetFree : public InvocationBase {
+        constexpr static uint16_t label = (proto<<8) + RETFREE;
+        RetFree() : InvocationBase(label,getLength(this)) {
+        }
+      };
+
+      template<class IMPL, class... ARGS>
+      static Error dispatchRequest(IMPL* obj, uint8_t m, ARGS const&...args) {
+        switch(Methods(m)) {
+          case ALLOC: return obj->invokeAlloc(args...);
+          case FREE: return obj->invokeFree(args...);
+          default: return Error::NOT_IMPLEMENTED;
+        }
+      }
+
+    };
+
+  }// namespace protocol
+}// namespace mythos
diff --git a/kernel/objects/processor-allocator/objects/PluginProcessorAllocator.cc b/kernel/objects/processor-allocator/objects/PluginProcessorAllocator.cc
new file mode 100644
index 00000000..02323d58
--- /dev/null
+++ b/kernel/objects/processor-allocator/objects/PluginProcessorAllocator.cc
@@ -0,0 +1,31 @@
+/* -*- mode:C++; indent-tabs-mode:nil; -*- */
+/* MIT License -- MyThOS: The Many-Threads Operating System
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Copyright 2020 Philipp Gypser and contributors, BTU Cottbus-Senftenberg
+ */
+
+#include "objects/PluginProcessorAllocator.hh"
+
+mythos::PluginProcessorAllocator pluginProcessorAllocator;
+mythos::PluginProcessorAllocatorActivator pluginProcessorAllocatorActivator;
+
diff --git a/kernel/objects/processor-allocator/objects/PluginProcessorAllocator.hh b/kernel/objects/processor-allocator/objects/PluginProcessorAllocator.hh
new file mode 100644
index 00000000..1d0e6bbe
--- /dev/null
+++ b/kernel/objects/processor-allocator/objects/PluginProcessorAllocator.hh
@@ -0,0 +1,80 @@
+/* -*- mode:C++; indent-tabs-mode:nil; -*- */
+/* MIT License -- MyThOS: The Many-Threads Operating System
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Copyright 2020 Philipp Gypser and contributors, BTU Cottbus-Senftenberg
+ */
+#pragma once
+
+#include "objects/ProcessorAllocator.hh"
+#include "util/events.hh"
+#include "boot/load_init.hh"
+#include "mythos/init.hh"
+#include "boot/mlog.hh"
+#include "util/assert.hh"
+
+namespace mythos {
+  class PluginProcessorAllocatorActivator
+    : public EventHook<boot::InitLoader&>
+  {
+  public:
+    PluginProcessorAllocatorActivator() {
+      event::initLoaderEarly.add(this);
+    }
+    virtual ~PluginProcessorAllocatorActivator() {}
+
+    void processEvent(boot::InitLoader& loader) override {
+      MLOG_DETAIL(mlog::pm, "prevent mapping of all scheduling contexts into CSpace");
+      loader.processorAllocatorPresent = true;
+    }
+  };
+
+  class PluginProcessorAllocator
+    : public EventHook<boot::InitLoader&>
+  {
+  public:
+    PluginProcessorAllocator() {
+      event::initLoader.add(this);
+    }
+    virtual ~PluginProcessorAllocator() {}
+
+    void processEvent(boot::InitLoader& loader) override {
+      MLOG_DETAIL(mlog::pm, "Init processor allocator");
+      pa.init();
+      MLOG_DETAIL(mlog::pm, "CSset processor allocator");
+      OOPS(loader.csSet(init::PROCESSOR_ALLOCATOR, pa));
+      auto sc = pa.alloc();
+      ASSERT(sc); 
+      MLOG_DETAIL(mlog::pm, "allocated SC for init app", DVAR(init::SCHEDULERS_START+*sc));
+      loader.initSC = init::SCHEDULERS_START+*sc;
+      MLOG_DETAIL(mlog::pm, "map SC for init app");
+      loader.csSet(init::SCHEDULERS_START+*sc, boot::getScheduler(*sc));
+
+    }
+
+    LiFoProcessorAllocator pa;
+  };
+
+} // namespace mythos
+
+extern mythos::PluginProcessorAllocator pluginProcessorAllocator;
+extern mythos::PluginProcessorAllocatorActivator pluginProcessorAllocatorActivator;
diff --git a/kernel/objects/processor-allocator/objects/ProcessorAllocator.cc b/kernel/objects/processor-allocator/objects/ProcessorAllocator.cc
new file mode 100644
index 00000000..b0e437f5
--- /dev/null
+++ b/kernel/objects/processor-allocator/objects/ProcessorAllocator.cc
@@ -0,0 +1,181 @@
+/* -*- mode:C++; indent-tabs-mode:nil; -*- */
+/* MIT License -- MyThOS: The Many-Threads Operating System
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Copyright 2020 Philipp Gypser and contributors, BTU Cottbus-Senftenberg
+ */
+
+
+#include "objects/ProcessorAllocator.hh"
+#include "objects/mlog.hh"
+
+namespace mythos {
+
+/* IKernelObject */ 
+  optional<void> ProcessorAllocator::deleteCap(CapEntry&, Cap, IDeleter&)
+  {
+    MLOG_DETAIL(mlog::pm, __func__);
+    RETURN(Error::SUCCESS);
+  }
+
+  void ProcessorAllocator::deleteObject(Tasklet*, IResult<void>*)
+  {
+    MLOG_DETAIL(mlog::pm, __func__);
+  }
+
+  void ProcessorAllocator::invoke(Tasklet* t, Cap self, IInvocation* msg)
+  {
+    MLOG_DETAIL(mlog::pm, __func__, DVAR(t), DVAR(msg));
+    monitor.request(t, [=](Tasklet* t){
+        Error err = Error::NOT_IMPLEMENTED;
+        switch (msg->getProtocol()) {
+        //case protocol::KernelObject::proto:
+          //err = protocol::KernelObject::dispatchRequest(this, msg->getMethod(), self, msg);
+          //break;
+        case protocol::ProcessorAllocator::proto:
+          err = protocol::ProcessorAllocator::dispatchRequest(this, msg->getMethod(), t, self, msg);
+          break;
+        }
+        if (err != Error::INHIBIT) {
+          msg->replyResponse(err);
+          monitor.requestDone();
+        }
+      } );
+  }
+
+/* IResult<void> */
+  void ProcessorAllocator::response(Tasklet* /*t*/, optional<void> res){
+    MLOG_DETAIL(mlog::pm, "revoke response:", res.state());
+  }
+
+/* ProcessorAllocator */
+  ProcessorAllocator::ProcessorAllocator()
+      : sc(image2kernel(&mySC[0]))
+    {}
+
+  void ProcessorAllocator::init(){
+    MLOG_DETAIL(mlog::pm, "PM::init");
+    for (cpu::ThreadID id = 0; id < cpu::getNumThreads(); ++id) {
+      sc[id].initRoot(Cap(image2kernel(&boot::getScheduler(id))));
+      free(id);
+    }
+  }
+
+  Error ProcessorAllocator::invokeAlloc(Tasklet*, Cap, IInvocation* msg){
+    MLOG_DETAIL(mlog::pm, __func__);
+    auto id = alloc();
+
+    if(id){
+      MLOG_DETAIL(mlog::pm, "allocated ", DVAR(*id));
+
+      auto data = msg->getMessage()->read<protocol::ProcessorAllocator::Alloc>();
+
+      optional<CapEntry*> dstEntry;
+      if(data.dstSpace() == null_cap){ // direct access
+        //dstEntry = msg->lookupEntry(data.dstPtr, 32, true); // lookup for write access
+        dstEntry = msg->lookupEntry(init::SCHEDULERS_START+*id, 32, true); // lookup for write access
+        if (!dstEntry){ 
+          MLOG_WARN(mlog::pm, "Warning: cannot find dstEntry!");
+          free(*id);
+          return dstEntry.state();
+        }
+      
+      }else{ // indirect access
+        TypedCap<ICapMap> dstSpace(msg->lookupEntry(data.dstSpace()));
+        if (!dstSpace){ 
+          MLOG_WARN(mlog::pm, "Warning: cannot find dstSpace!");
+          free(*id);
+          return dstSpace.state();
+        }
+
+        //auto dstEntryRef = dstSpace.lookup(data.dstPtr, data.dstDepth, true); // lookup for write
+        auto dstEntryRef = dstSpace.lookup(init::SCHEDULERS_START+*id, 32, true); // lookup for write
+        if (!dstEntryRef){ 
+          MLOG_WARN(mlog::pm, "Warning: cannot find dstEntryRef!");
+          free(*id);
+          return dstEntryRef.state();
+        }
+
+        dstEntry = dstEntryRef->entry;
+      }
+
+      auto res = cap::reference(sc[*id], **dstEntry, sc[*id].cap());
+      if(res){
+        msg->getMessage()->write<protocol::ProcessorAllocator::RetAlloc>(init::SCHEDULERS_START+*id);
+        MLOG_DETAIL(mlog::pm, "map new sc ", DVAR(*id));
+      }else{
+        MLOG_WARN(mlog::pm, "Warning: cannot create SC entry!");
+        free(*id);
+        msg->getMessage()->write<protocol::ProcessorAllocator::RetAlloc>(null_cap);
+      }
+
+    }else{
+      MLOG_WARN(mlog::pm, "allocation failed: no free cores available!");
+      msg->getMessage()->write<protocol::ProcessorAllocator::RetAlloc>(null_cap);
+    }
+    return Error::SUCCESS;
+  }
+
+  Error ProcessorAllocator::invokeFree(Tasklet* /*t*/, Cap, IInvocation* /*msg*/){
+    MLOG_ERROR(mlog::pm, __func__, ": NYI!");  
+    //auto data = msg->getMessage()->cast<protocol::ProcessorAllocator::Free>();
+    //ASSERT(data->sc() >= init::SCHEDULERS_START);
+    //cpu::ThreadID id = data->sc() - init::SCHEDULERS_START;
+    //ASSERT(id < cpu::getNumThreads());
+    //MLOG_ERROR(mlog::pm, "free SC", DVAR(data->sc()), DVAR(id));
+    //revokeOp._revoke(t, this, sc[id], this);
+    //MLOG_ERROR(mlog::pm, "free", DVAR(data->sc()), DVAR(id));
+    //free(id);
+    //return Error::SUCCESS;
+    return Error::NOT_IMPLEMENTED;
+  }
+
+  void ProcessorAllocator::freeSC(Tasklet* t, cpu::ThreadID id){
+    MLOG_DETAIL(mlog::pm, "freeSC", DVAR(id));
+    monitor.request(t, [=](Tasklet* t){
+      MLOG_DETAIL(mlog::pm, "monitor free", DVAR(id));
+      //todo: use IResult to call free(id) after cap is revoked
+      revokeOp._revoke(t, this, sc[id], this);
+      free(id);
+    }
+    );
+  }
+
+/* LiFoProcessorAllocator */
+  LiFoProcessorAllocator::LiFoProcessorAllocator()
+      : nFree(0)
+    {}
+
+  optional<cpu::ThreadID> LiFoProcessorAllocator::alloc(){
+    optional<cpu::ThreadID> ret;
+    if(nFree > 0){
+      nFree--;
+      ret = freeList[nFree];
+    }
+    return ret;
+  }
+
+  void LiFoProcessorAllocator::free(cpu::ThreadID id) {
+      freeList[nFree] = id;
+      nFree++;
+  }
+} // namespace mythos
diff --git a/kernel/objects/processor-allocator/objects/ProcessorAllocator.hh b/kernel/objects/processor-allocator/objects/ProcessorAllocator.hh
new file mode 100644
index 00000000..d3fad13a
--- /dev/null
+++ b/kernel/objects/processor-allocator/objects/ProcessorAllocator.hh
@@ -0,0 +1,86 @@
+/* -*- mode:C++; indent-tabs-mode:nil; -*- */
+/* MIT License -- MyThOS: The Many-Threads Operating System
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Copyright 2020 Philipp Gypser and contributors, BTU Cottbus-Senftenberg
+ */
+#pragma once
+
+#include "async/NestedMonitorDelegating.hh"
+#include "objects/IFactory.hh"
+#include "objects/IKernelObject.hh"
+#include "cpu/hwthreadid.hh"
+#include "mythos/protocol/ProcessorAllocator.hh"
+#include "boot/mlog.hh"
+#include "objects/RevokeOperation.hh"
+#include "async/IResult.hh"
+
+namespace mythos {
+
+class ProcessorAllocator
+  : public IKernelObject
+  , public IResult<void>
+{
+  public:
+    ProcessorAllocator();
+
+  /* IKernelObject */
+    optional<void> deleteCap(CapEntry&, Cap self, IDeleter& del) override;
+    void deleteObject(Tasklet* t, IResult<void>* r) override;
+    void invoke(Tasklet* t, Cap self, IInvocation* msg) override;
+
+  /* IResult<void> */
+    void response(Tasklet* /*t*/, optional<void> res) override;
+
+    void init();
+    Error invokeAlloc(Tasklet*, Cap, IInvocation* msg);
+    Error invokeFree(Tasklet* t, Cap, IInvocation* msg);
+    void freeSC(Tasklet* t, cpu::ThreadID id);
+
+  protected:
+    friend class PluginProcessorAllocator;
+    virtual optional<cpu::ThreadID> alloc() = 0;
+    virtual void free(cpu::ThreadID id) = 0;
+    virtual unsigned numFree() = 0;
+
+  private:
+    async::NestedMonitorDelegating monitor;
+    RevokeOperation revokeOp = {monitor};
+    CapEntry *sc;
+    CapEntry mySC[MYTHOS_MAX_THREADS];
+};
+
+class LiFoProcessorAllocator : public ProcessorAllocator
+{
+  public:
+    LiFoProcessorAllocator();
+
+    unsigned numFree() override { return nFree; }
+    optional<cpu::ThreadID> alloc() override; 
+    void free(cpu::ThreadID id) override;
+
+  private:
+    unsigned nFree;
+    cpu::ThreadID freeList[MYTHOS_MAX_THREADS];
+};
+
+} // namespace mythos
diff --git a/kernel/objects/scheduling-context/objects/SchedulingContext.cc b/kernel/objects/scheduling-context/objects/SchedulingContext.cc
index 7bedf186..8835a3d5 100644
--- a/kernel/objects/scheduling-context/objects/SchedulingContext.cc
+++ b/kernel/objects/scheduling-context/objects/SchedulingContext.cc
@@ -41,9 +41,15 @@ namespace mythos {
     void SchedulingContext::unbind(handle_t* ec)
     {
         ASSERT(ec != nullptr);
-        MLOG_DETAIL(mlog::sched, "unbind", DVAR(ec->get()));
+        MLOG_INFO(mlog::sched, "unbind", DVAR(ec->get()));
         readyQueue.remove(ec);
         current_handle.store(nullptr);
+        if(readyQueue.empty()){
+          MLOG_DETAIL(mlog::sched, "call freeSC");
+          pluginProcessorAllocator.pa.freeSC(&paTask, home->getThreadID());
+        }else{
+          MLOG_INFO(mlog::sched, "ready queue not empty!");
+        }   
     }
 
     void SchedulingContext::ready(handle_t* ec)
diff --git a/kernel/objects/scheduling-context/objects/SchedulingContext.hh b/kernel/objects/scheduling-context/objects/SchedulingContext.hh
index e1ca8d9f..c9362fdb 100644
--- a/kernel/objects/scheduling-context/objects/SchedulingContext.hh
+++ b/kernel/objects/scheduling-context/objects/SchedulingContext.hh
@@ -97,6 +97,8 @@ namespace mythos {
     async::Place* home = nullptr;
     list_t readyQueue; //< the ready list of waiting execution contexts
     std::atomic<handle_t*> current_handle = {nullptr}; //< the currently selected execution context
+
+    Tasklet paTask; //task for communication with processor allocator
   };
 
 } // namespace mythos
diff --git a/kernel/runtime/crt-init/runtime/start.S b/kernel/runtime/crt-init/runtime/start.S
index 712e1fd7..60705ee9 100644
--- a/kernel/runtime/crt-init/runtime/start.S
+++ b/kernel/runtime/crt-init/runtime/start.S
@@ -26,7 +26,7 @@
 
 .extern initstack_top
 .extern start_c
-.extern msg_ptr
+.extern info_ptr
 .extern __libc_init_array
 .extern exit
 
@@ -35,7 +35,7 @@
 _start:
         mov initstack_top, %rsp
         xor %rbp, %rbp
-        mov %rdi, msg_ptr       /* store first argument to global variable */
+        mov %rdi, info_ptr       /* store first argument to global variable */
         call start_c
 1:      jmp 1b                  /* should never return from start_c anyway */
 
diff --git a/kernel/runtime/cxx/runtime/cxxsupport.cc b/kernel/runtime/cxx/runtime/cxxsupport.cc
index a4df70b7..32d6e123 100644
--- a/kernel/runtime/cxx/runtime/cxxsupport.cc
+++ b/kernel/runtime/cxx/runtime/cxxsupport.cc
@@ -49,23 +49,60 @@
 #include "runtime/PageMap.hh"
 #include "runtime/KernelMemory.hh"
 #include "runtime/SimpleCapAlloc.hh"
+#include "runtime/ProcessorAllocator.hh"
 #include "runtime/tls.hh"
 #include "runtime/futex.hh"
 #include "runtime/umem.hh"
+#include "runtime/thread-extra.hh"
+#include "mythos/InfoFrame.hh"
 
-extern mythos::InvocationBuf* msg_ptr asm("msg_ptr");
+extern mythos::InfoFrame* info_ptr asm("info_ptr");
 extern mythos::Portal portal;
 extern mythos::CapMap myCS;
 extern mythos::PageMap myAS;
 extern mythos::KernelMemory kmem;
 extern mythos::SimpleCapAlloc< mythos::init::APP_CAP_START
   , mythos::init::SIZE-mythos::init::APP_CAP_START> capAlloc;
+extern mythos::ProcessorAllocator pa;
 
-#ifndef NUM_CPUS
-#define NUM_CPUS (2)
-#endif
+struct PthreadCleanerSemaphore{
+  PthreadCleanerSemaphore()
+    : flag(FREE)
+  {
+    //MLOG_ERROR(mlog::app, "PthreadCleaner");
+  }
 
-#define PS_PER_TSC (0x0000000000000181)
+  enum state{
+    UNKNOWN = 0,
+    FREE = 1,
+    EXITED = 2
+  };
+
+  void exit(){
+    //MLOG_DETAIL(mlog::app, "PthreadCleaner exit", DVARhex(this), DVARhex(pthread_self()));
+    auto ec = flag.exchange(EXITED);
+    if(ec != FREE){
+      ASSERT(ec!=UNKNOWN);
+      mythos::syscall_signal(ec);
+    }
+  }
+
+  void wait(pthread_t t){
+    auto pcs = reinterpret_cast<PthreadCleanerSemaphore* >(t - (pthread_self() - reinterpret_cast<uintptr_t>(this)));
+    //MLOG_DETAIL(mlog::app, "PthreadCleaner wait", DVARhex(pcs), DVARhex(this), DVARhex(pthread_self()), DVARhex(t));
+    while(pcs->flag.load() != EXITED){
+      mythos::CapPtr exp = FREE;
+      if(pcs->flag.compare_exchange_weak(exp, mythos_get_pthread_ec_self())){
+        //MLOG_DETAIL(mlog::app, "PthreadCleaner going to wait");
+        mythos_wait();
+      }
+    }
+  }
+  
+  std::atomic<mythos::CapPtr> flag;
+};
+
+static thread_local PthreadCleanerSemaphore pthreadCleanerSemphore;
 
 extern "C" [[noreturn]] void __assert_fail (const char *expr, const char *file, int line, const char *func)
 {
@@ -106,7 +143,7 @@ int prlimit(
 int sched_setaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask)
 {
     //MLOG_DETAIL(mlog::app, "syscall sched_setaffinity", DVAR(pid), DVAR(cpusetsize), DVARhex(mask));
-    if(cpusetsize == NUM_CPUS && mask == NULL) return -EFAULT;
+    if(cpusetsize == info_ptr->getNumThreads() && mask == NULL) return -EFAULT;
     return 0;
 }
 
@@ -116,9 +153,9 @@ int sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask)
     if (mask) {
         //CPU_ZERO(mask);
 	memset(mask, 0, cpusetsize);
-        for(int i = 0; i < NUM_CPUS; i++) CPU_SET(i, mask);
+        for(int i = 0; i < info_ptr->getNumThreads(); i++) CPU_SET(i, mask);
     }
-    return NUM_CPUS;
+    return info_ptr->getNumThreads();
 }
 
 void clock_gettime(long clk, struct timespec *ts){
@@ -126,8 +163,8 @@ void clock_gettime(long clk, struct timespec *ts){
     asm volatile("rdtsc" : "=a" (low), "=d" (high));
     unsigned long tsc = low | uint64_t(high) << 32;	
         //MLOG_DETAIL(mlog::app, "syscall clock_gettime", DVAR(clk), DVARhex(ts), DVAR(tsc), DVAR((tsc * PS_PER_TSC)/1000000000000));
-    ts->tv_nsec = (tsc * PS_PER_TSC / 1000)%1000000000;
-    ts->tv_sec = (tsc * PS_PER_TSC)/1000000000000;
+    ts->tv_nsec = (tsc * info_ptr->getPsPerTSC() / 1000)%1000000000;
+    ts->tv_sec = (tsc * info_ptr->getPsPerTSC())/1000000000000;
 }
 
 extern "C" long mythos_musl_syscall(
@@ -173,7 +210,8 @@ extern "C" long mythos_musl_syscall(
         MLOG_WARN(mlog::app, "syscall getpid NYI");
         return 0;
     case 60: // exit(exit_code)
-        //MLOG_DETAIL(mlog::app, "syscall exit", DVAR(a1));
+        //MLOG_ERROR(mlog::app, "syscall exit", DVAR(a1));
+        pthreadCleanerSemphore.exit();        
         asm volatile ("syscall" : : "D"(0), "S"(a1) : "memory");
         return 0;
     case 186: // gettid
@@ -245,7 +283,8 @@ extern "C" int munmap(void *start, size_t len)
 extern "C" int unmapself(void *start, size_t len)
 {
     // dummy implementation
-    MLOG_DETAIL(mlog::app, "unmapself");
+    MLOG_ERROR(mlog::app, "unmapself: NYI!");
+    ASSERT(0);
     while(1);
     return 0;
 }
@@ -266,7 +305,6 @@ int myclone(
 {
     //MLOG_DETAIL(mlog::app, "myclone");
     ASSERT(tls != nullptr);
-    static int nextThread = 1;
 
     // The compiler expect a kinda strange alignment coming from clone:
     // -> rsp % 16 must be 8
@@ -278,15 +316,19 @@ int myclone(
     mythos::ExecutionContext ec(capAlloc());
     if (ptid && (flags&CLONE_PARENT_SETTID)) *ptid = int(ec.cap());
     // @todo store thread-specific ctid pointer, which should set to 0 by the OS on the thread's exit
-    // @todo needs interaction with a process internal scheduler or core manager in order to figure out where to schedule the new thread
+
+    auto sc = pa.alloc(pl).wait();
+    ASSERT(sc);
+    if(sc->cap == mythos::null_cap){
+      MLOG_WARN(mlog::app, "Processor allocation failed!");
+      //todo: set errno = EAGAIN
+      return (-1);
+    }
+
     auto res1 = ec.create(kmem)
       .as(myAS)
       .cs(myCS)
-    // WARNING: This will lead to trouble if nextThread >= number of threads.
-    // It's also not thread safe.
-    // @TODO: More sensible thread placement.
-      .sched(mythos::init::SCHEDULERS_START + (nextThread++))
-    //                                         ^^^^^^^^^^^^
+      .sched(sc->cap)
       .rawStack(rsp)
       .rawFun(func, arg)
       .suspended(false)
@@ -309,6 +351,14 @@ extern "C" int clone(int (*func)(void *), void *stack, int flags, void *arg, ...
     return myclone(func, stack, flags, arg, ptid, tls, ctid);
 }
 
+extern "C" void mythos_pthread_cleanup(pthread_t t){
+    MLOG_DETAIL(mlog::app, "mythos_pthread_cleanup", mythos_get_pthread_ec(t));
+    pthreadCleanerSemphore.wait(t);
+    auto cap = mythos_get_pthread_ec(t);
+    mythos::PortalLock pl(portal); 
+    capAlloc.free(cap, pl);
+}
+
 struct dl_phdr_info
 {
     void* dlpi_addr; /* Base address of object */
diff --git a/kernel/runtime/kobject/mcconf.module b/kernel/runtime/kobject/mcconf.module
index 458ad07d..2e50bece 100644
--- a/kernel/runtime/kobject/mcconf.module
+++ b/kernel/runtime/kobject/mcconf.module
@@ -9,5 +9,6 @@ incfiles = [
   "runtime/KernelMemory.hh",
   "runtime/SimpleCapAlloc.hh",
   "runtime/InterruptControl.hh",
-  "runtime/RaplDriverIntel.hh"
+  "runtime/RaplDriverIntel.hh",
+  "runtime/ProcessorAllocator.hh"
   ]
diff --git a/kernel/runtime/kobject/runtime/ProcessorAllocator.hh b/kernel/runtime/kobject/runtime/ProcessorAllocator.hh
new file mode 100644
index 00000000..5f50e11b
--- /dev/null
+++ b/kernel/runtime/kobject/runtime/ProcessorAllocator.hh
@@ -0,0 +1,65 @@
+/* -*- mode:C++; indent-tabs-mode:nil; -*- */
+/* MIT License -- MyThOS: The Many-Threads Operating System
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Copyright 2020 Philipp Gypser and contributors, BTU Cottbus-Senftenberg
+ */
+#pragma once
+
+#include "runtime/PortalBase.hh"
+#include "mythos/protocol/ProcessorAllocator.hh"
+#include "mythos/init.hh"
+
+namespace mythos {
+
+  class ProcessorAllocator : public KObject
+  {
+  public:
+
+    ProcessorAllocator() {}
+    ProcessorAllocator(CapPtr cap) : KObject(cap) {}
+
+    struct AllocResult{
+      AllocResult() {}
+      AllocResult(InvocationBuf* ib) {
+        auto msg = ib->cast<protocol::ProcessorAllocator::RetAlloc>();
+        cap = msg->sc();
+      }
+     
+      CapPtr cap = null_cap;
+    };
+
+    PortalFuture<AllocResult> alloc(PortalLock pr){
+      return pr.invoke<protocol::ProcessorAllocator::Alloc>(_cap);
+    }
+
+    PortalFuture<AllocResult> alloc(PortalLock pr, CapPtr dstMap){
+      return pr.invoke<protocol::ProcessorAllocator::Alloc>(_cap, dstMap);
+    }
+
+    PortalFuture<void> free(PortalLock pr, CapPtr sc){
+      return pr.invoke<protocol::ProcessorAllocator::Free>(_cap, sc);
+    }
+
+  };
+
+} // namespace mythos
diff --git a/kernel/runtime/memory/runtime/tls.cc b/kernel/runtime/memory/runtime/tls.cc
index 11bbd725..fb66367b 100644
--- a/kernel/runtime/memory/runtime/tls.cc
+++ b/kernel/runtime/memory/runtime/tls.cc
@@ -7,6 +7,7 @@
 #include "mythos/init.hh"
 #include "mythos/protocol/ExecutionContext.hh"
 #include "mythos/syscall.hh"
+#include "mythos/InfoFrame.hh"
 #include "mythos/Error.hh"
 
 extern char __executable_start; //< provided by the default linker script
@@ -46,7 +47,7 @@ mythos::elf64::PHeader const* findTLSHeader() {
     return nullptr;
 }
 
-extern mythos::InvocationBuf* msg_ptr asm("msg_ptr");
+extern mythos::InfoFrame* info_ptr asm("info_ptr");
 
 /** make a system call to set the new FS base address.
  * Called from musl __init_tls.
@@ -55,7 +56,7 @@ extern mythos::InvocationBuf* msg_ptr asm("msg_ptr");
  */
 extern "C" int __set_thread_area(void *p)
 {
-    msg_ptr->write<protocol::ExecutionContext::SetFSGS>(reinterpret_cast<uintptr_t>(p), 0);
+    info_ptr->getInvocationBuf()->write<protocol::ExecutionContext::SetFSGS>(reinterpret_cast<uintptr_t>(p), 0);
     auto result = syscall_invoke_wait(mythos::init::PORTAL, mythos::init::EC, (void*)0xDEADBEEF);
     ASSERT(result.user == (uintptr_t)0xDEADBEEF);
     ASSERT(result.state == (uint64_t)Error::SUCCESS);
diff --git a/kernel/runtime/process/runtime/process.hh b/kernel/runtime/process/runtime/process.hh
index b696abe2..356622cc 100644
--- a/kernel/runtime/process/runtime/process.hh
+++ b/kernel/runtime/process/runtime/process.hh
@@ -7,12 +7,15 @@
 #include "util/optional.hh"
 #include "util/elf64.hh"
 #include "util/align.hh"
+#include "mythos/InfoFrame.hh"
 
+extern mythos::InfoFrame* info_ptr asm("info_ptr");
 extern mythos::CapMap myCS;
 extern mythos::PageMap myAS;
 extern mythos::KernelMemory kmem;
 extern mythos::SimpleCapAlloc< mythos::init::APP_CAP_START
   , mythos::init::SIZE-mythos::init::APP_CAP_START> capAlloc;
+extern mythos::ProcessorAllocator pa;
 
 using namespace mythos;
 
@@ -162,23 +165,17 @@ class Process{
     res = myCS.reference(pl, init::DEVICE_MEM, max_cap_depth, cs.cap(), init::DEVICE_MEM, max_cap_depth, 0).wait();
     TEST(res);
 
-    MLOG_DETAIL(mlog::app, "   scheduling contexts");
-    //todo: how to check whether cap is existing?
-    for(CapPtr ptr = init::SCHEDULERS_START; ptr < init::RAPL_DRIVER_INTEL; ptr++){
-      res = myCS.reference(pl, ptr, max_cap_depth, cs.cap(), ptr, max_cap_depth, 0).wait();
-      TEST(res);
-    }
-
     MLOG_DETAIL(mlog::app, "   RAPL driver");
     res = myCS.reference(pl, init::RAPL_DRIVER_INTEL, max_cap_depth, cs.cap(), init::RAPL_DRIVER_INTEL, max_cap_depth, 0).wait();
     TEST(res);
 
     MLOG_DETAIL(mlog::app, "   Interrupt control");
+    MLOG_WARN(mlog::app, "SKIP: Interrupt control caps!");
     //todo: how to check whether cap is existing?
-    for(CapPtr ptr = init::INTERRUPT_CONTROL_START; ptr < init::INTERRUPT_CONTROL_END; ptr++){
-      res = myCS.reference(pl, ptr, max_cap_depth, cs.cap(), ptr, max_cap_depth, 0).wait();
-      TEST(res);
-    }
+    //for(CapPtr ptr = init::INTERRUPT_CONTROL_START; ptr < init::INTERRUPT_CONTROL_END; ptr++){
+      //res = myCS.reference(pl, ptr, max_cap_depth, cs.cap(), ptr, max_cap_depth, 0).wait();
+      //TEST(res);
+    //}
 
     /* create address space */
     //todo: use dynamic table allocation in mmap!
@@ -246,35 +243,90 @@ class Process{
     auto ipc_vaddr = loadImage(pl, pm4);
     TEST(ipc_vaddr);
 
+    /* create InfoFrame */
+    MLOG_DETAIL(mlog::app, "create InfoFrame ...");
+    auto size = round_up(sizeof(InfoFrame), align2M);
+    MLOG_DETAIL(mlog::app, "   create frame", DVAR(size));
+    Frame infoFrame(capAlloc());
+    res = infoFrame.create(pl, kmem, size, align2M).wait();
+    TEST(res);
+    MLOG_DETAIL(mlog::app, "   map frame to target page map", DVARhex(size), DVARhex(*ipc_vaddr));
+    res = pm4.mmap(pl, infoFrame, *ipc_vaddr, align2M, 0x1).wait();
+    TEST(res);
+    
+    uintptr_t tmp_vaddr_if = 11*align512G;
+    MLOG_DETAIL(mlog::app, "   temporally map frame to own page map", DVARhex(tmp_vaddr_if));
+    PageMap pm3if(capAlloc());
+    res = pm3if.create(pl, kmem, 3).wait();
+    TEST(res);
+    PageMap pm2if(capAlloc());
+    res = pm2if.create(pl, kmem, 2).wait();
+    TEST(res);
+    MLOG_DETAIL(mlog::app, "   installMap");
+    res = myAS.installMap(pl, pm3if, ((tmp_vaddr_if >> 39) & 0x1FF)<< 39, 4,
+      protocol::PageMap::MapFlags().writable(true).configurable(true)).wait();
+    TEST(res);
+    res = pm3if.installMap(pl, pm2if, ((tmp_vaddr_if >> 30) & 0x1FF) << 30, 3,
+      protocol::PageMap::MapFlags().writable(true).configurable(true)).wait();
+    TEST(res);
+
+    MLOG_DETAIL(mlog::app, "   mmap");
+    res = myAS.mmap(pl, infoFrame, tmp_vaddr_if, size, 0x1).wait();
+    TEST(res);
+    
+    MLOG_DETAIL(mlog::app, "   copy info frame content");
+    mythos::memcpy(reinterpret_cast<void*>(tmp_vaddr_if), info_ptr, sizeof(InfoFrame));
+
+    MLOG_DETAIL(mlog::app, "   unmap");
+    res = myAS.munmap(pl, tmp_vaddr_if, size).wait();
+    TEST(res);
+
+    MLOG_DETAIL(mlog::app, "   remove maps");
+    res = myAS.removeMap(pl, tmp_vaddr_if, 2).wait();
+    TEST(res);
+    res = myAS.removeMap(pl, tmp_vaddr_if, 3).wait();
+    TEST(res);
+
+    MLOG_DETAIL(mlog::app, "   delete tables");
+    capAlloc.free(pm3if, pl);
+    capAlloc.free(pm2if, pl);
+
+
     /* create EC */
     MLOG_DETAIL(mlog::app, "create EC ...", DVARhex(img.header()->entry));
+    auto sc = pa.alloc(pl).wait();
+    TEST(sc);
+    MLOG_DETAIL(mlog::app, "allocated SC", DVAR(sc->cap));
     ExecutionContext ec(capAlloc());
-    res = ec.create(kmem).as(pm4).cs(cs).sched(mythos::init::SCHEDULERS_START + 1)
+    res = ec.create(kmem).as(pm4).cs(cs).sched(sc->cap)
     .rawFun(reinterpret_cast<int (*)(void*)>(img.header()->entry), reinterpret_cast<void*>(*ipc_vaddr))
     .suspended(true)
     .invokeVia(pl).wait();
     TEST(res);
+    MLOG_DETAIL(mlog::app, "move SC");
+    res = myCS.move(pl, sc->cap, max_cap_depth, cs.cap(), sc->cap, max_cap_depth).wait();
+    TEST(res);
 
     /* create portal */
     MLOG_DETAIL(mlog::app, "create Portal ...");
     MLOG_DETAIL(mlog::app, "   map frame at ", DVARhex(*ipc_vaddr));
-    Frame fp(capAlloc());
-    res = fp.create(pl, kmem, 2*1024*1024, align2M).wait();
-    TEST(res);
-    res = pm4.mmap(pl, fp, *ipc_vaddr, 2*1024*1024, 0x1).wait();
-    TEST(res);
 
     MLOG_DETAIL(mlog::app, "   create");
     Portal port(capAlloc(), reinterpret_cast<void*>(*ipc_vaddr));
     res = port.create(pl, kmem).wait();
     TEST(res);
-    res = port.bind(pl, fp, 0, ec.cap()).wait();
+    res = port.bind(pl, infoFrame, 0, ec.cap()).wait();
     TEST(res);
 
     MLOG_DETAIL(mlog::app, "   move Portal");
     res = myCS.move(pl, port.cap(), max_cap_depth, cs.cap(), init::PORTAL, max_cap_depth).wait();
     TEST(res);
     capAlloc.freeEmpty(port.cap());
+    
+    MLOG_DETAIL(mlog::app, "   move info frame");
+    res = myCS.move(pl, infoFrame.cap(), max_cap_depth, cs.cap(), init::INFO_FRAME, max_cap_depth).wait();
+    TEST(res);
+    capAlloc.freeEmpty(infoFrame.cap());
 
     /* move tables */
     MLOG_DETAIL(mlog::app, "move tables ...");
diff --git a/kernel/util/events/util/events.hh b/kernel/util/events/util/events.hh
index cb78e9b5..bbbc04d5 100644
--- a/kernel/util/events/util/events.hh
+++ b/kernel/util/events/util/events.hh
@@ -37,7 +37,7 @@ template<typename... Args>
 class EventHook
 {
 public:
-  EventHook() {}
+  constexpr EventHook() {}
   virtual ~EventHook() {}
   virtual int priority() const { return 0; }
   virtual void processEvent(Args...) = 0;
@@ -59,7 +59,7 @@ class Event
 public:
   typedef EventHook<Args...> hook_t;
 
-  Event() {}
+  constexpr Event() {}
 
   /** insert after this object but before the next object with
    * lower priority. */