root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/StaticData.cpp @ 36260

#include "PrecompiledHeaders.h"

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "Mil.h"
#include "Thread.h"
#include "ModuleCommon.h"

//#include <fecti/Utility/FBlockMemoryAllocator/FAllocatorImpl_Block.cpp>
//#include <fecti/Utility/FThread.cpp>

#ifdef ENABLE_NLS
#include <libintl.h>
#else
#define gettext(x) x
#endif

namespace mil {

post_tfree_memory_function posts[MIL_MAX_THREADS];

#ifdef MIL_TBB_PRODUCER
#ifdef _MSC_VER
#ifdef _DEBUG
#pragma comment(lib, "ix86/tbb_debug.lib")
#else
#pragma comment(lib, "ix86/tbb.lib")
#endif
#endif
namespace pool {
//tbb::scalable_allocator<TbbMemoryUnit> tbb_a;
tbb::tbb_allocator<TbbMemoryUnit> tbb_a;
}
#endif

namespace thread {
Serial id_serial(MIL_MAX_THREADS);
static atomic<void*> threads[MIL_MAX_THREADS];

void* get(id_t thread_id) {
    if (!is_valid_id(thread_id)) {
        halt << "thread_id is out of range";
    }
    return threads[thread_id].load();
}

void set(id_t thread_id, void* object) {
    if (!is_valid_id(thread_id)) {
        halt << "thread_id is out of range";
    }
    threads[thread_id].store(object);
}

void assert_id(id_t thread_id) {
    assert(is_valid_id(thread_id));
}

bool is_valid_id(id_t thread_id) {
    if (thread_id < 0 || thread_id >= static_cast<id_t>(_countof(threads)) || thread_id == Serial::INVALID_VALUE) {
        return false;
    }
    return true;
}
}

ExitNotifier exitNotifier /* XXX depends on id_serial */;
int auto_joiner_index = 0;
AutoJoiner auto_joiners[MIL_MAX_THREADS];
atomic<int> auto_join_native_id_once;
atomic<thread::native_id_t> auto_join_native_id;

static void check_id() {
    if (!auto_join_native_id_once.load()) {
        auto_join_native_id_once.store(1);
        auto_join_native_id.store(thread::get_native_id());
    }
    if (auto_join_native_id.load() != thread::get_native_id()) {
        halt << "native thread id is not match [" << auto_join_native_id.load() << "] != [" << thread::get_native_id() << "]";
    }
}

void set_auto_join_body(AutoJoiner& a) {
    check_id();

    auto_joiners[auto_joiner_index] = a;
    auto_joiner_index++;
    if (auto_joiner_index >= MIL_MAX_THREADS) {
        halt << "auto_joiner_index is too big [" << auto_joiner_index << "]";
        return;
    }
}

void do_auto_join() {
    check_id();

    for (int i = 0; i < auto_joiner_index; i++) {
        auto_joiners[i].post_exit(auto_joiners[i].obj, auto_joiners[i].event_memory);
    }
    for (int i = 0; i < auto_joiner_index; i++) {
        auto_joiners[i].join(auto_joiners[i].obj);
    }
    auto_joiner_index = 0;
}


}

#undef filter_exception_and_start
extern "C" int filter_exception_and_start(int argc, char** argv, int (*start)(int, char**)) {
    return start(argc, argv);
/*
    try {
        return start(argc, argv);
    }
    //catch (boost::exception& e)
    //{
    //    debug << "c++ boost::exception [" << boost::diagnostic_information(e) << "]";
    //}
    catch (std::exception& e) {
        //debug << "c++ std::exception [" << e.what() << "]";
        //_ftprintf(stderr, gettext("c++ std::exception [%s]\n"), e.what());
        fprintf(stderr, gettext("c++ std::exception [%s]\n"), e.what()); // e.what() -> char
    }
    return 1;
*/
}

#ifdef __OBJC__
namespace mil {
class CocoaThreadManager : boost::noncopyable {
    Mutex mutex;
    NSPort* port_matrix[MIL_MAX_THREADS][MIL_MAX_THREADS];
    NSConnection* send_connection_matrix[MIL_MAX_THREADS][MIL_MAX_THREADS];
    NSConnection* receive_connection_matrix[MIL_MAX_THREADS][MIL_MAX_THREADS];
    id proxies[MIL_MAX_THREADS][MIL_MAX_THREADS];
public:
    CocoaThreadManager() {
        synchronized (mutex) {
        }
    }

    ~CocoaThreadManager() {
        synchronized (mutex) {
        }
    }

    id getProxy(int sender, int receiver) {
        synchronized (mutex) {
            if (proxies[sender][receiver]) {
                return proxies[sender][receiver];
            }
            port_matrix[sender][receiver] = [NSPort port];
            port_matrix[receiver][sender] = [NSPort port];
            send_connection_matrix[sender][receiver] =
    [NSConnection connectionWithReceivePort:port_matrix[sender][receiver] sendPort:port_matrix[receiver][sender]];

            proxies[sender][receiver] = [send_connection_matrix[sender][receiver] rootProxy];
            return proxies[sender][receiver];
        }
    }

    void setProxy(int receiver, id object) {
        synchronized (mutex) {
            for (unsigned int sender = 0; sender < _countof(send_connection_matrix[0]); sender++) {
                if (send_connection_matrix[sender][receiver] && !receive_connection_matrix[sender][receiver]) {
                    receive_connection_matrix[sender][receiver] =
    [NSConnection connectionWithReceivePort:port_matrix[receiver][sender] sendPort:port_matrix[sender][receiver]];
[receive_connection_matrix[sender][receiver] setRootObject: object];
                }
            }
        }
    }
};

}
#endif