Add Thread support

Author: karic

include/Thread.h

@@ -0,0 +1,37 @@
+/*************************
+ * file:    Thread.h
+ * desc:    define Thread
+ * author:  Kari.Zhang
+ * date:    2017-12-14
+ ************************/
+
+#ifndef __THREAD__H__
+#define __THREAD__H__
+
+#ifdef linux
+#include <pthread.h>
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include "comm.h"
+
+typedef void* (*ThreadRoutine)(void*);
+typedef struct Thread Thread;
+
+Thread* createThread(ThreadRoutine func, void *param);
+bool startThread(Thread* thread);
+void destroyThread(Thread* thread);
+bool isThreadValid(const Thread* thread);
+
+#ifdef linux
+pthread_t getThreadId(const Thread* thread);
+#endif
+
+#ifdef WIN32
+HANDLE getThreadHandle(const Thread* thread);
+#endif
+
+#endif

include/engine.h

@@ -13,6 +13,7 @@
 #include "class.h"
 #include "runtime.h"
 
+extern void* engineRoutine(void *env);
 extern void executeMethod(ExecEnv *env, const MethodEntry *method);
 extern void executeMethod_spec(ExecEnv *env, const MethodEntry *method);
 

include/gc.h

@@ -32,4 +32,6 @@ void gcDestroy(gc_context* gc);
 
 extern void gcWork(gc_context* gc);
 
+extern void* gcRoutine(void *param);
+
 #endif

include/runtime.h

@@ -13,7 +13,9 @@
 
 #include "class.h"
 #include "comm.h"
+#include "gc.h"
 #include "mem.h"
+#include "Thread.h"
 
 /*
  * Store system property
@@ -131,6 +133,9 @@ typedef struct ExecEnv {
     Class **rtClsArea;	    // runtime class address list
     MethodEntry *mainMethod;// user class main()
     void* dl_handle;	    // dynamic link library handle 
+    Thread* gcThread;       // garbage collector thread
+    Thread* ngThread;       // engine thread
+    gc_context* gcctx;      // gc context
 } ExecEnv;
 
 typedef struct VM {

java/lang/Runnable.java

@@ -0,0 +1,4 @@
+
+public interface Runnable {
+    void run();
+}

java/lang/Thread.java

@@ -0,0 +1,26 @@
+
+public class Thread implements Runnable {
+
+    private Runnable target;
+
+    public Thread() {
+
+    }
+
+    public Thread(Runnable r) {
+        target = r;
+    }
+
+    private native void nativeCreate(Thread t);
+
+    public synchronized void start() {
+        nativeCreate(this);
+    }
+
+    @Override
+    public void run() {
+        if (target != null) {
+            target.run();
+        }
+    }
+}

src/vm/CMakeLists.txt

@@ -4,4 +4,4 @@ INCLUDE_DIRECTORIES(${libjar_dir} ${libvmbase_dir})
 
 AUX_SOURCE_DIRECTORY(. src_files)
 ADD_LIBRARY(libvmbase ${src_files})
-TARGET_LINK_LIBRARIES(libvmbase libminiz -ldl)
+TARGET_LINK_LIBRARIES(libvmbase libminiz -ldl -lpthread)

src/vm/Thread.c

@@ -0,0 +1,106 @@
+/*************************
+ * file:    Thread.c
+ * desc:    define Thread
+ * author:  Kari.Zhang
+ * date:    2017-12-14
+ ************************/
+
+#include <assert.h>
+#include <stdlib.h>
+
+#ifdef linux
+#include <pthread.h>
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include "Thread.h"
+
+typedef struct Thread {
+#ifdef linux
+    pthread_t pid;
+    pthread_attr_t *attr;
+#endif
+
+#ifdef WIN32
+    HANDLE hThread;
+    // thread attr
+#endif
+
+    ThreadRoutine func;
+    void* param;
+
+} Thread;
+
+Thread* createThread(ThreadRoutine func, void* param)
+{
+    assert(func && "func must not be NULL !");
+    Thread* thread = (Thread *)calloc(1, sizeof(Thread));
+    do {
+        if (thread == NULL) {
+            break;
+        }
+        thread->func = func;
+        thread->param = param;
+    } while (0);
+
+    return thread;
+}
+
+bool startThread(Thread* thread) {
+    assert(thread && "thread must not be NULL !");
+#ifdef linux
+    int result = pthread_create(
+            &thread->pid, 
+            thread->attr, 
+            thread->func,
+            thread->param);
+
+        if (result) {
+            free(thread);
+            thread = NULL;
+            return FALSE;
+        }
+        return TRUE; 
+#endif
+
+    return FALSE;
+}
+
+void destroyThread(Thread* thread)
+{
+    assert(thread && "thread must not be NULL !");
+}
+
+bool isThreadValid(const Thread* thread)
+{
+    if (thread != NULL) {
+        #ifdef linux
+            return thread->pid != 0;
+        #endif
+
+        #ifdef WIN32
+            return thread->hThread != NULL;
+        #endif
+    }
+
+    return FALSE;
+}
+
+#ifdef linux
+pthread_t getThreadId(const Thread* thread) 
+{
+    assert(thread && "thread must not be NULL !");
+    return thread->pid;
+}
+#endif
+
+#ifdef WIN32
+HANDLE getThreadHandle(const Thread* thread)
+{
+    assert(thread && "thread must not be NULL !");
+    return thread->hThread;
+}
+#endif

src/vm/engine.c

@@ -249,3 +249,14 @@ void executeMethod_spec(ExecEnv *env, const MethodEntry *method)
 #endif
 
 }
+
+void* engineRoutine(void *param)
+{
+    assert(param);
+    ExecEnv *env = (ExecEnv *)param;
+    JavaStack *stack = env->javaStack;
+    // TODO
+    printf("java stack top:%d\n", stack->top);
+
+    return NULL;
+}

src/vm/gc.c

@@ -28,7 +28,7 @@ gc_context* gcCreate(MemoryArea *mem) {
     assert (NULL != mem);
     gc_context *gc = (gc_context *)calloc(1, sizeof(gc_context));
     if (NULL != gc) {
-	gc->mem = mem;
+        gc->mem = mem;
     }
 
     return gc;
@@ -39,14 +39,27 @@ gc_context* gcCreate(MemoryArea *mem) {
  */
 void gcDestroy(gc_context* gc) {
     if (NULL != gc) {
-	free (gc);
-	gc = NULL;
+        free (gc);
+        gc = NULL;
     }
 }
 
 /*
  * gc start to work
  */
 extern void gcWork(gc_context* gc) {
+    // TODO
+    printf("gc works!\n");
+}
+
+extern void* gcRoutine(void *param)
+{
+    assert(param);
+    ExecEnv* env = (ExecEnv *)param;
+    if (env->gcctx == NULL){
+        env->gcctx = gcCreate(env->heapArea);
+    }
+    gcWork(env->gcctx);
 
+    return NULL;
 }