root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/Thread.h @ 34853

#pragma once
#include "Mil.h"
#include "Serial.h"
#include "Atomic.h"
#include "FilterException.h"

#ifndef MIL_MAX_THREADS
#define MIL_MAX_THREADS 25
#endif

namespace mil {
namespace thread {
typedef intptr_t id_t;
extern Serial id_serial;
extern void* get(id_t thread_id);
extern void set(id_t thread_id, void* object);
extern bool is_valid_id(id_t thread_id);
}
}

#if defined(MIL_OS_WINDOWS)
#include "os-windows/Thread.h"
#define MIL_DEFAULT_THREAD mil::thread::Windows
//#elif defined(__CYGWIN__)
//#include "os-windows/Thread.h"
#elif defined(MIL_OS_UNIX)
#include "os-unix/Thread.h"
#define MIL_DEFAULT_THREAD mil::thread::Posix
#else
#error
#endif

#ifdef __OBJC__
#include "gui-cocoa/CocoaThread.h"
namespace mil {
namespace thread {
template <typename Child>
class Cocoa : public boost::noncopyable {
    MIL_CRTP_CLASS_MEMBERS;

    WorkerThread* thread;

public:
    Cocoa() {
        thread = [[WorkerThread alloc] init];
    }

    ~Cocoa() {
        [thread release];
    }

    void start() {
        struct foo {
            static void* thread_routine(void* object) {
                Child::thread_routine(object);
                return NULL;
            }
        };

        void* (*routine_)(void*) = foo::thread_routine;
        void* arg_ = (void*)this;

[thread setData:routine_ arg:arg_];
[NSThread detachNewThreadSelector:@selector(start) toTarget:thread withObject:nil];
    }

    void join() {
        for (int retry = 50; !getChild().is_exited.load(); retry--) {
            if (retry == 0) {
                halt << "thread can't exit";
            }
            sleep(1);
        }
    }
};
}
}
#endif

#ifdef MIL_OS_UNIX

namespace mil {
namespace thread {

typedef pid_t native_id_t;
static inline native_id_t get_native_id() {
    return gettid();
}

template <typename Child>
class Posix : public boost::noncopyable {
    pthread_t t;
    pthread_attr_t a;

    MIL_CRTP_CLASS_MEMBERS;

public:
    void start() {
        struct foo {
            static void* thread(void* object) {
                Child::thread_routine(object);
                return NULL;
            }
        };

        pthread_attr_init(&a);
        pthread_attr_setdetachstate(&a,PTHREAD_CREATE_DETACHED);
        pthread_create(&t, &a, foo::thread,
                       static_cast<void*>(this));
    }

    void join() {
        for (int retry = 50; !getChild().is_exited.load(); retry--) {
            if (retry == 0) {
                halt << "thread can't exit";
            }
            sleep(1);
        }
    }
};
}
}
#endif

#ifdef MIL_OS_WINDOWS
namespace mil {
namespace thread {

typedef DWORD native_id_t;
static inline native_id_t get_native_id() {
    return GetCurrentThreadId();
}

template <typename Child>
class Windows : public boost::noncopyable {
public:
    MIL_CRTP_CLASS_MEMBERS;

protected:
    atomic<HANDLE> hThread;

public:
    void start() {
        struct foo {
            static DWORD WINAPI thread(LPVOID object) {
                Child::thread_routine(object);
                return 0;
            }
        };

        DWORD threadId;
        LPVOID obj = reinterpret_cast<LPVOID>(this);
        HANDLE t = CreateThread(NULL, 0, foo::thread, obj, 0, &threadId);
        if (t == NULL) {
            halt << "CreateThread(): failed";
        }
        hThread.store(t);
    }

    void join() {
        HANDLE t = hThread.exchange(0);
        if (!t) {
            return;
        }

        for (int retry = 50; !getChild().is_exited.load(); retry--) {
            if (retry == 0) {
                MessageBox(NULL, _T("terminate thread"), _T(""), MB_OK);
                //ExitProcess(1); // XXX
                TerminateThread(t, 1);
                break;
            }
            sleep(1);
        }
        CloseHandle(t);
    }

    Windows() : hThread(NULL) {
    }
};
}
}
#endif

namespace mil {
template <class Child, template<class> class ThreadType = MIL_DEFAULT_THREAD>
class Thread : public ThreadType<Thread<Child, ThreadType> > {
public:
    MIL_CRTP_CLASS_MEMBERS;

    const thread::id_t thread_id;
    atomic<bool> is_exited;

    static int thread_routine_filtered(int, char** argv) {
        Thread<Child, ThreadType>* obj = (Thread<Child, ThreadType>*)argv;
        typedef Thread<Child, ThreadType> Type;

        MIL_MODULE_SUPER_CHILD_TYPE(Type)& o =
            MIL_MODULE_GET_SUPER_CHILD(*obj);

        o.run();
        o.is_exited.store(true);
        //std::cout << "X" << std::flush;
        return 0;
    }

    static void thread_routine(void* object) {
        char** argv = reinterpret_cast<char**>(object);
        filter_exception_and_start(0, argv, thread_routine_filtered);
    }

    void run() {
    }

    void start() {
        if (!this->is_exited.load()) {
            return;
        }
        this->is_exited.store(false);
        //ThreadPlatform<Thread<Child> >::start();
        ThreadType<Thread<Child, ThreadType> >::start();
    }

    Thread() : thread_id(thread::id_serial.retain()), is_exited(true) {
        if (!thread::is_valid_id(thread_id)) {
            halt << "can't retain thread id";
            return;
        }
        //threads[thread_id].store(reinterpret_cast<void*>(this));
        thread::set(thread_id, reinterpret_cast<void*>(this));
    }

    ~Thread() {
        this->join();
        thread::set(thread_id, NULL);
        //threads[thread_id].store(NULL);
        if (!thread::id_serial.release(thread_id)) {
            halt << "can't release thread id";
        }
    }
};
}