started adding message passing scaffolding

diff --git a/Kernel.c b/Kernel.c
index f5139231bda800342d93dd197459b8d4e1262ff6..30f1c5f29158be651af301dfd976db2a8c3265c3 100644 (file)
--- a/Kernel.c
+++ b/Kernel.c
@@ -24,14 +24,23 @@
 #define WORD_ALIGN(x) \
     (((x) + WORD_SIZE) & ~(WORD_SIZE))
 
 #define WORD_ALIGN(x) \
     (((x) + WORD_SIZE) & ~(WORD_SIZE))
 

+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+

 typedef long TaskID_T;
 
 typedef long TaskID_T;
 

+struct Task_T;
+
+typedef struct {
+    struct Task_T* head;
+    struct Task_T* tail;
+} TaskQueue_T;
+

 typedef enum {
 typedef enum {

-    STATE_READY = 0,
-    STATE_RUNNING,
+    STATE_TERMINATED = 0,
+    STATE_READY,

     STATE_SEND_BLOCKED,
     STATE_RECV_BLOCKED,
     STATE_SEND_BLOCKED,
     STATE_RECV_BLOCKED,

-    STATE_TERMINATED
+    STATE_RUNNING,

 } TaskState_T;
 
 typedef struct Task_T {
 } TaskState_T;
 
 typedef struct Task_T {


@@ -39,12 +48,20 @@ typedef struct Task_T {
     long* heap_top;
     long* memory;
     struct Task_T* next;
     long* heap_top;
     long* memory;
     struct Task_T* next;

+    TaskState_T state;
+
+    /* incoming messages */
+    TaskQueue_T wait_queue;
+
+    /* outgoing message */
+    TaskID_T sender;
+    long status;
+    const void* sdata;
+    size_t nsdata;
+    void* rdata;
+    size_t nrdata;

 } Task_T;
 
 } Task_T;
 

-typedef struct {
-    Task_T* head;
-    Task_T* tail;
-} TaskQueue_T;

 
 typedef struct {
     Task_T idle;
 
 typedef struct {
     Task_T idle;


@@ -397,19 +414,64 @@ void* Kernel_Allocate(long sz)
     return ptr;
 }
 
     return ptr;
 }
 

-#if 0
-long Kernel_MsgSend(Task_T* task, const void* sdata, size_t nsdata, void* rdata, size_t nrdata)
+long Kernel_MsgSend(TaskID_T tid, const void* sdata, size_t nsdata, void* rdata, size_t nrdata)

 {
 {

+    AcquireLock();
+    Task_T* receiver = &Tasks[tid];
+    Task_T* sender = &Tasks[Running[CpuID].task];
+    sender->sender = tid;
+    sender->sdata  = sdata;
+    sender->nsdata = nsdata;
+    sender->rdata  = rdata;
+    sender->nrdata = nrdata;
+    // put sender in receiver's wait queue
+
+    if (receiver->state == STATE_RECV_BLOCKED)
+    {
+        // TODO: swap tasks directly to the receiver
+        // The receiver will handle the message and yield back to sender
+        ReleaseLock();
+        //YieldTo(receiver);
+    }
+    else
+    {
+        ReleaseLock();
+        Kernel_Yield();
+    }
+    return sender->status;

 }
 
 long Kernel_MsgReceive(void* rdata, size_t nrdata)
 {
 }
 
 long Kernel_MsgReceive(void* rdata, size_t nrdata)
 {

+    AcquireLock();
+    Task_T* sender = Tasks[Running[CpuID].task].wait_queue.head;
+    if (&Tasks[Running[CpuID].task].wait_queue.head)
+    {
+        memcpy(rdata, sender->sdata, MIN(nrdata, sender->nsdata));
+        ReleaseLock();
+    }
+    else
+    {
+        /* insert into wait queue and yield() */
+        ReleaseLock();
+        // yield
+    }
+    return 0;

 }
 
 long Kernel_MsgReply(long status, void* sdata, size_t nsdata)
 {
 }
 
 long Kernel_MsgReply(long status, void* sdata, size_t nsdata)
 {

+    (void)status;
+    (void)sdata;
+    (void)nsdata;
+    // acquire lock
+    // copy response data
+    // deque sender from wait queue
+    // enqueue receiver in ready queue
+    // yield to sender
+    // release lock
+    return 0;

 }
 }

-#endif

 
 /***************************************
     Main Routine
 
 /***************************************
     Main Routine