Implement Multithreading

source/Cosmos.Core/INTs.cs

@@ -234,6 +234,8 @@ public struct IRQContext {
         [AsmMarker(AsmMarker.Type.Int_LastKnownAddress)]
         private static uint mLastKnownAddress;
 
+        public static uint mStackContext;
+
         /// <summary>
         /// IRQ handlers.
         /// </summary>
@@ -845,6 +847,8 @@ public static void Dummy() {
                     HandleInterrupt_47(ref xCtx);
                     HandleInterrupt_48(ref xCtx);
                     HandleInterrupt_49(ref xCtx);
+                    Processing.ProcessorScheduler.SwitchTask();
+                    Processing.ProcessorScheduler.EntryPoint();
                 }
             }
         }

source/Cosmos.Core/Memory/Old/Old_Heap.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Cosmos.Core;
+using Cosmos.Core.Processing;
 using Cosmos.Debug.Kernel;
 
 namespace Cosmos.Core.Memory.Old
@@ -19,6 +20,8 @@ public static unsafe class Heap
 
         private static uint mLastEntryIndex = 0u;
 
+        private static Mutex mMemeoryGate = new Mutex();
+
         private static bool mInitialized = false;
 
         private static void DoInitialize(uint aEndOfRam)
@@ -59,6 +62,11 @@ public static uint MemAlloc(uint aLength)
             {
                 EnsureIsInitialized();
 
+                if (mMemeoryGate != null)
+                {
+                    mMemeoryGate.Lock();
+                }
+
                 DataLookupTable* xCurrentTable = GlobalSystemInfo.GlobalInformationTable->FirstDataLookupTable;
                 DataLookupTable* xPreviousTable = null;
                 uint xResult;
@@ -81,6 +89,11 @@ public static uint MemAlloc(uint aLength)
                             }
                         }
 
+                        if (mMemeoryGate != null)
+                        {
+                            mMemeoryGate.Unlock();
+                        }
+
                         return xResult;
                     }
                     mLastTable = xPreviousTable;
@@ -117,6 +130,12 @@ public static uint MemAlloc(uint aLength)
                 }
                 mLastTable = xNextTablePointer;
                 mLastEntryIndex = 0;
+
+                if (mMemeoryGate != null)
+                {
+                    mMemeoryGate.Unlock();
+                }
+
                 return xResult;
             }
             finally
@@ -129,6 +148,10 @@ public static uint MemAlloc(uint aLength)
                 {
                     //Debugger.DoSend("    Not enabling interrupts, because they weren't enabled yet!");
                 }
+                if (mMemeoryGate != null)
+                {
+                    mMemeoryGate.Unlock();
+                }
             }
         }
 

source/Cosmos.Core/ObjUtilities.cs

@@ -0,0 +1,19 @@
+using IL2CPU.API.Attribs;
+using System;
+
+namespace Cosmos.Core
+{
+    public static unsafe class ObjUtilities
+    {
+        public static uint GetPointer(Delegate aVal)
+        {
+            return (uint)aVal.GetHashCode();
+        }
+
+        [PlugMethod(PlugRequired = true)]
+        public static uint GetPointer(Object aVal) { return 0; }
+
+        [PlugMethod(PlugRequired = true)]
+        public static uint GetEntryPoint() { return 0; }
+    }
+}

source/Cosmos.Core/Processing/Mutex.cs

@@ -0,0 +1,27 @@
+using IL2CPU.API.Attribs;
+
+namespace Cosmos.Core.Processing
+{
+    public unsafe class Mutex
+    {
+        public int gate;
+
+        [PlugMethod(PlugRequired = true)]
+        public static void MutexLock(int* mtx) { }
+
+        public void Lock()
+        {
+            while (gate != 0) { }
+            gate = 1;
+            /*fixed (int* p = &gate)
+            {
+                MutexLock(p);
+            }*/
+        }
+
+        public void Unlock()
+        {
+            gate = 0;
+        }
+    }
+}

source/Cosmos.Core/Processing/ProcessContext.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Cosmos.Core.Processing
+{
+    public static unsafe class ProcessContext
+    {
+        public enum Thread_State
+        {
+            ALIVE = 0,
+            DEAD = 1,
+            WAITING_SLEEP = 2,
+            PAUSED = 3
+        }
+
+        public enum Context_Type
+        {
+            THREAD = 0,
+            PROCESS = 1
+        }
+
+        public class Context
+        {
+            public Context next;
+            public Context_Type type;
+            public uint tid;
+            public string name;
+            public uint esp;
+            public uint stacktop;
+            public System.Threading.ThreadStart entry;
+            public System.Threading.ParameterizedThreadStart paramentry;
+            public Thread_State state;
+            public object param;
+            public int arg;
+            public uint priority;
+            public uint age;
+            public uint parent;
+        }
+
+        public const uint STACK_SIZE = 4096;
+        public static uint m_NextCID;
+        public static Context m_CurrentContext;
+        public static Context m_ContextList;
+
+        public static Context GetContext(uint tid)
+        {
+            /*for(int i = 0; i < m_ContextList.Count; i++)
+            {
+                if(m_ContextList[i].tid == tid)
+                {
+                    return m_ContextList[i];
+                }
+            }*/
+            Context ctx = m_ContextList;
+            while (ctx.next != null)
+            {
+                if (ctx.tid == tid)
+                {
+                    return ctx;
+                }
+                ctx = ctx.next;
+            }
+            if (ctx.tid == tid)
+            {
+                return ctx;
+            }
+            return null;
+        }
+
+        public static uint* SetupStack(uint* stack)
+        {
+            uint origin = (uint)stack;
+            *--stack = 0xFFFFFFFF; // trash
+            *--stack = 0xFFFFFFFF; // trash
+            *--stack = 0xFFFFFFFF; // trash
+            *--stack = 0xFFFFFFFF; // trash
+            *--stack = 0x10; // ss ?
+            *--stack = 0x00000202; // eflags
+            *--stack = 0x8; // cs
+            *--stack = ObjUtilities.GetEntryPoint(); // eip
+            *--stack = 0; // error
+            *--stack = 0; // int
+            *--stack = 0; // eax
+            *--stack = 0; // ebx
+            *--stack = 0; // ecx
+            *--stack = 0; // offset
+            *--stack = 0; // edx
+            *--stack = 0; // esi
+            *--stack = 0; // edi
+            *--stack = origin; //ebp
+            *--stack = 0x10; // ds
+            *--stack = 0x10; // fs
+            *--stack = 0x10; // es
+            *--stack = 0x10; // gs
+            return stack;
+        }
+
+        public static uint StartContext(string name, System.Threading.ThreadStart entry, Context_Type type)
+        {
+            Context context = new Context();
+            context.type = type;
+            context.tid = m_NextCID++;
+            context.name = name;
+            context.stacktop = GCImplementation.AllocNewObject(4096);
+            context.esp = (uint)SetupStack((uint*)(context.stacktop + 4000));
+            context.state = Thread_State.PAUSED;
+            context.entry = entry;
+            if (type == Context_Type.PROCESS)
+            {
+                context.parent = 0;
+            }
+            else
+            {
+                context.parent = m_CurrentContext.tid;
+            }
+            Context ctx = m_ContextList;
+            while (ctx.next != null)
+            {
+                ctx = ctx.next;
+            }
+            ctx.next = context;
+            return context.tid;
+        }
+
+        public static uint StartContext(string name, System.Threading.ParameterizedThreadStart entry, Context_Type type, object param)
+        {
+            Context context = new Context();
+            context.type = type;
+            context.tid = m_NextCID++;
+            context.name = name;
+            context.stacktop = GCImplementation.AllocNewObject(4096);
+            context.esp = (uint)SetupStack((uint*)(context.stacktop + 4000));
+            context.state = Thread_State.ALIVE;
+            context.paramentry = entry;
+            context.param = param;
+            if (type == Context_Type.PROCESS)
+            {
+                context.parent = 0;
+            }
+            else
+            {
+                context.parent = m_CurrentContext.tid;
+            }
+            Context ctx = m_ContextList;
+            while (ctx.next != null)
+            {
+                ctx = ctx.next;
+            }
+            ctx.next = context;
+            return context.tid;
+        }
+    }
+}

source/Cosmos.Core/Processing/ProcessorScheduler.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using IL2CPU.API.Attribs;
+
+namespace Cosmos.Core.Processing
+{
+    public static unsafe class ProcessorScheduler
+    {
+        public static void Initialize()
+        {
+            var context = new ProcessContext.Context();
+            context.type = ProcessContext.Context_Type.PROCESS;
+            context.tid = ProcessContext.m_NextCID++;
+            context.name = "Boot";
+            context.esp = 0;
+            context.stacktop = 0;
+            context.state = ProcessContext.Thread_State.ALIVE;
+            context.arg = 0;
+            context.priority = 0;
+            context.age = 0;
+            context.parent = 0;
+            ProcessContext.m_ContextList = context;
+            ProcessContext.m_CurrentContext = context;
+
+            IOPort counter0 = new IOPort(0x40);
+            IOPort cmd = new IOPort(0x43);
+
+            int divisor = 1193182 / 25;
+            cmd.Byte = (0x06 | 0x30);
+            counter0.Byte = (byte)divisor;
+            counter0.Byte = (byte)(divisor >> 8);
+
+            IOPort pA1 = new IOPort(0xA1);
+            IOPort p21 = new IOPort(0xA1);
+            pA1.Byte = 0x00;
+            p21.Byte = 0x00;
+        }
+
+        public static void EntryPoint()
+        {
+            ProcessContext.m_CurrentContext.entry?.Invoke();
+            ProcessContext.m_CurrentContext.paramentry?.Invoke(ProcessContext.m_CurrentContext.param);
+            ProcessContext.m_CurrentContext.state = ProcessContext.Thread_State.DEAD;
+            while (true) { } // remove from thread pool later
+        }
+
+        public static int interruptCount;
+
+        public static void SwitchTask()
+        {
+            interruptCount++;
+            if (ProcessContext.m_CurrentContext != null)
+            {
+                ProcessContext.Context ctx = ProcessContext.m_ContextList;
+                ProcessContext.Context last = ctx;
+                while (ctx != null)
+                {
+                    if (ctx.state == ProcessContext.Thread_State.DEAD)
+                    {
+                        last.next = ctx.next;
+                        break;
+                    }
+                    last = ctx;
+                    ctx = ctx.next;
+                }
+                ctx = ProcessContext.m_ContextList;
+                while (ctx != null)
+                {
+                    if (ctx.state == ProcessContext.Thread_State.WAITING_SLEEP)
+                    {
+                        ctx.arg -= 1000 / 25;
+                        if (ctx.arg <= 0)
+                        {
+                            ctx.state = ProcessContext.Thread_State.ALIVE;
+                        }
+                    }
+                    ctx.age++;
+                    ctx = ctx.next;
+                }
+                ProcessContext.m_CurrentContext.esp = INTs.mStackContext;
+            tryagain:;
+                if (ProcessContext.m_CurrentContext.next != null)
+                {
+                    ProcessContext.m_CurrentContext = ProcessContext.m_CurrentContext.next;
+                }
+                else
+                {
+                    ProcessContext.m_CurrentContext = ProcessContext.m_ContextList;
+                }
+                if (ProcessContext.m_CurrentContext.state != ProcessContext.Thread_State.ALIVE)
+                {
+                    goto tryagain;
+                }
+                ProcessContext.m_CurrentContext.age = ProcessContext.m_CurrentContext.priority;
+                INTs.mStackContext = ProcessContext.m_CurrentContext.esp;
+            }
+            Global.PIC.EoiMaster();
+            Global.PIC.EoiSlave();
+        }
+    }
+}