template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i (void) { ACE_TRACE ("ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i"); if (this->map_man_->table_ == 0) return -1; // Handle initial case specially. else if (this->index_ == -1) { this->index_++; return this->forward_i (); } else if (this->index_ >= ACE_static_cast (ssize_t, this->map_man_->total_size_)) return 0; this->next_ = this->next_->next_; if (this->next_ == &this->map_man_->table_[this->index_]) { while (++this->index_ < ACE_static_cast (ssize_t, this->map_man_->total_size_)) { this->next_ = this->map_man_->table_[this->index_].next_; if (this->next_ != &this->map_man_->table_[this->index_]) break; } } return this->index_ < ACE_static_cast (ssize_t, this->map_man_->total_size_); }
// Listing 2 code/ch09 void echo_dgram (void) { ACE_INET_Addr my_addr (ACE_static_cast (u_short, 10102)); ACE_INET_Addr your_addr; ACE_SOCK_Dgram udp (my_addr); char buff[BUFSIZ]; size_t buflen = sizeof (buff); ssize_t recv_cnt = udp.recv (buff, buflen, your_addr); if (recv_cnt > 0) udp.send (buff, ACE_static_cast (size_t, buflen), your_addr); udp.close (); return; }
ACE_LPTRANSMIT_FILE_BUFFERS ACE_Asynch_Transmit_File::Header_And_Trailer::transmit_buffers (void) { // If both are zero, return zero if (this->header_ == 0 && this->trailer_ == 0) return 0; else { // Something is valid // If header is valid, set the fields if (this->header_ != 0) { this->transmit_buffers_.Head = this->header_->rd_ptr (); #if defined(ACE_WIN64) this->transmit_buffers_.HeadLength = ACE_static_cast (DWORD, this->header_bytes_); #else this->transmit_buffers_.HeadLength = this->header_bytes_; #endif /* ACE_WIN64 */ } else { this->transmit_buffers_.Head = 0; this->transmit_buffers_.HeadLength = 0; } // If trailer is valid, set the fields if (this->trailer_ != 0) { this->transmit_buffers_.Tail = this->trailer_->rd_ptr (); #if defined(ACE_WIN64) this->transmit_buffers_.TailLength = ACE_static_cast (DWORD, this->trailer_bytes_); #else this->transmit_buffers_.TailLength = this->trailer_bytes_; #endif /* ACE_WIN64 */ } else { this->transmit_buffers_.Tail = 0; this->transmit_buffers_.TailLength = 0; } // Return the transmit buffers return &this->transmit_buffers_; } }
int ACEXML_Transcoder::ucs42utf8 (ACEXML_UCS4 src, ACEXML_UTF8 *dst, size_t len) { if (src < 0x10000) { int retv = ACEXML_Transcoder::utf162utf8 (ACE_static_cast (ACEXML_UTF16, src), dst, len); return (retv == ACEXML_IS_SURROGATE ? ACEXML_NON_UNICODE : retv); } else if (src >= 0x100000 && src < 0x110000) { if (len < 4) return ACEXML_DESTINATION_TOO_SHORT; if (dst == 0) return ACEXML_INVALID_ARGS; *dst = 0xf0 | (src / 0x40000); *(dst+1) = 0x80 | ((src % 0x40000) / 0x1000); *(dst+2) = 0x80 | ((src % 0x1000) / 0x40); *(dst+3) = 0x80 | (src % 0x40); return 4; } return ACEXML_NON_UNICODE; }
int ACEXML_Transcoder::ucs42utf16 (ACEXML_UCS4 src, ACEXML_UTF16 *dst, size_t len) { if (dst == 0) return ACEXML_INVALID_ARGS; if (src < 0x10000) { if (len < 1) return ACEXML_DESTINATION_TOO_SHORT; if (src >= 0xD800 && src < 0xE000) return ACEXML_NON_UNICODE; // Surrogates are not valid unicode value *dst = ACE_static_cast (ACEXML_UTF16, src); return 1; } else if (src >= 0x100000 && src < 0x110000) // Scalar values are encoded into surrogates { if (len < 2) return ACEXML_DESTINATION_TOO_SHORT; *dst = 0xD800 | (src / 0x400); *(dst+1) = 0xDC00 | (src % 0x400); return 2; } return ACEXML_NON_UNICODE; }
int Request_Handler::handle_input (ACE_HANDLE fd) { ACE_TCHAR buffer[BUFSIZ]; ACE_TCHAR len = 0; ssize_t result = this->peer ().recv (&len, sizeof (ACE_TCHAR)); if (result > 0 && this->peer ().recv_n (buffer, len * sizeof (ACE_TCHAR)) == ACE_static_cast (ssize_t, len * sizeof (ACE_TCHAR))) { ++this->nr_msgs_rcvd_; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) svr input; fd: 0x%x; input: %s\n"), fd, buffer)); if (ACE_OS::strcmp (buffer, ACE_TEXT ("shutdown")) == 0) ACE_Reactor::end_event_loop (); return 0; } else ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Request_Handler: 0x%x peer closed (0x%x)\n"), this, fd)); return -1; }
int Service_Reporter::handle_input (ACE_HANDLE) { ACE_SOCK_Stream peer_stream; acceptor_.accept (peer_stream); ACE_Service_Repository_Iterator iterator (*ACE_Service_Repository::instance (), 0); for (const ACE_Service_Type *st; iterator.next (st) != 0; iterator.advance ()) { iovec iov[3]; iov[0].iov_base = ACE_const_cast (char *, st->name ()); iov[0].iov_len = ACE_OS::strlen (st->name ()) * sizeof (ACE_TCHAR); const ACE_TCHAR *state = st->active () ? ACE_TEXT (" (active) ") : ACE_TEXT (" (paused) "); iov[1].iov_base = ACE_const_cast (char *, state); iov[1].iov_len = ACE_OS::strlen (state) * sizeof (ACE_TCHAR); ACE_TCHAR *report = 0; // Ask info() to allocate buffer int len = st->type ()->info (&report, 0); iov[2].iov_base = ACE_static_cast (char *, report); iov[2].iov_len = ACE_static_cast (size_t, len); iov[2].iov_len *= sizeof (ACE_TCHAR); peer_stream.sendv_n (iov, 3); ACE::strdelete (report); } peer_stream.close (); return 0; }
ACE_UINT32 High_Priority_Synchronized_Task:: average_context_switch_time () const { return iterations_ > 0 ? ACE_static_cast (ACE_UINT32, total_time_ / iterations_) : 0; }
template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i (void) { ACE_TRACE ("ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i"); if (this->map_man_->table_ == 0) return -1; else if (this->index_ == ACE_static_cast (ssize_t, this->map_man_->total_size_)) { this->index_--; return this->reverse_i (); } else if (this->index_ < 0) return 0; this->next_ = this->next_->prev_; if (this->next_ == &this->map_man_->table_[this->index_]) { while (--this->index_ >= 0) { this->next_ = this->map_man_->table_[this->index_].prev_; if (this->next_ != &this->map_man_->table_[this->index_]) break; } } return this->index_ >= 0; }
int ACE_SV_Semaphore_Simple::open (key_t k, int flags, int initial_value, u_short n, int perms) { ACE_TRACE ("ACE_SV_Semaphore_Simple::open"); union semun ivalue; if (k == IPC_PRIVATE || k == ACE_static_cast (key_t, ACE_INVALID_SEM_KEY)) return -1; ivalue.val = initial_value; this->key_ = k; this->sem_number_ = n; this->internal_id_ = ACE_OS::semget (this->key_, n, perms | flags); if (this->internal_id_ == -1) return -1; if (ACE_BIT_ENABLED (flags, IPC_CREAT)) for (int i = 0; i < n; i++) if (ACE_OS::semctl (this->internal_id_, i, SETVAL, ivalue) == -1) return -1; return 0; }
int handle_output (ACE_HANDLE handle) { ACE_DEBUG ((LM_DEBUG, "Different_Handler::handle_output\n")); // Add for reading int result = ACE_Reactor::instance ()->mask_ops (this, ACE_Event_Handler::READ_MASK, ACE_Reactor::ADD_MASK); ACE_ASSERT (result != -1); ACE_Reactor_Mask old_masks = ACE_Event_Handler::WRITE_MASK | ACE_Event_Handler::EXCEPT_MASK; ACE_ASSERT (old_masks == ACE_static_cast (ACE_Reactor_Mask, result)); // Get new masks result = ACE_Reactor::instance ()->mask_ops (this, ACE_Event_Handler::NULL_MASK, ACE_Reactor::GET_MASK); ACE_ASSERT (result != -1); ACE_Reactor_Mask current_masks = ACE_Event_Handler::READ_MASK | ACE_Event_Handler::WRITE_MASK | ACE_Event_Handler::EXCEPT_MASK; ACE_ASSERT (current_masks == ACE_static_cast (ACE_Reactor_Mask, result)); // Remove for writing ACE_Reactor_Mask mask = ACE_Event_Handler::WRITE_MASK | ACE_Event_Handler::DONT_CALL; result = ACE_Reactor::instance ()->remove_handler (this, mask); ACE_ASSERT (result == 0); // Write to the pipe; this causes handle_input to get called. if (!write_to_pipe_in_main) write_to_pipe (this->pipe_); return 0; }
Tester::Tester (void) : seed_ (ACE_static_cast(ACE_RANDR_TYPE,ACE_OS::time (0))) , lowest_sequence_number_ (0) , next_expected_ (0) { // Initialize the stack... this->reordering_.next (this); this->proxy_.set_tester (this); }
ACE_MEM_Addr::ACE_MEM_Addr (const ACE_TCHAR port_number[]) : ACE_Addr (AF_INET, sizeof (ACE_MEM_Addr)) { ACE_TRACE ("ACE_MEM_Addr::ACE_MEM_Addr"); u_short pn = ACE_static_cast (u_short, ACE_OS::strtoul (port_number, NULL, 10)); this->initialize_local (pn); }
int ACE_MEM_Addr::string_to_addr (const ACE_TCHAR s[]) { ACE_TRACE ("ACE_MEM_Addr::string_to_addr"); u_short pn = ACE_static_cast (u_short, ACE_OS::strtoul (s, NULL, 10)); return this->set (pn); }
Tester::Tester (void) : seed_ (ACE_static_cast(ACE_RANDR_TYPE,ACE_OS::time (0))) , sequence_number_generator_ (0) { // Initialize the stack... this->retransmission_.next (this); for (size_t i = 0; i != nproxy; ++i) { this->proxy_[i].set_tester (this); this->proxy_[i].joined (1); } }
void ErrorTraceHelper::toString (ACSErr::ErrorTrace * c, int level, std::ostringstream &oss){ oss << "Error Trace Level : " << level << std::endl; char ctp[21]; long sec_ = ACE_static_cast(CORBA::ULongLong, c->timeStamp) / ACE_static_cast(ACE_UINT32, 10000000u) - ACE_UINT64_LITERAL(0x2D8539C80); long usec_ = (c->timeStamp % 10000000u) / 10; time_t tt(sec_); struct tm *utc_p = ACE_OS::gmtime(&tt); ACE_OS::strftime(ctp, sizeof(ctp), "%Y-%m-%dT%H:%M:%S.", utc_p); oss << " " << ctp << std::setfill('0') << std::setw(3) << usec_/1000; oss << " in " << c->routine << " of file " << c->file << " at line " << c->lineNum << std::endl; oss << " HostName:" << c->host << ", process:" << c->process << " Thread " << c->thread << "," << std::endl; oss << " Severity=" << c->severity; oss << " type=" << c->errorType << " code=" << c->errorCode << " description:" << c->shortDescription << std::endl; for (unsigned int j=0; j<c->data.length(); j++) oss << " data[" << j << "] : " << c->data[j].name << " = " << c->data[j].value << std::endl; return; }
int send_unicast (const ACE_INET_Addr &to) { const char *message = "this is the message!\n"; ACE_INET_Addr my_addr (ACE_static_cast (u_short, 10101)); ACE_SOCK_Dgram udp (my_addr); ssize_t sent = udp.send (message, ACE_OS_String::strlen (message) + 1, to); udp.close (); if (sent == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("send")), -1); return 0; }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("Semaphore_Test")); #if defined (ACE_HAS_THREADS) parse_args (argc, argv); ACE_OS::srand (ACE_OS::time (0L)); # if !defined (ACE_HAS_STHREADS) && !defined (ACE_HAS_POSIX_SEM) //Test timed waits. for (size_t i = 0; i < test_timeout_count; i++) if (test_timeout () != 0) test_result = 1; # endif /* ACE_HAS_STHREADS && ACE_HAS_POSIX_SEM */ // Release the semaphore a certain number of times. s.release (n_release_count); if (ACE_Thread_Manager::instance ()->spawn_n (ACE_static_cast (size_t, n_workers), ACE_THR_FUNC (worker), 0, THR_NEW_LWP) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("spawn_n")), 1); ACE_Thread_Manager::instance ()->wait (); # if !defined (ACE_HAS_STHREADS) && !defined (ACE_HAS_POSIX_SEM) size_t percent = (timeouts * 100) / (n_workers * n_iterations); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Worker threads timed out %d percent of the time\n"), percent)); # endif /* ACE_HAS_STHREADS && ACE_HAS_POSIX_SEM */ ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Semaphore Test successful\n"))); #else ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); ACE_ERROR ((LM_INFO, ACE_TEXT ("Threads not supported on this platform\n"))); #endif /* ACE_HAS_THREADS */ ACE_END_TEST; return test_result; }
key_t ACE_SV_Semaphore_Simple::name_2_key (const char *name) { ACE_TRACE ("ACE_SV_Semaphore_Simple::name_2_key"); if (name == 0) { errno = EINVAL; return ACE_static_cast (key_t, ACE_INVALID_SEM_KEY); } // Basically "hash" the values in the <name>. This won't // necessarily guarantee uniqueness of all keys. // But (IMHO) CRC32 is good enough for most purposes (Carlos) return (key_t) ACE::crc32 (name); }
ssize_t ACE_UPIPE_Stream::send (const char *buffer, size_t n, ACE_Time_Value *timeout) { ACE_TRACE ("ACE_UPIPE_Stream::send"); ACE_Message_Block *mb_p; ACE_NEW_RETURN (mb_p, ACE_Message_Block (n), -1); mb_p->copy (buffer, n); return this->stream_.put (mb_p, timeout) == -1 ? -1 : ACE_static_cast (ssize_t, n); }
void PConnectionManager::destroy_connection(int index) { ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, monitor, this->lock_); ACE_ASSERT(ACE_static_cast(u_int,index) < MAX_CONNECTIONS); PConnection * connection = this->list_connections_[index]; if (!connection) return; this->total_snd_ += connection->get_total_snd(); this->total_rcv_ += connection->get_total_rcv(); this->total_w_ += connection->get_total_w(); this->total_r_ += connection->get_total_r(); this->factory_.destroy_protocol (connection->protocol ()); connection->set_protocol (0); this->num_connections_--; this->list_connections_[index] = 0; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) %s=%d: DEL %s=%d S=%d(%d+%d) R=%d(%d+%d)\n"), this->get_name(), this->num_connections_, connection->get_name(), index, connection->get_total_snd(), connection->get_total_w(), connection->get_ref_cnt_w(), connection->get_total_rcv(), connection->get_total_r(), connection->get_ref_cnt_r())); connection->set_manager (0,-1); this->factory_.destroy_connection (connection) ; if (this->is_safe_to_delete()) this->task().signal_main(); }
int ACEXML_Transcoder::utf162utf8 (ACEXML_UTF16 src, ACEXML_UTF8 *dst, size_t len) { // Check for valid argument first... if (dst == 0) return ACEXML_INVALID_ARGS; if (src < 0x80) { if (len < 1) return ACEXML_DESTINATION_TOO_SHORT; *dst = ACE_static_cast (ACEXML_UTF8, src); return 1; } else if (src < 0x800) { if (len < 2) return ACEXML_DESTINATION_TOO_SHORT; *dst = 0xc0 | (src / 0x40); *(dst+1) = 0x80 | (src % 0x40); return 2; } else { if (len < 3) return ACEXML_DESTINATION_TOO_SHORT; // Surrogates (0xD800 - 0xDFFF) are not valid unicode values if (src >= 0xD800 && src < 0xE000) return ACEXML_IS_SURROGATE; *dst = 0xe0 | (src / 0x1000); *(dst+1) = 0x80 | ((src % 0x1000) / 0x40); *(dst+2) = 0x80 | (src % 0x40); return 3; } ACE_NOTREACHED (return ACEXML_NON_UNICODE;) }
static void test_duplicates (size_t count) { size_t duplicates = 0; size_t sets = 0; size_t clears = 0; ACE_Handle_Set handle_set; ACE_OS::srand (ACE_OS::time (0L)); for (size_t i = 0; i < count; i++) { size_t handle = ACE_static_cast (size_t, ACE_OS::rand () % ACE_Handle_Set::MAXSIZE); if (ACE_ODD (handle)) { if (handle_set.is_set ((ACE_HANDLE) handle)) duplicates++; handle_set.set_bit ((ACE_HANDLE) handle); sets++; } else { if (handle_set.is_set ((ACE_HANDLE) handle)) duplicates--; handle_set.clr_bit ((ACE_HANDLE) handle); clears++; } } ACE_ASSERT (count == sets + clears); ACE_ASSERT (handle_set.num_set () + duplicates == sets); }
int Synchronized_Suspend_Resume_Test::svc () { #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Synchronized_Suspend_Resume_Test::svc (), entering")); ACE_hthread_t thread_id; ACE_Thread_Manager::instance ()->thr_self (thread_id); ACE_DEBUG ((LM_DEBUG, "; thread ID is %u\n", thread_id)); #endif /* ACE_DEBUG_CST */ { Mutex_Acquire_Release_Test mutex_acquire_release_test (num_iterations); mutex_acquire_release_test.svc (); mutex_acquire_release_time_ = ACE_static_cast (ACE_UINT32, mutex_acquire_release_test.elapsed_time () / num_iterations); #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "mutex_acquire_release: %u nsec\n", mutex_acquire_release_time_)); #endif /* ACE_DEBUG_CST */ } high_.ready (); #if ACE_DEBUG_CST > 0 int priority, high_priority; ACE_OS::thr_getprio (thread_id, priority); ACE_OS::thr_getprio (high_.thread_id (), high_priority); ACE_DEBUG ((LM_DEBUG, "Synchronized_Suspend_Resume_Test::svc (), priority is %d, " ", high thread priority is %d\n", priority, high_priority)); #endif /* ACE_DEBUG_CST */ // For information: the cost of the just the loop itself below, // without the suspend and resume calls, on a 166 MHz Ultrasparc // is about 12.3 nanoseconds per iteration. ACE_UINT32 i; for (i = 0; i < iterations_; ++i) { #if ACE_DEBUG_CST > 0 if (i % (iterations_ >= 10 ? iterations_ / 10 : 1) == 0) { ACE_DEBUG ((LM_DEBUG, "Synchronized_Suspend_Resume_Test::svc (), iteration " "%d, continue high-priority thread %u\n", i, high_.thread_id ())); } #endif /* ACE_DEBUG_CST */ { // Acquire the mutex so that the high priority thread will // block after we signal it via the condition variable. ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, mutex_, -1); // Release the semaphore so that the high priority thread can // proceed. if (sem_.release () != 0) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "sem_.release"), -1); timer_.start (); // Release the mutex so that the high priority thread can // proceed. The ACE_GUARD_RETURN macro implicity releases // the mutex. } } high_.done (); // The high priority thread will be block on the semaphore, so // release it. if (sem_.release () != 0) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "sem_.release"), -1); #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Synchronized_Suspend_Resume_Test::svc: told high priority " "task to terminate\n")); #endif /* ACE_DEBUG_CST */ // Resume the thread until thr_continue fails, indicating that it has // finished. for (i = 0; i < 10000 && ! ACE_OS::thr_continue (high_.thread_id ()); ++i) /* null */; #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Synchronized_Suspend_Resume_Test::svc, finishing\n")); #endif /* ACE_DEBUG_CST */ return 0; }
int main (int argc, char* argv[]) { ACE_Get_Opt get_opt (argc, argv, "n:l:pftahmxe"); int c; size_t iteration = 10; Profiler profiler = 0; const char *profile_name = 0 ; while ((c=get_opt ()) != -1) { switch (c) { case 'n': iteration = ACE_OS::atoi (get_opt.optarg); break; case 'l': MULTIPLY_FACTOR = ACE_static_cast (size_t, ACE_OS::atoi (get_opt.optarg)); break; case 'p': // test ACE_Process.spawn () profiler = prof_ace_process; profile_name = "ACE_Process.spawn ()"; break; case 'f': // test fork () profiler = prof_fork; profile_name = "fork ()"; break; case 't': // test native thread creation profiler = prof_native_thread; profile_name = "native threads"; break; case 'a': // test ACE_OS::thr_create profiler = prof_ace_os_thread; profile_name = "ACE_OS::thr_create ()"; break; case 'm': profiler = prof_tm_thread; profile_name = "ACE_Thread_Manager::spawn_n ()"; break; case 'x': profiler = prof_mutex_base; profile_name = "ACE_Thread_Mutex Baseline"; break; case 'h': // use high resolution timer ACE_High_Res_Timer::get_env_global_scale_factor (); break; case 'e': do_exec_after_fork = 1; break; default: break; } } if (profiler == 0) ACE_ERROR_RETURN ((LM_ERROR, "Usage: childbirth_time {-p|-f|-t|-a|-m|-x} [-n ###] [-L ###] [-h] [-e]\n"), 1); else { double time = profiler (iteration); if (time > 0) ACE_DEBUG ((LM_DEBUG, "Average performance of %d iterations of %s: %.0f usec\n", iteration * MULTIPLY_FACTOR, profile_name, time * 1e6)); } return 0; }
int ACE_RMCast_Reassembly_Tester::svc (void) { for (int iteration = 0; iteration != 50; ++iteration) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) iteration %d\n"), iteration)); ACE_UINT32 sequence_number = this->next_sequence_number (); { ACE_Message_Block received; const size_t fragment_size = 128; ACE_UINT32 n = 32 * fragment_size; ACE_Message_Block big_blob (n); big_blob.wr_ptr (n); this->initialize (&big_blob); // Use an ACT to store the results in <received> ACE_Message_Block *received_pointer = &received; ACE_OS::memcpy (big_blob.rd_ptr (), &received_pointer, sizeof(received_pointer)); for (size_t offset = 0; offset < n; offset += fragment_size) { if (this->put_fragment (sequence_number, offset, fragment_size, &big_blob) == -1) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Error in put_fragment\n"))); return -1; } } if (this->compare (&received, &big_blob) == -1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Mismatched big_blob data\n")), -1); } } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) iteration %d, first test passed\n"), iteration)); sequence_number = this->next_sequence_number (); { ACE_Message_Block received; const size_t fragment_size = 128; ACE_UINT32 n = 32 * fragment_size; ACE_Message_Block big_blob (n); big_blob.wr_ptr (n); this->initialize (&big_blob); // Use an ACT to store the results in <received> ACE_Message_Block *received_pointer = &received; ACE_OS::memcpy (big_blob.rd_ptr (), &received_pointer, sizeof(received_pointer)); ACE_RANDR_TYPE seed = ACE_static_cast(ACE_RANDR_TYPE, ACE_OS::time (0)); for (int i = 0; i != 100; ++i) { size_t offset = ACE_OS::rand_r (seed) % n; if (offset >= n) { offset = n/2; } if (this->put_fragment (sequence_number, offset, fragment_size, &big_blob) == -1) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Error in put_fragment\n"))); return -1; } } for (size_t offset = 0; offset < n; offset += fragment_size) { if (this->put_fragment (sequence_number, offset, fragment_size, &big_blob) == -1) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Error in put_fragment\n"))); return -1; } } if (this->compare (&received, &big_blob) == -1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Mismatched random big_blob data\n")), -1); } } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) iteration %d, random test passed\n"), iteration)); } return 0; }
int ACE_Mem_Map::map_it (ACE_HANDLE handle, int length_request, int prot, int share, void *addr, off_t offset, LPSECURITY_ATTRIBUTES sa) { ACE_TRACE ("ACE_Mem_Map::map_it"); #if defined (ACE_LACKS_AUTO_MMAP_REPLACEMENT) // If the system does not replace any previous mappings, then // unmap() before (potentially) mapping to the same location. int unmap_result = this->unmap (); if (unmap_result != 0) return unmap_result; #endif /* ACE_LACKS_AUTO_MMAP_REPLACEMENT */ this->base_addr_ = addr; this->handle_ = handle; #if defined (CHORUS) // Chorus does not support filesize on a shared memory handle. We // assume that <length_> = 0 when <ACE_Mem_Map> is initially // constructed (i.e., before <map_it> is called with a valid // <len_request>). long result = this->length_; if (result == -1) return -1; #else long result = ACE_OS::filesize (this->handle_); #endif /* CHORUS */ // At this point we know <result> is not negative... size_t current_file_length = ACE_static_cast (size_t, result); // Flag to indicate if we need to extend the back store int extend_backing_store = 0; // File length requested by user size_t requested_file_length = 0; // Check <length_request> if (length_request == -1) // Set length to file_request. this->length_ = current_file_length - offset; else { // File length implicitly requested by user requested_file_length = length_request + offset; // Check to see if we need to extend the backing store if (requested_file_length > current_file_length) { // If the length of the mapped region is less than the // length of the file then we force a complete new remapping // by setting the descriptor to ACE_INVALID_HANDLE (closing // down the descriptor if necessary). this->close_filemapping_handle (); // Remember to extend the backing store extend_backing_store = 1; } // Set length to length_request this->length_ = length_request; } // Check if we need to extend the backing store. if (extend_backing_store) { #if !defined (CHORUS) // Remember than write increases the size by one. off_t null_byte_position; if (requested_file_length > 0) // This will make the file size <requested_file_length> null_byte_position = ACE_static_cast (off_t, requested_file_length - 1); else // This will make the file size 1 null_byte_position = 0; if (ACE_OS::pwrite (this->handle_, "", 1, null_byte_position) == -1) return -1; #else // This nonsense is to make this code similar to the above code. size_t actual_file_length; if (requested_file_length > 0) // This will make the file size <requested_file_length> actual_file_length = requested_file_length; else // This will make the file size 1 actual_file_length = 1; if (ACE_OS::ftruncate (this->handle_, actual_file_length) == -1) return -1; #endif /* !CHORUS */ } #if defined (__Lynx__) // Set flag that indicates whether PROT_WRITE has been enabled. write_enabled_ = ACE_BIT_ENABLED (prot, PROT_WRITE); #endif /* __Lynx__ */ #if defined (ACE_USE_MAPPING_NAME) if (ACE_BIT_ENABLED (share, MAP_SHARED)) { # if defined(__MINGW32__) const int max_mapping_name_length = 32; # else const int max_mapping_name_length = 31; # endif /* __MINGW32__ */ ACE_TCHAR file_mapping_name[max_mapping_name_length + 1]; to_mapping_name (file_mapping_name, filename_, max_mapping_name_length + 1); this->base_addr_ = ACE_OS::mmap (this->base_addr_, this->length_, prot, share, this->handle_, offset, &this->file_mapping_, sa, file_mapping_name); } else #endif /* ACE_USE_MAPPING_NAME */ this->base_addr_ = ACE_OS::mmap (this->base_addr_, this->length_, prot, share, this->handle_, offset, &this->file_mapping_, sa); return this->base_addr_ == MAP_FAILED ? -1 : 0; }
int ACE_MEM_Connector::connect (ACE_MEM_Stream &new_stream, const ACE_INET_Addr &remote_sap, ACE_Time_Value *timeout, const ACE_Addr &local_sap, int reuse_addr, int flags, int perms, int protocol) { ACE_TRACE ("ACE_MEM_Connector::connect"); if (!this->address_.same_host (remote_sap)) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("(%P|%t) MEM_Connector can't connect ") ACE_LIB_TEXT ("to %s:%d which is not a local endpoint"), remote_sap.get_host_name (), remote_sap.get_port_number ()), -1); else this->address_.set_port_number (remote_sap.get_port_number ()); ACE_SOCK_Stream temp_stream; if (ACE_SOCK_Connector::connect (temp_stream, this->address_.get_local_addr (), timeout, local_sap, reuse_addr, flags, perms, PF_INET, protocol) == -1) ACE_ERROR_RETURN ((LM_DEBUG, ACE_LIB_TEXT ("ACE_MEM_Connector::connect error connecting to socket\n")), -1); ACE_HANDLE new_handle = temp_stream.get_handle (); new_stream.set_handle (new_handle); new_stream.disable (ACE_NONBLOCK); // Do not close the handle. // now we should setup the mmap malloc. ACE_TCHAR buf[MAXPATHLEN]; // @@ Need to handle timeout here. ACE_INT16 server_strategy = ACE_MEM_IO::Reactive; // Receive the signaling strategy theserver support. if (ACE::recv (new_handle, &server_strategy, sizeof (ACE_INT16)) == -1) ACE_ERROR_RETURN ((LM_DEBUG, ACE_LIB_TEXT ("ACE_MEM_Connector::connect error receiving strategy\n")), -1); // If either side don't support MT, we will not use it. #if defined (ACE_WIN32) || !defined (_ACE_USE_SV_SEM) if (! (this->preferred_strategy_ == ACE_MEM_IO::MT && server_strategy == ACE_MEM_IO::MT)) #endif /* ACE_WIN32 || !_ACE_USE_SV_SEM */ server_strategy = ACE_MEM_IO::Reactive; if (ACE::send (new_handle, &server_strategy, sizeof (ACE_INT16)) == -1) ACE_ERROR_RETURN ((LM_DEBUG, ACE_LIB_TEXT ("ACE_MEM_Connector::connect error sending strategy\n")), -1); ACE_INT16 buf_len; // Byte-order is not a problem for this read. if (ACE::recv (new_handle, &buf_len, sizeof (buf_len)) == -1) ACE_ERROR_RETURN ((LM_DEBUG, ACE_LIB_TEXT ("ACE_MEM_Connector::connect error receiving shm filename length\n")), -1); if (ACE::recv (new_handle, buf, buf_len) == -1) ACE_ERROR_RETURN ((LM_DEBUG, ACE_LIB_TEXT ("ACE_MEM_Connector::connect error receiving shm filename.\n")), -1); if (new_stream.init (buf, ACE_static_cast (ACE_MEM_IO::Signal_Strategy, server_strategy), &this->malloc_options_) == -1) return -1; return 0; }
// ---------------------------------------------------------- void LogSvcHandler::log(const LogRecord& lr) { //may need to make some changes to the message if the CORBA //logging service is down std::string message = lr.message; //if it's a trace we set the message to be "". if((lr.priority==LM_TRACE) && (message==FIELD_UNAVAILABLE)) { message = ""; } //add a newline if the logging service is unavailable if(LoggingProxy::isInit()==false) { message = message + '\n'; } LoggingProxy::File(lr.file.c_str()); LoggingProxy::Line(lr.line); //only set the logging flags if the priority is debug or trace if((lr.priority==LM_DEBUG)||(lr.priority==LM_TRACE)) { LoggingProxy::Flags(LM_SOURCE_INFO | LM_RUNTIME_CONTEXT); } //if the field is available if(lr.method!=FIELD_UNAVAILABLE) { //set the routine name. LoggingProxy::Routine(lr.method.c_str()); } else { LoggingProxy::Routine(""); } if(lr.priority == LM_SHUTDOWN) message = " -- ERROR in the priority of this message, please check the source --" + message; //set the component/container/etc name LoggingProxy::SourceObject(sourceObjectName_m.c_str()); //figure out the time long sec_ = ACE_static_cast(CORBA::ULongLong, lr.timeStamp) / ACE_static_cast(ACE_UINT32, 10000000u) - ACE_UINT64_LITERAL(0x2D8539C80); long usec_ = (lr.timeStamp % 10000000u) / 10; ACE_Time_Value time(sec_, usec_); //create the ACE log message /** * @todo Here there was an assignment to * a local variable never used. * Why was that? * I have now commented it out * int __ace_error = ACE_Log_Msg::last_error_adapter(); */ ACE_Log_Msg::last_error_adapter(); ACE_Log_Msg *ace___ = ACE_Log_Msg::instance(); //create the ACE log record using the message ACE_Log_Record log_record_(acs2acePriority(lr.priority), time, 0); log_record_.msg_data(message.c_str()); // set private flags const int prohibitLocal = getLocalLevel() == LM_SHUTDOWN || lr.priority < getLocalLevel() ? 1 : 0; const int prohibitRemote = getRemoteLevel() == LM_SHUTDOWN ||lr.priority < getRemoteLevel() ? 2 : 0; LoggingProxy::PrivateFlags(prohibitLocal | prohibitRemote); LoggingProxy::LogLevelLocalType(getLocalLevelType()); LoggingProxy::LogLevelRemoteType(getRemoteLevelType()); ace___->log(log_record_, 0); }
int High_Priority_Synchronized_Task::svc () { #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "High_Priority_Synchronized_Task::svc (), entering")); #endif /* ACE_DEBUG_CST */ ACE_Thread_Manager::instance ()->thr_self (thread_id_); ACE_UINT32 mutex_acquire_release_time = 0; { Mutex_Acquire_Release_Test mutex_acquire_release_test (num_iterations); mutex_acquire_release_test.svc (); mutex_acquire_release_time = ACE_static_cast (ACE_UINT32, mutex_acquire_release_test.elapsed_time () / num_iterations); #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "mutex_acquire_release: %u nsec\n", mutex_acquire_release_time)); #endif /* ACE_DEBUG_CST */ } initialized_.release (); #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "; thread ID is %u\n", thread_id_)); #endif /* ACE_DEBUG_CST */ for (ACE_UINT32 i = 0; ! terminate_; ++i) { #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "High_Priority_Synchronized_Task::svc, wait on sem (" "%u)\n", thread_id_)); #endif /* ACE_DEBUG_CST */ if (sem_.acquire () != 0) { ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "sem_.acquire"), -1); } { // Block on the mutex. ACE_GUARD_RETURN (ACE_Thread_Mutex, guard, mutex_, -1); timer_.stop (); ++iterations_; ACE_hrtime_t nsec; timer_.elapsed_time (nsec); const ACE_UINT32 context_switch_time = ACE_U64_TO_U32 (nsec) >= mutex_acquire_release_time ? ACE_U64_TO_U32 (nsec) - mutex_acquire_release_time : 0; total_time_ += context_switch_time; // Release the mutex so that the low priority thread can // proceed. The ACE_GUARD_RETURN macro implicity releases the // mutex. } #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "High_Priority_Synchronized_Task::svc, resumed (%u)\n", thread_id_)); #endif /* ACE_DEBUG_CST */ } #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "High_Priority_Synchronized_Task::svc, finishing\n")); #endif /* ACE_DEBUG_CST */ return 0; }