root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/ModuleCommon.h @ 36274

#pragma once

#include "Thread.h"
#include "Memory.h"

namespace mil {

class Tls {
    struct Data {
#ifdef MIL_GUI_WINDOWS
        HWND window_cache;
#else
        NSWindow* window_cache;
#endif
    } data[MIL_MAX_THREADS];
    Data dummy;
public:
    Data& getData(thread::id_t thread_id) {
        if (!thread::is_valid_id(thread_id)) {
            // Error
            return dummy;
        }
        return data[thread_id];
    }
    void flush() {
        for (size_t i = 0; i < _countof(data); i++) {
            data[i].window_cache = NULL;
        }
    }
    const thread::id_t thread_id;
    pool::Producer producer;
    pool::Consumer consumer;
    Tls(thread::id_t thread_id) : thread_id(thread_id), producer(thread_id) {
        memset(&data, 0, sizeof(data));
        memset(&dummy, 0, sizeof(dummy));
    }
};

struct ExitEvent {
    typedef SFINAE_CONDITION IsExitEvent;
};

struct ModuleExecuteProxy {
    template <class EventData, class Target>
    static void execute_body(EventData& data, Target& target, typename EventData::IsReturnMemoryEvent) {
        target.tls.producer.free(data.memory);
    }

    template <class EventData, class Target>
    static void execute_body(EventData&, Target& target, typename EventData::IsExitEvent) {
        MIL_MODULE_SUPER_CHILD_TYPE(Target)& o =
            MIL_MODULE_GET_SUPER_CHILD(target);
        o.destroy();
    }

    template <class EventData, class Target>
    static void execute_body(EventData& data, Target& target, ...) {
        MIL_MODULE_SUPER_CHILD_TYPE(Target)& o =
            MIL_MODULE_GET_SUPER_CHILD(target);
        
        o.execute_hook(data);
        o.execute(data);
    }

//    template <class, class Target>
//    static void execute_body(ExitEvent, Target& target, ...) {
//        MIL_MODULE_SUPER_CHILD_TYPE(Target)& o =
//            MIL_MODULE_GET_SUPER_CHILD(target);
//        o.destroy();
//    }

    template <class EventData, class Target>
    static void execute(EventData& data, Target& target) {
        execute_body<EventData, Target>(data, target, SFINAE_DUMMY_VALUE);
    }
};

template <class T>
void post_exit_template(void* obj, void* event_memory) {
    MIL_MODULE_SUPER_CHILD_TYPE(T)& o =
        MIL_MODULE_GET_SUPER_CHILD(*reinterpret_cast<T*>(obj));

    o.requestExit(event_memory);
}

template <class T>
void join_template(void* obj) {
    MIL_MODULE_SUPER_CHILD_TYPE(T)& o =
        MIL_MODULE_GET_SUPER_CHILD(*reinterpret_cast<T*>(obj));

    o.join();
}

struct AutoJoiner {
    void* obj;
    void (*post_exit)(void*, void*);
    void (*join)(void*);
    char event_memory[sizeof(void*) * 10];
};

void set_auto_join_body(AutoJoiner&);
void do_auto_join();

void set_tmalloc_post_body(void (*post)());

template <class T>
void set_auto_join(T* t) {
    AutoJoiner a = {};
    a.obj = reinterpret_cast<void*>(t);
    a.post_exit = post_exit_template<T>;
    a.join = join_template<T>;
    set_auto_join_body(a);
}

template <class Event, class Target, class Sender>
void dispatcher_free_event(Event& event, Target& target) {
    if (is_exit_event<Event>()) {
        return;
    }

    if (is_return_memory_event<Event>() || unlikely(event.owner_id == target.thread_id)) {
        // ReturnMemoryEvent
        size_t blocks = pool::bytes_to_blocks(return_memory_considered_sizeof<Event>());
        target.tls.producer.free(&event, blocks);
        return;
    }

    pool::MemoryList* m = target.tls.consumer.pop(event.owner_id);
    if (!m) {
        target.tls.consumer.store(&event);
        return;
    }

    pool::ReturnMemoryEvent<sizeof(Event)> e;
    e.memory = m;
    void* sender = thread::get(event.owner_id);
    if (unlikely(!sender)) {
        return;
    }
    (reinterpret_cast<Sender*>(sender))->post(e, target, (void*)&event, event.owner_id);
}

typedef void (*post_tfree_memory_function)(void*, pool::MemoryList*, thread::id_t);
extern post_tfree_memory_function posts[MIL_MAX_THREADS];

template <class Child, template <class> class ThreadType = MIL_DEFAULT_THREAD>
class ModuleCommon : public Thread<ModuleCommon<Child, ThreadType>, ThreadType> {
public:
    Tls tls;
    MIL_CRTP_CLASS_MEMBERS;

        template <class Event>
        void execute_hook_(Event&) {}

        template <class Event>
    void execute_hook(Event&) // no bracket


    ModuleCommon() : tls(this->thread_id) {
        set_auto_join(&MIL_MODULE_GET_SUPER_CHILD(*this));
        posts[this->thread_id] = &post_tfree_memory<Child>;
    }

    ~ModuleCommon() {
    }

protected:
    struct TMemory {
        void setMalloced() {
            owner_id |= (1 << (sizeof(owner_id) * 8 - 1));
        }
        bool isMalloced() {
                        return (owner_id & (1 << (sizeof(owner_id) * 8 - 1))) ? true : false;
        }
        mil::thread::id_t owner_id;
    };
    struct TMemoryStore {
        union {
            mil::thread::id_t owner_id;
            char padding[pool::BLOCK_SIZE];
        };
    };

    template <class Receiver>
    static void post_tfree_memory(void* memory, pool::MemoryList* list, thread::id_t receiver_id)  {
        pool::ReturnMemoryEvent<pool::BLOCK_SIZE> e;
        e.memory = list;
        Receiver& receiver = *(reinterpret_cast<Receiver*>(thread::get(receiver_id)));
        receiver.post(e, receiver, memory, receiver_id);
    }

    void* tmalloc(size_t size) {
        TMemory* tmemory = NULL;
        if ((size + sizeof(TMemory)) <= mil::pool::BLOCK_SIZE) {
            tmemory = (TMemory*)tls.producer.malloc<mil::pool::BLOCK_SIZE>();
            tmemory->owner_id = this->thread_id;
        } else {
            tmemory = (TMemory*)malloc(size + sizeof(TMemory));
            tmemory->setMalloced();
        }
        return (void*)(((TMemory*)tmemory) + 1);
    }

    void tfree(void* memory_) {
        TMemory* tmemory = (((TMemory*)memory_) - 1);
        if (tmemory->isMalloced()) {
            free(tmemory);
            return;
        }

        pool::MemoryList* m = this->tls.consumer.pop(tmemory->owner_id);
        if (!m) {
            this->tls.consumer.store((TMemoryStore*)tmemory);
            return;
        }

        posts[tmemory->owner_id](tmemory, m, tmemory->owner_id);
    }
};

class ExitNotifier : public ModuleCommon<ExitNotifier, MIL_DEFAULT_THREAD> {
public:
    void requestExit(void*) {
    }

    template <typename T, typename Sender>
    void post(const T&, Sender&, void*, thread::id_t) {
    }

    template <typename T, typename Sender>
    void post(const T& event, Sender& sender) {
    }
};
extern ExitNotifier exitNotifier;

}