root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/StaticData.cc @ 37790

#include "PrecompiledHeaders.h"
#include "Mil.h"
#include "Thread.h"
#include "ModuleCommon.h"
#include "FilterException.h"
#include "Intl.h"

#undef filter_exception_and_start

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

namespace mil {

post_tfree_memory_function posts[MIL_MAX_THREADS];

#if 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::tbb_allocator<TBBMemoryUnit> tbb_a;
}
#endif

namespace thread {
Serial<id_t> 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 >= static_cast<id_t>(_countof(threads)) ||
        thread_id == Serial<id_t>::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;
}


}

int filter_exception_and_start(
    int (*start)(int, char**), int argc, char** argv) {

#ifdef __OBJC__
    {
        NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
        int result = 0;
        id exception = filter_exception_and_start_objc(
            &result, start, argc, argv);
        if (exception != nil) {
            const char* userInfoString = NULL;
            //if ([exception userInfo] != nil) {
            //    userInfoString = [[[exception userInfo] description] UTF8String];
            //}
            fprintf(
                stderr,
                _("Objective-C Exception\n    name     = %s\n    reason   = %s\n    userInfo = %s\n"),
                [[exception name] UTF8String],
                [[exception reason] UTF8String],
                userInfoString);
            result = EXIT_FAILURE;
        }
        [pool release];
        return result;
    }
#else
    return start(argc, argv);
#endif    

    /*
      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__

@implementation WorkerThread
- (void)setData:(void* (*)(void*))routine_ arg:(void*)arg_ {
    routine = routine_;
    arg = arg_;
}
- (void)start {
    routine(arg);
}
@end

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