/*
fence: 1) send the heartbeat message to repo at regular basis. 1/1 minute, get back the messages,
calculate the digest, and send to localhost:9907
2)listens on localhost:9901, for the incoming raw inputs, calculate the digest, and send it to hub:10007
*/
int
ACE_TMAIN(int argc, ACE_TCHAR* argv[]){
ACE_SOCK_Acceptor _9901acceptor;
ACE_INET_Addr _9901addr(9901);
//create the acceptor
if(_9901acceptor.open(_9901addr,1)==-1){
ACE_ERROR_RETURN((LM_ERROR,
"%p\n","open"),1);
}else if(_9901acceptor.get_local_addr(_9901addr)== -1){
ACE_ERROR_RETURN((LM_ERROR,
"%p\n","get_local_addr"),1);
}
ACE_DEBUG((LM_INFO,
"(%P|%t) starting server at port %d\n",
_9901addr.get_port_number()));
// ACE_INET_Addr repo_addr(repo_port,repo_host.c_str());
ACE_SOCK_Connector con;
// ACE_SOCK_Stream cli_stream ;
ACE_Thread_Manager* mgr = ACE_Thread_Manager::instance();
// if(con.connect(cli_stream,repo_addr)==-1){
// ACE_ERROR_RETURN((LM_ERROR,
// "(%P|%t:%l) %p\n","connection failed"),0);
// }else{
// ACE_DEBUG((LM_DEBUG,
// "(%P|%t) connected to %s at port %d\n",repo_addr.get_host_name(),repo_addr.get_port_number()));
// }
/*connector side; do in a seperate thread;
*/
if(mgr->spawn(fetch_step2,
0,
THR_DETACHED) == -1){
ACE_ERROR ((LM_ERROR,
"(%P|%t) %p\n",
"spawn"));
}
/*
run the accept loop ;
*/
do{
ACE_SOCK_Stream stream;
if(_9901acceptor.accept(stream)== -1){
ACE_ERROR_RETURN((LM_ERROR,
"(%P|%t:%l) %p\n","accept failed"),0);
}else{
ACE_DEBUG((LM_DEBUG,
"(%P|%t:%l) connected to %s at port %d\n",_9901addr.get_host_name(),_9901addr.get_port_number()));
}
if(mgr->spawn(accept_step1,
reinterpret_cast<void *> (stream.get_handle()),
THR_DETACHED) == -1){
ACE_ERROR ((LM_ERROR,
"(%P|%t) %p\n",
"spawn"));
}
}while(true);
return 0;
}
int ChatServer::handle_data(ACE_SOCK_Stream *client)
{
if (DLOG)
{
printf("\n");
Util::log("[ChatServer::handle_data] START\n");
}
// Place the connection into blocking mode since this
// thread isn't doing anything except handling this client.
client->disable(ACE_NONBLOCK);
PacketHandler handler = PacketHandler(*client);
ServerPacketListener spl = ServerPacketListener(handler);
// Keep handling chat messages until client closes connection
// or this thread is asked to cancel itself.
ACE_Thread_Manager *mgr = ACE_Thread_Manager::instance();
ACE_thread_t me = ACE_Thread::self();
while (!mgr->testcancel(me) &&
handler.processPacket(spl) != 0)
continue;
handler.close();
if (DLOG) Util::log("[ChatServer::handle_data] END\n");
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("s:c:"));
int c = -1;
const ACE_TCHAR *client_cmd = 0;
while ((c = get_opts ()) != -1)
switch (c)
{
case 'c':
client_cmd = get_opts.opt_arg ();
ACE_DEBUG ((LM_DEBUG, "Client argument: %s\n", client_cmd));
break;
case 's':
server_cmd = get_opts.opt_arg ();
ACE_DEBUG ((LM_DEBUG, "Server argument: %s\n", server_cmd));
break;
default:
ACE_ERROR_RETURN ((LM_ERROR,
"Usage: collocation_test -s \"server opts\" -c \"client opts\""),
-1);
}
ACE_TCHAR cmd_line[1024];
ACE_OS::strcpy (cmd_line, ACE_TEXT("client "));
if (client_cmd != 0)
ACE_OS::strcat (cmd_line, client_cmd);
ACE_OS::strcat (cmd_line, ACE_TEXT(" -f ") THE_IOR);
ACE_ARGV args (cmd_line);
Barriers thread_barrier (2);
int retv = 1;
ACE_DEBUG ((LM_DEBUG,
"\n \t IDL_Cubit: Collocation test \n\n"));
ACE_Thread_Manager tm;
tm.spawn (reinterpret_cast<ACE_THR_FUNC> (&svr_worker),
&thread_barrier);
thread_barrier.server_init_.wait ();
ACE_OS::sleep (1);
Cubit_Client cubit_client (1);
// Make sure the server shuts itself down afterward.
if (cubit_client.init (args.argc (), args.argv ()) == -1)
return 1;
else
retv = cubit_client.run ();
thread_barrier.client_fini_.wait ();
tm.wait ();
ACE_OS::unlink (THE_IOR);
return retv;
}
int thread_test(int argc, char *argv[])
{
ACE_Thread_Manager* pThMgr = ACE_Thread_Manager::instance();
ACE_thread_t thId = 0;
int ret = pThMgr->spawn(thread_func, "create thread"
, THR_DETACHED|THR_SCOPE_SYSTEM
, &thId);
printf("thread_id=%d\n", thId);
ret = pThMgr->join(thId);
return ret;
}
// Listing 4 code/ch13
int ACE_TMAIN (int, ACE_TCHAR *[])
{
ExitHandler eh;
ACE_Thread_Manager tm;
HA_CommandHandler handler (eh);
handler.thr_mgr (&tm);
handler.activate ();
tm.wait();
return 0;
}
int
ACE_TMAIN (int, ACE_TCHAR *[])
{
// Message queue.
ACE_Message_Queue<ACE_MT_SYNCH> msg_queue (max_queue);
if (thr_mgr.spawn (ACE_THR_FUNC (producer), (void *) &msg_queue,
THR_NEW_LWP | THR_DETACHED) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn"), 1);
// Wait for producer and consumer threads to exit.
thr_mgr.wait ();
return 0;
}
int
FrameStoreUpdaterSvc::svc()
{
// set up RAPID frame-updaters
rapid::FsConfigUpdater fsConfigUpdater(*m_frameStore);
typedef kn::shared_ptr<rapid::FsPositionUpdater> FsPositionUpdaterPtr;
typedef kn::shared_ptr<rapid::FsJointUpdater> FsJointUpdaterPtr;
std::vector<FsPositionUpdaterPtr> fsPositionUpdaters;
std::vector<FsJointUpdaterPtr> fsJointUpdaters;
kn::DdsEventLoop eventLoop(svcName);
// connect RAPID frame-updaters for local-robot updates
if (m_params->frameStoreConfig.enabled) {
eventLoop.connect<rapid::FrameStoreConfig>(&fsConfigUpdater, rapid::FRAMESTORE_CONFIG_TOPIC +
m_params->frameStoreConfig.topicSuffix,
m_params->frameStoreConfig.parentNode,
m_params->frameStoreConfig.profile,
m_params->frameStoreConfig.library);
}
for (unsigned int i = 0; i < m_params->positionUpdaters.size(); ++i) {
fsPositionUpdaters.push_back(FsPositionUpdaterPtr(new rapid::FsPositionUpdater(*m_frameStore,
m_params->positionUpdaters[i])));
fsPositionUpdaters.back()->connect(eventLoop);
}
for (unsigned int i = 0; i < m_params->jointUpdaters.size(); ++i) {
fsJointUpdaters.push_back(FsJointUpdaterPtr(new rapid::FsJointUpdater(*m_frameStore,
m_params->jointUpdaters[i])));
fsJointUpdaters.back()->connect(eventLoop);
}
// enter processing loop
MIRO_LOG(LL_NOTICE, "Entering (detached) rapid framestore update loop.");
ACE_Thread_Manager * mgr = this->thr_mgr();
while (!mgr->testcancel(mgr->thr_self())) {
// 10Hz processing
eventLoop.processEvents(kn::microseconds(100000));
}
MIRO_LOG(LL_NOTICE, "Exiting (detached) rapid framestore updater loop.");
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
u_short port = argc > 1 ? ACE_OS::atoi (argv[1]) : ACE_DEFAULT_SERVER_PORT;
ACE_TLI_Acceptor server;
ACE_TLI_Stream new_stream;
// Open the server and reuse the address if in use...
if (server.open (ACE_INET_Addr (port), 1) == -1)
ACE_OS::t_error ("server.open"), ACE_OS::exit (1);
// Wait for a connection from a client. This is an example of a
// concurrent server.
for (int count = 1; ; count++)
{
ACE_DEBUG ((LM_DEBUG,
"thread %t, blocking for accept #%d\n",
count));
if (server.accept (new_stream) == -1)
ACE_OS::t_error ("server.accept error");
else if (thr_mgr.spawn (ACE_THR_FUNC (read_file),
(void *) new_stream.get_handle (),
THR_DETACHED | THR_BOUND) == -1)
ACE_OS::perror ("can't create worker thread\n");
}
ACE_NOTREACHED (return 0);
}
int
main (int argc, char *argv[])
{
u_short port = argc > 1 ? ACE_OS::atoi (argv[1]) : ACE_DEFAULT_SERVER_PORT;
ACE_INET_Addr l_addr (port);
ACE_TLI_Acceptor server (l_addr, 1); // Create server, reuse addr if in use.
ACE_TLI_Stream new_stream;
// Wait for a connection from a client. This is an example of a
// concurrent server.
for (;;)
{
if (server.accept (new_stream) == -1)
ACE_OS::t_error ("server.accept error");
if (thr_mgr.spawn (ACE_THR_FUNC (lookup_name),
(void *) new_stream.get_handle (),
THR_DETACHED) == -1)
ACE_DEBUG ((LM_ERROR,
"server: can't create worker thread %d\n"));
}
ACE_NOTREACHED (return 0);
}
int Thread_Per_Connection_Logging_Server::handle_data(ACE_SOCK_Stream *client)
{
ACE_FILE_IO log_file;
make_log_file(log_file, client);
client->disable(ACE_NONBLOCK);
Logging_Handler logging_handler(log_file, *client);
ACE_Thread_Manager *tm = ACE_Thread_Manager::instance();
ACE_thread_t me = ACE_OS::thr_self();
while (!tm->testcancel(me) && logging_handler.log_record() != -1)
continue;
log_file.close();
return 0;
}
//
// Now the svc() method where everything interesting happens.
//
int
ReactorTask::svc()
{
MIRO_DBG_OSTR(MIRO, LL_DEBUG,
"[Miro::ReactorTask] 0x" << (void*)this <<
" starts in thread " << ACE_Thread::self());
ACE_Time_Value timeout(0, 100000); // wait for 100 msec
ACE_Time_Value delta; // uninitialized time value
// set the given thread scheduling policy
if (ACE_OS::sched_params(schedp_) == -1) {
MIRO_LOG_OSTR(LL_ERROR, "[Miro::ReactorTask] Could not set sched parameters." << std::endl
<< "[Miro::ReactorTask] Maybe suid root is missing." << std::endl
<< "[Miro::ReactorTask] Will work on default scheduling policy." << std::endl);
}
// set the thread to be the owner of the reactor,
//otherwise we will get errors
reactor_.owner(ACE_OS::thr_self());
ACE_Thread_Manager * mgr = this->thr_mgr();
try {
while (!mgr->testcancel(mgr->thr_self())) {
// set delta to timeout
// handle_events decrements the timeout
delta = timeout;
// trigger message handling
reactor_.handle_events(delta);
}
}
catch (const Miro::Exception& e) {
MIRO_LOG_OSTR(LL_ERROR, "ReactorTask.handleMessage() - Uncaught Miro exception: " << e << std::endl);
conditionalShutdown();
}
catch (...) {
MIRO_LOG(LL_ERROR, "[Miro::HwReactor] task terminated due to unknown exception.");
conditionalShutdown();
}
return 0;
}
int main (int argc, char *argv[])
{
ACE_LOG_MSG->open (argv[0]);
parse_args (argc, argv);
current_readers = 0; // Possibly already done
current_writers = 0; // Possibly already done
ACE_DEBUG ((LM_DEBUG, "(%t) main thread starting\n"));
if (thr_mgr.spawn_n (n_readers, (ACE_THR_FUNC) reader, 0, THR_NEW_LWP) == -1 ||
thr_mgr.spawn_n (n_writers, (ACE_THR_FUNC) writer, 0, THR_NEW_LWP) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn_n"), 1);
thr_mgr.wait ();
ACE_DEBUG ((LM_DEBUG, "(%t) exiting main thread\n"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
if (parse_args (argc, argv) == -1)
return -1;
if (remote)
{
ACE_Remote_Mutex::set_server_address (ACE_INET_Addr (server_port, server_host));
global_rlock = (ACE_Token_Proxy *) new
ACE_Remote_RLock ("THE_TOKEN", ignore_deadlock, debug);
global_wlock = (ACE_Token_Proxy *) new
ACE_Remote_WLock ("THE_TOKEN", ignore_deadlock, debug);
}
else
{
global_rlock = (ACE_Token_Proxy *) new
ACE_Local_RLock ("THE_TOKEN", ignore_deadlock, debug);
global_wlock = (ACE_Token_Proxy *) new
ACE_Local_WLock ("THE_TOKEN", ignore_deadlock, debug);
}
ACE_Thread_Manager mgr;
if (mgr.spawn_n (threads, ACE_THR_FUNC (run_thread),
(void *) 0,
THR_BOUND | SUSPEND) == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "spawn failed"), -1);
#if ! defined (ACE_HAS_PTHREADS)
if (mgr.resume_all () == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "resume failed"), -1);
#endif
mgr.wait ();
return 0;
}
int
Thread_Per_Connection_Logging_Server::handle_data (ACE_SOCK_Stream *client)
{
ACE_FILE_IO log_file;
// Client's hostname is logfile name.
make_log_file (log_file, client);
// Place the connection into blocking mode since this
// thread isn't doing anything except handling this client.
client->disable (ACE_NONBLOCK);
Logging_Handler logging_handler (log_file, *client);
// Keep handling log records until client closes connection
// or this thread is asked to cancel itself.
ACE_Thread_Manager *mgr = ACE_Thread_Manager::instance ();
ACE_thread_t me = ACE_Thread::self ();
while (!mgr->testcancel (me) &&
logging_handler.log_record () != -1)
continue;
log_file.close ();
return 0;
}
int
SystemInfoSvc::fini()
{
// deregister the update timer
if (m_timerId != -1)
reactor()->cancel_timer(m_timerId);
m_timerId = -1;
ACE_Thread_Manager * mgr = this->thr_mgr();
if (mgr != NULL) {
mgr->cancel_task(this);
this->wait();
}
m_errorCounter = 0;
delete m_systemInfo;
delete m_sampleSupplier;
delete m_configSupplier;
MIRO_LOG(LL_NOTICE, "kn::SystemInfoSvc::fini() done");
return 0;
}
void TAO::Fault_Detector_i::start(ACE_Thread_Manager & threadManager)
{
threadManager.spawn(thr_func, this);
}
//---------------------------------------------------------------------------
int ACE_MAIN(int argc, ACE_TCHAR *argv[])
{
// 환경설정 (제일 먼저 초기화 해야함)
procArguments(argc, argv);
// 로그
if(initLog() < 0)
{
printf("로그 초기화를 실패했으므로 프로그램을 종료합니다.\n");
return -1;
}
//-----------------------------------------------------------------------
// 데몬 만들기
//-----------------------------------------------------------------------
// acceptor 가 초기화 된 후 데몬을 만들게 되면, 부모프로세스가 제거되면서
// listen 소켓도 같이 제거된다. 그러므로 acceptor 를 초기화 하기 전에
// 데몬을 먼저 만들어야 한다.
if(Config::instance()->process.daemon == true)
{
if(makeDaemon() < 0)
{
printf("데몬으로 만들기를 실패했으므로 프로그램을 종료합니다.\n");
return -1;
}
}
PAS_NOTICE1("%s", compile_date);
// 시그널 핸들러
PasSignalHandler* pSignalHandler = new PasSignalHandler;
initSignal(pSignalHandler);
//------------------
// 각 모듈의 초기화
//------------------
HTTP::Request::HeaderBuffBytes = HTTP::Response::HeaderBuffBytes = Config::instance()->process.HttpHeaderBufferBytes;
increseFdLimit();
// PAS 공식 로그
char hostName[32];
gethostname(hostName, sizeof(hostName)-1);
PasDataLog::setPasAddr(hostName);
// 메모리 매니저 초기화
//initMessageBlockManager();
if (readMBconfig() < 0)
{
printf("메모리 풀 컨피그 설정값을 확인하세요.\n");
PAS_ERROR("메모리 풀 컨피그 설정값을 확인하세요.\n");
return -1;
}
const int numWorkerThread = Config::instance()->thread.numWorker;
// 리액터
ACE_Reactor* pReactor = ReactorPool::instance()->createMaster();
ReactorPool::instance()->createWorkers(numWorkerThread);
ACE_Reactor* pGlobalReactor = ACE_Reactor::instance();
PAS_NOTICE3("REACTOR: Master=%X, Global=%X, Master=%x",
pReactor, pGlobalReactor, ReactorPool::instance()->masterReactor());
// Listen 포트 설정
PAS_NOTICE("Listen Socket Activate");
PasAcceptor* pAcceptor = new PasAcceptor(pReactor);
const int listenPort = Config::instance()->network.listenPort;
// mIDC 내의 서버를 감시하는 쪽에 mwatch 전달하기 위해 메시지 작성한다.
Util2::setMwatchMsg(listenPort);
// acceptor 기동
if(pAcceptor->open(listenPort) < 0)
{
PAS_ERROR1("Listen 소켓 생성 실패, Port[%d]\n", listenPort);
PAS_ERROR("프로그램 종료\n");
printf("Listen 소켓 생성 실패, Port[%d]\n", listenPort);
printf("프로그램 종료\n");
return -1;
}
// 쓰레드 매니저
ACE_Thread_Manager* pTManager = ACE_Thread_Manager::instance();
// monitor 보고리를 위한 thread 를 생성한다.
MonitorReporter *monitor = MonitorReporter::instance(pTManager);
monitor->activate(THR_NEW_LWP | THR_JOINABLE);
WatchReporter *watch = WatchReporter::instance(pTManager);
watch->activate(THR_NEW_LWP | THR_JOINABLE);
// UserInfo 관리를 위한 thread 를 생성한다.
UserInfoMng *userInfoMng = UserInfoMng::instance(pTManager);
userInfoMng->activate(THR_NEW_LWP | THR_JOINABLE);
// phone trace 를 위한 thread 를 생성한다.
PhoneTraceMng *phoneTraceMng = PhoneTraceMng::instance(pTManager);
phoneTraceMng->setDataFile((char*)"trace.acl");
phoneTraceMng->activate(THR_NEW_LWP | THR_JOINABLE);
// 공지 처리 (Stat Filter) 를 위한 thread 를 생성한다.
StatFilterMng *statFilterMng = StatFilterMng::instance(pTManager);
statFilterMng->setDataFile((char*)"k_stat.cfg");
statFilterMng->activate(THR_NEW_LWP | THR_JOINABLE);
// ACL 초기화
if(Config::instance()->acl.enable)
initACL();
CGI::cgiSetupConstants();
// Create AuthAgent Thread
AuthAgent *authAgent = AuthAgent::instance(pTManager);
authAgent->activate(THR_NEW_LWP | THR_JOINABLE);
//usleep(1000);
// 내부 정보 (sysinfo) 출력를 위한 Thread
SysInfo *sysInfo = SysInfo::instance(pTManager);
sysInfo->activate(THR_NEW_LWP | THR_JOINABLE);
// hash key 로그 작성을 위한 초기화.
HashKey::prepare();
// 로그 화일을 먼저 만들어 놓는다. 테스트시에 편하다. (tail -f )
PasDataLog::instance();
// accept event 핸들러 등록
pReactor->register_handler(pAcceptor, ACE_Event_Handler::ACCEPT_MASK);
// 이벤트 디멀티플렉싱
PAS_NOTICE("Master Reactor Start");
pReactor->run_event_loop();
PAS_NOTICE("Master Reactor Stop");
ReactorPool::instance()->stopWorkers();
/*--- Reactor 가 종료된 경우 아래 라인으로 진행된다. ---*/
stopACL(); // ACL 종료
userInfoMng->stop();
monitor->stop();
watch->stop();
phoneTraceMng->putq(new ACE_Message_Block());
statFilterMng->putq(new ACE_Message_Block());
sysInfo->putq(new ACE_Message_Block());
authAgent->putq(new ACE_Message_Block());
DNS::Manager::instance()->removeAllQuerier();
// 모든 쓰레드 종료 대기
PAS_NOTICE("Waiting for all threads to stop");
pTManager->wait();
delete phoneTraceMng;
delete statFilterMng;
delete sysInfo;
// 생성한 동적 객체 삭제
delete pSignalHandler;
PAS_NOTICE("======= PAS GW Stop =======");
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR* argv[]){
u_long priority_mask =
ACE_LOG_MSG->priority_mask (ACE_Log_Msg::PROCESS);
ACE_CLR_BITS (priority_mask,
LM_DEBUG|LM_TRACE);
ACE_LOG_MSG->priority_mask (priority_mask,
ACE_Log_Msg::PROCESS);
ACE::set_handle_limit();
ACE_Thread_Manager* mgr = ACE_Thread_Manager::instance();
ACE_SOCK_Acceptor _987acceptor;
ACE_INET_Addr _987addr(0x987);//2439
if(_987acceptor.open(_987addr, 1) == -1){
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"open"),
1);
}else if(_987acceptor.get_local_addr(_987addr) == -1){
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"get_local_addr"),
1);
}
ACE_DEBUG((LM_INFO,
"(%P|%t) starting 987 server at port %d\n",
_987addr.get_port_number()));
ACE_SOCK_Stream _str;
ACE_Handle_Set _set;
_set.set_bit(_987acceptor.get_handle());
do{
ACE_Time_Value timeout(ACE_DEFAULT_TIMEOUT);
ACE_Handle_Set tmp = _set;
int result = ACE_OS::select(ACE_Utils::truncate_cast<int> ((intptr_t) _987acceptor.get_handle()) +1,
(fd_set *) tmp,
0,
0,
NULL);
if(result == -1)
ACE_ERROR((LM_ERROR,
"(%P|%t) %p\n",
"select"));
else if(result==0)
ACE_DEBUG((LM_INFO,
"(%P|%t) select timed out\n"));
else{
if(tmp.is_set(_987acceptor.get_handle())){
if(_987acceptor.accept(_str) == -1){
ACE_ERROR((LM_ERROR,
"%p\n",
"987 accept"));
continue;
}else{
ACE_DEBUG((LM_INFO,
"(%P|%t: %l) spawning 987 server\n"));
if(mgr->spawn(process,
reinterpret_cast<void*> (_str.get_handle()),
THR_DETACHED) == -1){
ACE_ERROR((LM_ERROR,
"(%P|%t) %p\n",
"spawn"));
}
}
}
}
}while(true);
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
if (parse_args (argc, argv) == -1)
return -1;
ACE_Token_Proxy *A; // Mutex *A*.
ACE_Token_Proxy *B; // Mutex *B*.
ACE_Token_Proxy *R; // *R*eader Lock.
ACE_Token_Proxy *W; // *W*riter Lock.
// Depending on the command line arguments, we will create local or
// remote tokens. The names of the tokens are not important as long
// as they are unique.
if (remote)
{
ACE_Remote_Mutex::set_server_address (ACE_INET_Addr (server_port, server_host));
A = new ACE_Remote_Mutex ("R Mutex A", 0, debug);
B = new ACE_Remote_Mutex ("R Mutex B", 0, debug);
R = new ACE_Remote_RLock ("R Reader Lock", 0, debug);
W = new ACE_Remote_WLock ("R Writer Lock", 0, debug);
}
else
{
A = new ACE_Local_Mutex ("L Mutex A", 0, debug);
B = new ACE_Local_Mutex ("L Mutex B", 0, debug);
R = new ACE_Local_RLock ("L Reader Lock", 0, debug);
W = new ACE_Local_WLock ("L Writer Lock", 0, debug);
}
// These collections will be treated as Tokens by the threads.
ACE_Token_Collection collectionAR (debug, "A and Reader");
ACE_Token_Collection collectionAW (debug, "A and Writer");
ACE_Token_Collection collectionBR (debug, "B and Reader");
// AR and BR can run concurrently. Neither AR or BR can run when AW
// is running.
collectionAR.insert (*A);
collectionAR.insert (*R);
collectionAW.insert (*A);
collectionAW.insert (*W);
collectionBR.insert (*B);
collectionBR.insert (*R);
// Spawn off three threads.
ACE_Thread_Manager *mgr = ACE_Thread_Manager::instance ();
if (mgr->spawn (ACE_THR_FUNC (run_thread),
(void *) &collectionAR, THR_BOUND | THR_SUSPENDED) == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "spawn 1 failed"), -1);
if (mgr->spawn (ACE_THR_FUNC (run_thread),
(void *) &collectionAW, THR_BOUND | THR_SUSPENDED) == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "spawn 2 failed"), -1);
if (mgr->spawn (ACE_THR_FUNC (run_thread),
(void *) &collectionBR, THR_BOUND | THR_SUSPENDED) == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "spawn 3 failed"), -1);
#if ! defined (ACE_HAS_PTHREADS)
if (mgr->resume_all () == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "resume failed"), -1);
#endif
// Wait for all threads to exit.
mgr->wait ();
return 0;
}
