ACE_POSIX_AIOCB_Proactor Class Reference

This Proactor makes use of Asynchronous I/O Control Blocks (AIOCB) to notify/get the completion status of the operations issued. More...

#include <POSIX_Proactor.h>

Inheritance diagram for ACE_POSIX_AIOCB_Proactor:

[legend]Collaboration diagram for ACE_POSIX_AIOCB_Proactor:

[legend]List of all members.

Public Member Functions
	ACE_POSIX_AIOCB_Proactor (size_t nmaxop=ACE_AIO_DEFAULT_SIZE)
virtual Proactor_Type	get_impl_type (void)
virtual	~ACE_POSIX_AIOCB_Proactor (void)
	Destructor.
virtual int	close (void)
	Close down the Proactor.
virtual int	handle_events (ACE_Time_Value &wait_time)
virtual int	handle_events (void)
virtual int	post_completion (ACE_POSIX_Asynch_Result *result)
	Post a result to the completion port of the Proactor.
virtual int	start_aio (ACE_POSIX_Asynch_Result *result, ACE_POSIX_Proactor::Opcode op)
virtual int	cancel_aio (ACE_HANDLE h)
Protected Member Functions
	ACE_POSIX_AIOCB_Proactor (size_t nmaxop, ACE_POSIX_Proactor::Proactor_Type ptype)
virtual int	get_result_status (ACE_POSIX_Asynch_Result *asynch_result, int &error_status, size_t &transfer_count)
int	create_result_aiocb_list (void)
	Create aiocb list.
int	delete_result_aiocb_list (void)
void	create_notify_manager (void)
void	delete_notify_manager (void)
void	check_max_aio_num (void)
void	set_notify_handle (ACE_HANDLE h)
	To identify requests from Notify_Pipe_Manager.
int	handle_events_i (u_long milli_seconds)
int	start_deferred_aio (void)
	Start deferred AIO if necessary.
virtual int	cancel_aiocb (ACE_POSIX_Asynch_Result *result)
	Cancel running or deferred AIO.
ACE_POSIX_Asynch_Result *	find_completed_aio (int &error_status, size_t &transfer_count, size_t &index, size_t &count)
	Extract the results of aio.
virtual ssize_t	allocate_aio_slot (ACE_POSIX_Asynch_Result *result)
	Find free slot to store result and aiocb pointer.
virtual int	start_aio_i (ACE_POSIX_Asynch_Result *result)
	Initiate an aio operation.
virtual int	notify_completion (int sig_num)
int	putq_result (ACE_POSIX_Asynch_Result *result)
	Put "post_completed" result into the internal queue.
ACE_POSIX_Asynch_Result *	getq_result (void)
	Get "post_completed" result from the internal queue.
int	clear_result_queue (void)
	Clear the internal results queue.
int	process_result_queue (void)
	Process the internal results queue.
Protected Attributes
ACE_AIOCB_Notify_Pipe_Manager *	aiocb_notify_pipe_manager_
aiocb **	aiocb_list_
ACE_POSIX_Asynch_Result **	result_list_
size_t	aiocb_list_max_size_
	To maintain the maximum size of the array (list).
size_t	aiocb_list_cur_size_
	To maintain the current size of the array (list).
ACE_SYNCH_MUTEX	mutex_
	Mutex to protect work with lists.
ACE_HANDLE	notify_pipe_read_handle_
size_t	num_deferred_aiocb_
size_t	num_started_aio_
	Number active,i.e. running requests.
ACE_Unbounded_Queue< ACE_POSIX_Asynch_Result * >	result_queue_
	Queue which keeps "post_completed" ACE_POSIX_Asynch_Result's.
Friends
class	ACE_AIOCB_Notify_Pipe_Manager
	Handler needs to call application specific code.
class	ACE_POSIX_Asynch_Operation
class	ACE_POSIX_Asynch_Accept
class	ACE_POSIX_Asynch_Connect

---

Detailed Description

This Proactor makes use of Asynchronous I/O Control Blocks (AIOCB) to notify/get the completion status of the operations issued.

Definition at line 327 of file POSIX_Proactor.h.

---

Constructor & Destructor Documentation

ACE_POSIX_AIOCB_Proactor::ACE_POSIX_AIOCB_Proactor (  size_t  nmaxop = ACE_AIO_DEFAULT_SIZE  )

Constructor defines max number asynchronous operations which can be started at the same time Definition at line 782 of file POSIX_Proactor.cpp. References check_max_aio_num(), create_notify_manager(), create_result_aiocb_list(), ACE_POSIX_Proactor::get_asynch_pseudo_task(), and ACE_Asynch_Pseudo_Task::start(). : aiocb_notify_pipe_manager_ (0), aiocb_list_ (0), result_list_ (0), aiocb_list_max_size_ (max_aio_operations), aiocb_list_cur_size_ (0), notify_pipe_read_handle_ (ACE_INVALID_HANDLE), num_deferred_aiocb_ (0), num_started_aio_ (0) { // Check for correct value for max_aio_operations check_max_aio_num (); this->create_result_aiocb_list (); this->create_notify_manager (); // start pseudo-asynchronous accept task // one per all future acceptors this->get_asynch_pseudo_task().start (); }

ACE_POSIX_AIOCB_Proactor::~ACE_POSIX_AIOCB_Proactor (  void   )  [virtual]

Destructor. Definition at line 827 of file POSIX_Proactor.cpp. References close(). { this->close(); }

ACE_POSIX_AIOCB_Proactor::ACE_POSIX_AIOCB_Proactor (  size_t  nmaxop, ACE_POSIX_Proactor::Proactor_Type  ptype )  [protected]

Special constructor for ACE_SUN_Proactor and ACE_POSIX_SIG_Proactor Definition at line 806 of file POSIX_Proactor.cpp. References check_max_aio_num(), and create_result_aiocb_list(). : aiocb_notify_pipe_manager_ (0), aiocb_list_ (0), result_list_ (0), aiocb_list_max_size_ (max_aio_operations), aiocb_list_cur_size_ (0), notify_pipe_read_handle_ (ACE_INVALID_HANDLE), num_deferred_aiocb_ (0), num_started_aio_ (0) { //check for correct value for max_aio_operations this->check_max_aio_num (); this->create_result_aiocb_list (); // @@ We should create Notify_Pipe_Manager in the derived class to // provide correct calls for virtual functions !!! }

---

Member Function Documentation

ssize_t ACE_POSIX_AIOCB_Proactor::allocate_aio_slot (  ACE_POSIX_Asynch_Result *  result  )  [protected, virtual]

Find free slot to store result and aiocb pointer. Reimplemented in ACE_POSIX_CB_Proactor. Definition at line 1376 of file POSIX_Proactor.cpp. References ACE_ERROR_RETURN, aiocb_list_max_size_, LM_ERROR, notify_pipe_read_handle_, and result_list_. Referenced by ACE_POSIX_CB_Proactor::allocate_aio_slot(), and start_aio(). { size_t i = 0; // we reserve zero slot for ACE_AIOCB_Notify_Pipe_Manager // so make check for ACE_AIOCB_Notify_Pipe_Manager request if (notify_pipe_read_handle_ == result->aio_fildes) // Notify_Pipe ? { // should be free, if (result_list_[i] != 0) // only 1 request { // is allowed errno = EAGAIN; ACE_ERROR_RETURN ((LM_ERROR, "%N:%l:(%P | %t)::\n" "ACE_POSIX_AIOCB_Proactor::allocate_aio_slot:" "internal Proactor error 0\n"), -1); } } else //try to find free slot as usual, but starting from 1 { for (i= 1; i < this->aiocb_list_max_size_; i++) if (result_list_[i] == 0) break; } if (i >= this->aiocb_list_max_size_) ACE_ERROR_RETURN ((LM_ERROR, "%N:%l:(%P | %t)::\n" "ACE_POSIX_AIOCB_Proactor::allocate_aio_slot:" "internal Proactor error 1\n"), -1); //setup OS notification methods for this aio result->aio_sigevent.sigev_notify = SIGEV_NONE; return static_cast<ssize_t> (i); }

int ACE_POSIX_AIOCB_Proactor::cancel_aio (  ACE_HANDLE  h  )  [virtual]

This method should be called from ACE_POSIX_Asynch_Operation::cancel() instead of usual ::aio_cancel. For all deferred AIO requests with handle "h" it removes its from the lists and notifies user. For all running AIO requests with handle "h" it calls ::aio_cancel. According to the POSIX standards we will receive ECANCELED for all ::aio_canceled AIO requests later on return from ::aio_suspend Implements ACE_POSIX_Proactor. Definition at line 1526 of file POSIX_Proactor.cpp. References ACE_GUARD_RETURN, ACE_TRACE, aiocb_list_, aiocb_list_cur_size_, aiocb_list_max_size_, cancel_aiocb(), num_deferred_aiocb_, putq_result(), result_list_, ACE_POSIX_Asynch_Result::set_bytes_transferred(), and ACE_POSIX_Asynch_Result::set_error(). { // This new method should be called from // ACE_POSIX_Asynch_Operation instead of usual ::aio_cancel // It scans the result_list_ and defines all AIO requests // that were issued for handle "handle" // // For all deferred AIO requests with handle "handle" // it removes its from the lists and notifies user // // For all running AIO requests with handle "handle" // it calls ::aio_cancel. According to the POSIX standards // we will receive ECANCELED for all ::aio_canceled AIO requests // later on return from ::aio_suspend ACE_TRACE ("ACE_POSIX_AIOCB_Proactor::cancel_aio"); int num_total = 0; int num_cancelled = 0; { ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->mutex_, -1)); size_t ai = 0; for (ai = 0; ai < this->aiocb_list_max_size_; ai++) { if (this->result_list_[ai] == 0) // Skip empty slot continue; if (this->result_list_[ai]->aio_fildes != handle) // Not ours continue; num_total++; ACE_POSIX_Asynch_Result *asynch_result = this->result_list_[ai]; if (this->aiocb_list_[ai] == 0) // Canceling a deferred operation { num_cancelled++; this->num_deferred_aiocb_--; this->aiocb_list_[ai] = 0; this->result_list_[ai] = 0; this->aiocb_list_cur_size_--; asynch_result->set_error (ECANCELED); asynch_result->set_bytes_transferred (0); this->putq_result (asynch_result); // we are with locked mutex_ here ! } else // Cancel started aio { int rc_cancel = this->cancel_aiocb (asynch_result); if (rc_cancel == 0) //notification in the future num_cancelled++; //it is OS responsiblity } } } // release mutex_ if (num_total == 0) return 1; // ALLDONE if (num_cancelled == num_total) return 0; // CANCELLED return 2; // NOT CANCELLED }

int ACE_POSIX_AIOCB_Proactor::cancel_aiocb (  ACE_POSIX_Asynch_Result *  result  )  [protected, virtual]

Cancel running or deferred AIO. Definition at line 1598 of file POSIX_Proactor.cpp. Referenced by cancel_aio(), and delete_result_aiocb_list(). { // This method is called from cancel_aio // to cancel a previously submitted AIO request int rc = ::aio_cancel (0, result); // Check the return value and return 0/1/2 appropriately. if (rc == AIO_CANCELED) return 0; else if (rc == AIO_ALLDONE) return 1; else // (rc == AIO_NOTCANCELED) return 2; }

void ACE_POSIX_AIOCB_Proactor::check_max_aio_num (  void   )  [protected]

Define the maximum number of asynchronous I/O requests for the current OS Definition at line 956 of file POSIX_Proactor.cpp. References ACE_AIO_MAX_SIZE, ACE_DEBUG, ACE_LIB_TEXT, aiocb_list_max_size_, LM_DEBUG, ACE::max_handles(), ACE::set_handle_limit(), and ACE_OS::sysconf(). Referenced by ACE_POSIX_AIOCB_Proactor(). { long max_os_aio_num = ACE_OS::sysconf (_SC_AIO_MAX); // Define max limit AIO's for concrete OS // -1 means that there is no limit, but it is not true // (example, SunOS 5.6) if (max_os_aio_num > 0 && aiocb_list_max_size_ > (unsigned long) max_os_aio_num) aiocb_list_max_size_ = max_os_aio_num; #if defined (HPUX) || defined (__FreeBSD__) // Although HPUX 11.00 allows to start 2048 AIO's for all process in // system it has a limit 256 max elements for aio_suspend () It is a // pity, but ... long max_os_listio_num = ACE_OS::sysconf (_SC_AIO_LISTIO_MAX); if (max_os_listio_num > 0 && aiocb_list_max_size_ > (unsigned long) max_os_listio_num) aiocb_list_max_size_ = max_os_listio_num; #endif /* HPUX || __FreeBSD__ */ // check for user-defined value // ACE_AIO_MAX_SIZE if defined in POSIX_Proactor.h if (aiocb_list_max_size_ <= 0 || aiocb_list_max_size_ > ACE_AIO_MAX_SIZE) aiocb_list_max_size_ = ACE_AIO_MAX_SIZE; // check for max number files to open int max_num_files = ACE::max_handles (); if (max_num_files > 0 && aiocb_list_max_size_ > (unsigned long) max_num_files) { ACE::set_handle_limit (aiocb_list_max_size_); max_num_files = ACE::max_handles (); } if (max_num_files > 0 && aiocb_list_max_size_ > (unsigned long) max_num_files) aiocb_list_max_size_ = (unsigned long) max_num_files; ACE_DEBUG ((LM_DEBUG, "(%P | %t) ACE_POSIX_AIOCB_Proactor::Max Number of AIOs=%d\n", aiocb_list_max_size_)); #if defined(__sgi) ACE_DEBUG((LM_DEBUG, ACE_LIB_TEXT( "SGI IRIX specific: aio_init!\n"))); //typedef struct aioinit { // int aio_threads; /* The number of aio threads to start (5) */ // int aio_locks; /* Initial number of preallocated locks (3) */ // int aio_num; /* estimated total simultanious aiobc structs (1000) */ // int aio_usedba; /* Try to use DBA for raw I/O in lio_listio (0) */ // int aio_debug; /* turn on debugging (0) */ // int aio_numusers; /* max number of user sprocs making aio_* calls (5) */ // int aio_reserved[3]; //} aioinit_t; aioinit_t aioinit; aioinit.aio_threads = 10; /* The number of aio threads to start (5) */ aioinit.aio_locks = 20; /* Initial number of preallocated locks (3) */ /* estimated total simultaneous aiobc structs (1000) */ aioinit.aio_num = aiocb_list_max_size_; aioinit.aio_usedba = 0; /* Try to use DBA for raw IO in lio_listio (0) */ aioinit.aio_debug = 0; /* turn on debugging (0) */ aioinit.aio_numusers = 100; /* max number of user sprocs making aio_* calls (5) */ aioinit.aio_reserved[0] = 0; aioinit.aio_reserved[1] = 0; aioinit.aio_reserved[2] = 0; aio_sgi_init (&aioinit); #endif return; }

int ACE_POSIX_AIOCB_Proactor::clear_result_queue (  void   )  [protected]

Clear the internal results queue. Definition at line 1136 of file POSIX_Proactor.cpp. References getq_result(). Referenced by close(). { int ret_val = 0; ACE_POSIX_Asynch_Result* result = 0; while ((result = this->getq_result ()) != 0) { delete result; ret_val++; } return ret_val; }

int ACE_POSIX_AIOCB_Proactor::close (  void   )  [virtual]

Close down the Proactor. Reimplemented from ACE_POSIX_Proactor. Definition at line 840 of file POSIX_Proactor.cpp. References clear_result_queue(), delete_notify_manager(), delete_result_aiocb_list(), ACE_POSIX_Proactor::get_asynch_pseudo_task(), and ACE_Asynch_Pseudo_Task::stop(). Referenced by ~ACE_POSIX_AIOCB_Proactor(), and ACE_POSIX_CB_Proactor::~ACE_POSIX_CB_Proactor(). { // stop asynch accept task this->get_asynch_pseudo_task().stop (); this->delete_notify_manager (); this->clear_result_queue (); return this->delete_result_aiocb_list (); }

void ACE_POSIX_AIOCB_Proactor::create_notify_manager (  void   )  [protected]

Call these methods from derived class when virtual table is built. Definition at line 1042 of file POSIX_Proactor.cpp. References ACE_NEW, and aiocb_notify_pipe_manager_. Referenced by ACE_POSIX_AIOCB_Proactor(). { // Remember! this issues a Asynch_Read // on the notify pipe for doing the Asynch_Accept/Connect. if (aiocb_notify_pipe_manager_ == 0) ACE_NEW (aiocb_notify_pipe_manager_, ACE_AIOCB_Notify_Pipe_Manager (this)); }

int ACE_POSIX_AIOCB_Proactor::create_result_aiocb_list (  void   )  [protected]

Create aiocb list. Definition at line 857 of file POSIX_Proactor.cpp. References ACE_NEW_RETURN, aiocb_list_, aiocb_list_max_size_, and result_list_. Referenced by ACE_POSIX_AIOCB_Proactor(). { if (aiocb_list_ != 0) return 0; ACE_NEW_RETURN (aiocb_list_, aiocb *[aiocb_list_max_size_], -1); ACE_NEW_RETURN (result_list_, ACE_POSIX_Asynch_Result *[aiocb_list_max_size_], -1); // Initialize the array. for (size_t ai = 0; ai < this->aiocb_list_max_size_; ai++) { aiocb_list_[ai] = 0; result_list_[ai] = 0; } return 0; }

void ACE_POSIX_AIOCB_Proactor::delete_notify_manager (  void   )  [protected]

Definition at line 1053 of file POSIX_Proactor.cpp. References aiocb_notify_pipe_manager_. Referenced by close(). { // We are responsible for delete as all pointers set to 0 after // delete, it is save to delete twice delete aiocb_notify_pipe_manager_; aiocb_notify_pipe_manager_ = 0; }

int ACE_POSIX_AIOCB_Proactor::delete_result_aiocb_list (  void   )  [protected]

Call this method from derived class when virtual table is built. Definition at line 878 of file POSIX_Proactor.cpp. References ACE_DEBUG, ACE_ERROR, ACE_LIB_TEXT, aiocb_list_, aiocb_list_max_size_, cancel_aiocb(), get_result_status(), LM_DEBUG, LM_ERROR, result_list_, and ACE_OS::strerror(). Referenced by close(). { if (aiocb_list_ == 0) // already deleted return 0; size_t ai; // Try to cancel all uncomlpeted operarion POSIX systems may have // hidden system threads that still can work with our aiocb's! for (ai = 0; ai < aiocb_list_max_size_; ai++) if (this->aiocb_list_[ai] != 0) // active operation this->cancel_aiocb (result_list_[ai]); int num_pending = 0; for (ai = 0; ai < aiocb_list_max_size_; ai++) { if (this->aiocb_list_[ai] == 0 ) // not active operation continue; // Get the error and return status of the aio_ operation. int error_status = 0; size_t transfer_count = 0; int flg_completed = this->get_result_status (result_list_[ai], error_status, transfer_count); //don't delete uncompleted AIOCB's if (flg_completed == 0) // not completed !!! { num_pending++; #if 0 char * errtxt = ACE_OS::strerror (error_status); if (errtxt == 0) errtxt ="?????????"; char * op = (aiocb_list_[ai]->aio_lio_opcode == LIO_WRITE )? "WRITE":"READ" ; ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT("slot=%d op=%s status=%d xfercnt=%d %s\n"), ai, op, error_status, transfer_count, errtxt)); #endif /* 0 */ } else // completed , OK { delete this->result_list_[ai]; this->result_list_[ai] = 0; this->aiocb_list_[ai] = 0; } } // If it is not possible cancel some operation (num_pending > 0 ), // we can do only one thing -report about this // and complain about POSIX implementation. // We know that we have memory leaks, but it is better than // segmentation fault! ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("ACE_POSIX_AIOCB_Proactor::delete_result_aiocb_list\n") ACE_LIB_TEXT(" number pending AIO=%d\n"), num_pending)); delete [] this->aiocb_list_; this->aiocb_list_ = 0; delete [] this->result_list_; this->result_list_ = 0; return (num_pending == 0 ? 0 : -1); // ?? or just always return 0; }

ACE_POSIX_Asynch_Result * ACE_POSIX_AIOCB_Proactor::find_completed_aio (  int &  error_status, size_t &  transfer_count, size_t &  index, size_t &  count )  [protected]

Extract the results of aio. Definition at line 1256 of file POSIX_Proactor.cpp. References ACE_GUARD_RETURN, aiocb_list_, aiocb_list_cur_size_, aiocb_list_max_size_, get_result_status(), num_started_aio_, result_list_, and start_deferred_aio(). Referenced by handle_events_i(), and ACE_POSIX_CB_Proactor::handle_events_i(). { // parameter index defines initial slot to scan // parameter count tells us how many slots should we scan ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->mutex_, 0)); ACE_POSIX_Asynch_Result *asynch_result = 0; if (num_started_aio_ == 0) // save time return 0; for (; count > 0; index++ , count--) { if (index >= aiocb_list_max_size_) // like a wheel index = 0; if (aiocb_list_[index] == 0) // Dont process null blocks. continue; if (0 != this->get_result_status (result_list_[index], error_status, transfer_count)) // completed break; } // end for if (count == 0) // all processed , nothing found return 0; asynch_result = result_list_[index]; aiocb_list_[index] = 0; result_list_[index] = 0; aiocb_list_cur_size_--; num_started_aio_--; // decrement count active aios index++; // for next iteration count--; // for next iteration this->start_deferred_aio (); //make attempt to start deferred AIO //It is safe as we are protected by mutex_ return asynch_result; }

ACE_POSIX_Proactor::Proactor_Type ACE_POSIX_AIOCB_Proactor::get_impl_type (  void   )  [virtual]

Reimplemented from ACE_POSIX_Proactor. Reimplemented in ACE_POSIX_CB_Proactor. Definition at line 833 of file POSIX_Proactor.cpp. { return PROACTOR_AIOCB; }

int ACE_POSIX_AIOCB_Proactor::get_result_status (  ACE_POSIX_Asynch_Result *  asynch_result, int &  error_status, size_t &  transfer_count )  [protected, virtual]

Check AIO for completion, error and result status Return: 1 - AIO completed , 0 - not completed yet Definition at line 1237 of file POSIX_Proactor.cpp. References EINPROGRESS, and ssize_t. Referenced by delete_result_aiocb_list(), and find_completed_aio(). { transfer_count = 0; // Get the error status of the aio_ operation. error_status = aio_error (asynch_result); if (error_status == EINPROGRESS) return 0; // not completed ssize_t op_return = aio_return (asynch_result); if (op_return > 0) transfer_count = static_cast<size_t> (op_return); // else transfer_count is already 0, error_status reports the error. return 1; // completed }

ACE_POSIX_Asynch_Result * ACE_POSIX_AIOCB_Proactor::getq_result (  void   )  [protected]

Get "post_completed" result from the internal queue. Definition at line 1116 of file POSIX_Proactor.cpp. References ACE_GUARD_RETURN, ACE_SYNCH_MUTEX, and ACE_Unbounded_Queue< ACE_POSIX_Asynch_Result * >::dequeue_head(). Referenced by clear_result_queue(), and process_result_queue(). { ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, 0)); ACE_POSIX_Asynch_Result* result = 0; if (this->result_queue_.dequeue_head (result) != 0) return 0; // don;t waste time if queue is empty - it is normal // or check queue size before dequeue_head // ACE_ERROR_RETURN ((LM_ERROR, // "%N:%l:(%P | %t):%p\n", // "ACE_POSIX_AIOCB_Proactor::getq_result failed"), // 0); return result; }

int ACE_POSIX_AIOCB_Proactor::handle_events (  void   )  [virtual]

Block indefinitely until at least one event is dispatched. Dispatch a single set of events. If elapses before any events occur, return 0. Return 1 on success i.e., when a completion is dispatched, non-zero (-1) on errors and errno is set accordingly. Implements ACE_POSIX_Proactor. Reimplemented in ACE_POSIX_CB_Proactor. Definition at line 1071 of file POSIX_Proactor.cpp. References ACE_INFINITE, and handle_events_i(). { return this->handle_events_i (ACE_INFINITE); }

int ACE_POSIX_AIOCB_Proactor::handle_events (  ACE_Time_Value &  wait_time  )  [virtual]

Dispatch a single set of events. If elapses before any events occur, return 0. Return 1 on success i.e., when a completion is dispatched, non-zero (-1) on errors and errno is set accordingly. Implements ACE_POSIX_Proactor. Reimplemented in ACE_POSIX_CB_Proactor. Definition at line 1063 of file POSIX_Proactor.cpp. References handle_events_i(), and ACE_Time_Value::msec(). { // Decrement <wait_time> with the amount of time spent in the method ACE_Countdown_Time countdown (&wait_time); return this->handle_events_i (wait_time.msec ()); }

int ACE_POSIX_AIOCB_Proactor::handle_events_i (  u_long  milli_seconds  )  [protected]

Dispatch a single set of events. If elapses before any events occur, return 0. Return 1 if a completion dispatched. Return -1 on errors. Reimplemented in ACE_POSIX_CB_Proactor. Definition at line 1170 of file POSIX_Proactor.cpp. References ACE_ERROR, ACE_INFINITE, aiocb_list_, aiocb_list_max_size_, ACE_POSIX_Proactor::application_specific_code(), find_completed_aio(), LM_ERROR, process_result_queue(), timespec::tv_nsec, and timespec::tv_sec. Referenced by handle_events(). { int result_suspend = 0; int retval= 0; if (milli_seconds == ACE_INFINITE) // Indefinite blocking. result_suspend = aio_suspend (aiocb_list_, aiocb_list_max_size_, 0); else { // Block on <aio_suspend> for <milli_seconds> timespec timeout; timeout.tv_sec = milli_seconds / 1000; timeout.tv_nsec = (milli_seconds - (timeout.tv_sec * 1000)) * 1000000; result_suspend = aio_suspend (aiocb_list_, aiocb_list_max_size_, &timeout); } // Check for errors if (result_suspend == -1) { if (errno != EAGAIN && // Timeout errno != EINTR ) // Interrupted call ACE_ERROR ((LM_ERROR, "%N:%l:(%P | %t)::%p\n", "ACE_POSIX_AIOCB_Proactor::handle_events:" "aio_suspend failed\n")); // let continue work // we should check "post_completed" queue } else { size_t index = 0; size_t count = aiocb_list_max_size_; // max number to iterate int error_status = 0; size_t transfer_count = 0; for (;; retval++) { ACE_POSIX_Asynch_Result *asynch_result = find_completed_aio (error_status, transfer_count, index, count); if (asynch_result == 0) break; // Call the application code. this->application_specific_code (asynch_result, transfer_count, 0, // No completion key. error_status); } } // process post_completed results retval += this->process_result_queue (); return retval > 0 ? 1 : 0; }

int ACE_POSIX_AIOCB_Proactor::notify_completion (  int  sig_num  )  [protected, virtual]

Notify queue of "post_completed" ACE_POSIX_Asynch_Results called from post_completion method Reimplemented in ACE_POSIX_CB_Proactor. Definition at line 1077 of file POSIX_Proactor.cpp. References aiocb_notify_pipe_manager_, and ACE_AIOCB_Notify_Pipe_Manager::notify(). Referenced by putq_result(). { ACE_UNUSED_ARG (sig_num); return this->aiocb_notify_pipe_manager_->notify (); }

int ACE_POSIX_AIOCB_Proactor::post_completion (  ACE_POSIX_Asynch_Result *  result  )  [virtual]

Post a result to the completion port of the Proactor. Implements ACE_POSIX_Proactor. Definition at line 1085 of file POSIX_Proactor.cpp. References ACE_GUARD_RETURN, ACE_SYNCH_MUTEX, and putq_result(). { ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1)); int ret_val = this->putq_result (result); return ret_val; }

int ACE_POSIX_AIOCB_Proactor::process_result_queue (  void   )  [protected]

Process the internal results queue. Definition at line 1150 of file POSIX_Proactor.cpp. References ACE_POSIX_Asynch_Result::bytes_transferred(), and getq_result(). Referenced by handle_events_i(), and ACE_POSIX_CB_Proactor::handle_events_i(). { int ret_val = 0; ACE_POSIX_Asynch_Result* result = 0; while ((result = this->getq_result ()) != 0) { this->application_specific_code (result, result->bytes_transferred(), // 0, No bytes transferred. 0, // No completion key. result->error()); //0, No error. ret_val++; } return ret_val; }

int ACE_POSIX_AIOCB_Proactor::putq_result (  ACE_POSIX_Asynch_Result *  result  )  [protected]

Put "post_completed" result into the internal queue. Definition at line 1095 of file POSIX_Proactor.cpp. References ACE_ERROR_RETURN, ACE_Unbounded_Queue< ACE_POSIX_Asynch_Result * >::enqueue_tail(), LM_ERROR, notify_completion(), and ACE_POSIX_Asynch_Result::signal_number(). Referenced by cancel_aio(), post_completion(), and start_deferred_aio(). { // this protected method should be called with locked mutex_ // we can't use GUARD as Proactor uses non-recursive mutex if (!result) return -1; int sig_num = result->signal_number (); int ret_val = this->result_queue_.enqueue_tail (result); if (ret_val == -1) ACE_ERROR_RETURN ((LM_ERROR, "%N:%l:ACE_POSIX_AIOCB_Proactor::putq_result failed\n"), -1); this->notify_completion (sig_num); return 0; }

void ACE_POSIX_AIOCB_Proactor::set_notify_handle (  ACE_HANDLE  h  )  [protected]

To identify requests from Notify_Pipe_Manager. Definition at line 852 of file POSIX_Proactor.cpp. References notify_pipe_read_handle_. Referenced by ACE_AIOCB_Notify_Pipe_Manager::ACE_AIOCB_Notify_Pipe_Manager(). { notify_pipe_read_handle_ = h; }

int ACE_POSIX_AIOCB_Proactor::start_aio (  ACE_POSIX_Asynch_Result *  result, ACE_POSIX_Proactor::Opcode  op )  [virtual]

Definition at line 1307 of file POSIX_Proactor.cpp. References ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_TRACE, aiocb_list_, aiocb_list_cur_size_, aiocb_list_max_size_, allocate_aio_slot(), LM_ERROR, num_deferred_aiocb_, result_list_, ssize_t, and start_aio_i(). { ACE_TRACE ("ACE_POSIX_AIOCB_Proactor::start_aio"); ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->mutex_, -1)); int ret_val = (aiocb_list_cur_size_ >= aiocb_list_max_size_) ? -1 : 0; if (result == 0) // Just check the status of the list return ret_val; // Save operation code in the aiocb switch (op) { case ACE_POSIX_Proactor::ACE_OPCODE_READ: result->aio_lio_opcode = LIO_READ; break; case ACE_POSIX_Proactor::ACE_OPCODE_WRITE: result->aio_lio_opcode = LIO_WRITE; break; default: ACE_ERROR_RETURN ((LM_ERROR, "%N:%l:(%P | %t)::\n" "start_aio: Invalid operation code\n"), -1); } if (ret_val != 0) // No free slot { errno = EAGAIN; return -1; } // Find a free slot and store. ssize_t slot = allocate_aio_slot (result); if (slot < 0) return -1; size_t index = static_cast<size_t> (slot); result_list_[index] = result; //Store result ptr anyway aiocb_list_cur_size_++; ret_val = start_aio_i (result); switch (ret_val) { case 0: // started OK aiocb_list_[index] = result; return 0; case 1: // OS AIO queue overflow num_deferred_aiocb_ ++; return 0; default: // Invalid request, there is no point break; // to start it later } result_list_[index] = 0; aiocb_list_cur_size_--; return -1; }

int ACE_POSIX_AIOCB_Proactor::start_aio_i (  ACE_POSIX_Asynch_Result *  result  )  [protected, virtual]

Initiate an aio operation. Definition at line 1421 of file POSIX_Proactor.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TCHAR, ACE_TRACE, LM_ERROR, and num_started_aio_. Referenced by start_aio(), and start_deferred_aio(). { ACE_TRACE ("ACE_POSIX_AIOCB_Proactor::start_aio_i"); int ret_val; const ACE_TCHAR *ptype; // Start IO switch (result->aio_lio_opcode ) { case LIO_READ : ptype = ACE_LIB_TEXT ("read "); ret_val = aio_read (result); break; case LIO_WRITE : ptype = ACE_LIB_TEXT ("write"); ret_val = aio_write (result); break; default: ptype = ACE_LIB_TEXT ("?????"); ret_val = -1; break; } if (ret_val == 0) this->num_started_aio_++; else // if (ret_val == -1) { if (errno == EAGAIN || errno == ENOMEM) //Ok, it will be deferred AIO ret_val = 1; else ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("%N:%l:(%P | %t)::start_aio_i: aio_%s %p\n"), ptype, ACE_LIB_TEXT ("queueing failed\n"))); } return ret_val; }

int ACE_POSIX_AIOCB_Proactor::start_deferred_aio (  void   )  [protected]

Start deferred AIO if necessary. Definition at line 1464 of file POSIX_Proactor.cpp. References ACE_ERROR_RETURN, ACE_TRACE, aiocb_list_, aiocb_list_cur_size_, aiocb_list_max_size_, LM_ERROR, num_deferred_aiocb_, putq_result(), result_list_, ACE_POSIX_Asynch_Result::set_bytes_transferred(), ACE_POSIX_Asynch_Result::set_error(), and start_aio_i(). Referenced by find_completed_aio(). { ACE_TRACE ("ACE_POSIX_AIOCB_Proactor::start_deferred_aio"); // This protected method is called from // find_completed_aio after any AIO completion // We should call this method always with locked // ACE_POSIX_AIOCB_Proactor::mutex_ // // It tries to start the first deferred AIO // if such exists if (num_deferred_aiocb_ == 0) return 0; // nothing to do size_t i = 0; for (i= 0; i < this->aiocb_list_max_size_; i++) if (result_list_[i] !=0 // check for && aiocb_list_[i] ==0) // deferred AIO break; if (i >= this->aiocb_list_max_size_) ACE_ERROR_RETURN ((LM_ERROR, "%N:%l:(%P | %t)::\n" "start_deferred_aio:" "internal Proactor error 3\n"), -1); ACE_POSIX_Asynch_Result *result = result_list_[i]; int ret_val = start_aio_i (result); switch (ret_val) { case 0 : //started OK , decrement count of deferred AIOs aiocb_list_[i] = result; num_deferred_aiocb_ --; return 0; case 1 : return 0; //try again later default : // Invalid Parameters , should never be break; } //AL notify user result_list_[i] = 0; aiocb_list_cur_size_--; num_deferred_aiocb_ --; result->set_error (errno); result->set_bytes_transferred (0); this->putq_result (result); // we are with locked mutex_ here ! return -1; }

---

Friends And Related Function Documentation

friend class ACE_AIOCB_Notify_Pipe_Manager [friend]

Handler needs to call application specific code. Definition at line 331 of file POSIX_Proactor.h.

friend class ACE_POSIX_Asynch_Accept [friend]

Definition at line 336 of file POSIX_Proactor.h.

friend class ACE_POSIX_Asynch_Connect [friend]

Definition at line 337 of file POSIX_Proactor.h.

friend class ACE_POSIX_Asynch_Operation [friend]

This class does the registering of Asynch Operations with the Proactor which is necessary in the AIOCB strategy. Definition at line 335 of file POSIX_Proactor.h.

---

Member Data Documentation

aiocb** ACE_POSIX_AIOCB_Proactor::aiocb_list_ [protected]

Use a dynamically allocated array to keep track of all the aio's issued currently. Definition at line 469 of file POSIX_Proactor.h. Referenced by cancel_aio(), create_result_aiocb_list(), delete_result_aiocb_list(), find_completed_aio(), handle_events_i(), start_aio(), and start_deferred_aio().

size_t ACE_POSIX_AIOCB_Proactor::aiocb_list_cur_size_ [protected]

To maintain the current size of the array (list). Definition at line 476 of file POSIX_Proactor.h. Referenced by cancel_aio(), find_completed_aio(), start_aio(), and start_deferred_aio().

size_t ACE_POSIX_AIOCB_Proactor::aiocb_list_max_size_ [protected]

To maintain the maximum size of the array (list). Definition at line 473 of file POSIX_Proactor.h. Referenced by allocate_aio_slot(), cancel_aio(), check_max_aio_num(), create_result_aiocb_list(), delete_result_aiocb_list(), find_completed_aio(), handle_events_i(), start_aio(), and start_deferred_aio().

ACE_AIOCB_Notify_Pipe_Manager* ACE_POSIX_AIOCB_Proactor::aiocb_notify_pipe_manager_ [protected]

This class takes care of doing when we use AIO_CONTROL_BLOCKS strategy. Definition at line 465 of file POSIX_Proactor.h. Referenced by create_notify_manager(), delete_notify_manager(), and notify_completion().

ACE_SYNCH_MUTEX ACE_POSIX_AIOCB_Proactor::mutex_ [protected]

Mutex to protect work with lists. Definition at line 479 of file POSIX_Proactor.h.

ACE_HANDLE ACE_POSIX_AIOCB_Proactor::notify_pipe_read_handle_ [protected]

The purpose of this member is only to identify asynchronous request from NotifyManager. We will reserve for it always slot 0 in the list of aiocb's to be sure that don't lose notifications. Definition at line 484 of file POSIX_Proactor.h. Referenced by allocate_aio_slot(), and set_notify_handle().

size_t ACE_POSIX_AIOCB_Proactor::num_deferred_aiocb_ [protected]

Number of ACE_POSIX_Asynch_Result's waiting for start i.e. deferred AIOs Definition at line 488 of file POSIX_Proactor.h. Referenced by cancel_aio(), start_aio(), and start_deferred_aio().

size_t ACE_POSIX_AIOCB_Proactor::num_started_aio_ [protected]

Number active,i.e. running requests. Definition at line 491 of file POSIX_Proactor.h. Referenced by find_completed_aio(), and start_aio_i().

ACE_POSIX_Asynch_Result** ACE_POSIX_AIOCB_Proactor::result_list_ [protected]

Definition at line 470 of file POSIX_Proactor.h. Referenced by allocate_aio_slot(), cancel_aio(), create_result_aiocb_list(), delete_result_aiocb_list(), find_completed_aio(), start_aio(), and start_deferred_aio().

ACE_Unbounded_Queue<ACE_POSIX_Asynch_Result *> ACE_POSIX_AIOCB_Proactor::result_queue_ [protected]

Queue which keeps "post_completed" ACE_POSIX_Asynch_Result's. Definition at line 494 of file POSIX_Proactor.h.

---

The documentation for this class was generated from the following files:

• POSIX_Proactor.h
• POSIX_Proactor.cpp

---