---

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 <aio_> 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 Methods
	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. More...
virtual Proactor_Type	get_impl_type (void)
virtual	~ACE_POSIX_AIOCB_Proactor (void)
	Destructor. More...
virtual int	close (void)
	Close down the Proactor. More...
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. More...
virtual int	start_aio (ACE_POSIX_Asynch_Result *result, ACE_POSIX_Proactor::Opcode op)
virtual int	cancel_aio (ACE_HANDLE h)
Protected Methods
	ACE_POSIX_AIOCB_Proactor (size_t nmaxop, ACE_POSIX_Proactor::Proactor_Type ptype)
	Special constructor for ACE_SUN_Proactor and ACE_POSIX_SIG_Proactor. More...
virtual int	get_result_status (ACE_POSIX_Asynch_Result *asynch_result, int &error_status, size_t &transfer_count)
	Check AIO for completion, error and result status Return: 1 - AIO completed , 0 - not completed yet. More...
int	create_result_aiocb_list (void)
	Create aiocb list. More...
int	delete_result_aiocb_list (void)
	Call this method from derived class when virtual table is built. More...
void	create_notify_manager (void)
	Call these methods from derived class when virtual table is built. More...
void	delete_notify_manager (void)
void	check_max_aio_num (void)
	Define the maximum number of asynchronous I/O requests for the current OS. More...
void	set_notify_handle (ACE_HANDLE h)
	To identify requests from Notify_Pipe_Manager. More...
int	handle_events_i (u_long milli_seconds)
int	start_deferred_aio (void)
	Start deferred AIO if necessary. More...
virtual int	cancel_aiocb (ACE_POSIX_Asynch_Result *result)
	Cancel running or deferred AIO. More...
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. More...
virtual ssize_t	allocate_aio_slot (ACE_POSIX_Asynch_Result *result)
	Find free slot to store result and aiocb pointer. More...
virtual int	start_aio_i (ACE_POSIX_Asynch_Result *result)
	Initiate an aio operation. More...
virtual int	notify_completion (int sig_num)
	Notify queue of "post_completed" ACE_POSIX_Asynch_Results called from post_completion method. More...
int	putq_result (ACE_POSIX_Asynch_Result *result)
	Put "post_completed" result into the internal queue. More...
ACE_POSIX_Asynch_Result *	getq_result (void)
	Get "post_completed" result from the internal queue. More...
int	clear_result_queue (void)
	Clear the internal results queue. More...
int	process_result_queue (void)
	Process the internal results queue. More...
Protected Attributes
ACE_AIOCB_Notify_Pipe_Manager *	aiocb_notify_pipe_manager_
	This class takes care of doing <accept> when we use AIO_CONTROL_BLOCKS strategy. More...
aiocb **	aiocb_list_
	Use a dynamically allocated array to keep track of all the aio's issued currently. More...
ACE_POSIX_Asynch_Result **	result_list_
size_t	aiocb_list_max_size_
	To maintain the maximum size of the array (list). More...
size_t	aiocb_list_cur_size_
	To maintain the current size of the array (list). More...
ACE_SYNCH_MUTEX	mutex_
	Mutex to protect work with lists. More...
ACE_HANDLE	notify_pipe_read_handle_
	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. More...
size_t	num_deferred_aiocb_
	Number of ACE_POSIX_Asynch_Result's waiting for start i.e. deferred AIOs. More...
size_t	num_started_aio_
	Number active,i.e. running requests. More...
ACE_Unbounded_Queue< ACE_POSIX_Asynch_Result * >	result_queue_
	Queue which keeps "post_completed" ACE_POSIX_Asynch_Result's. More...
Friends
class	ACE_AIOCB_Notify_Pipe_Manager
	Handler needs to call application specific code. More...
class	ACE_POSIX_Asynch_Operation
	This class does the registering of Asynch Operations with the Proactor which is necessary in the AIOCB strategy. More...
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 <aio_> operations issued.

Definition at line 326 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 752 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 797 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 776 of file POSIX_Proactor.cpp. References check_max_aio_num, create_result_aiocb_list, and ACE_POSIX_Proactor::Proactor_Type. : 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 1340 of file POSIX_Proactor.cpp. References ACE_ERROR_RETURN, aiocb_list_max_size_, LM_ERROR, notify_pipe_read_handle_, result_list_, and ssize_t. 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 ACE_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 1490 of file POSIX_Proactor.cpp. References ACE_GUARD_RETURN, ACE_MT, 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 1562 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 919 of file POSIX_Proactor.cpp. References _SC_AIO_MAX, 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) // 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 */ // 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 1100 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 803 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 1006 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 820 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 1017 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 841 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_String::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 1220 of file POSIX_Proactor.cpp. References ACE_GUARD_RETURN, ACE_MT, 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. { // 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_INLINE 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 11 of file POSIX_Proactor.i. References ACE_POSIX_Proactor::PROACTOR_AIOCB, and ACE_POSIX_Proactor::Proactor_Type. { 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 1201 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 = ACE_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 1080 of file POSIX_Proactor.cpp. References ACE_GUARD_RETURN, ACE_MT, ACE_SYNCH_MUTEX, ACE_Unbounded_Queue< ACE_POSIX_Asynch_Result * >::dequeue_head, and result_queue_. 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 <wait_time> 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 1035 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 <wait_time> 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 1027 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 <milli_seconds> 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 1134 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)) * 1000; 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 1041 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 1049 of file POSIX_Proactor.cpp. References ACE_GUARD_RETURN, ACE_MT, 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 1114 of file POSIX_Proactor.cpp. References ACE_POSIX_Proactor::application_specific_code, ACE_POSIX_Asynch_Result::bytes_transferred, ACE_POSIX_Asynch_Result::error, and getq_result. Referenced by 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 1059 of file POSIX_Proactor.cpp. References ACE_ERROR_RETURN, ACE_Unbounded_Queue< ACE_POSIX_Asynch_Result * >::enqueue_tail, LM_ERROR, notify_completion, result_queue_, 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 815 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 1271 of file POSIX_Proactor.cpp. References ACE_ERROR_RETURN, ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, aiocb_list_, aiocb_list_cur_size_, aiocb_list_max_size_, allocate_aio_slot, LM_ERROR, num_deferred_aiocb_, ACE_POSIX_Proactor::Opcode, ACE_POSIX_Proactor::READ, result_list_, ssize_t, start_aio_i, and ACE_POSIX_Proactor::WRITE. { 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::READ: result->aio_lio_opcode = LIO_READ; break; case ACE_POSIX_Proactor::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 = ACE_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 1385 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 1428 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 330 of file POSIX_Proactor.h.

friend class ACE_POSIX_Asynch_Accept [friend]

Definition at line 335 of file POSIX_Proactor.h.

friend class ACE_POSIX_Asynch_Connect [friend]

Definition at line 336 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 334 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 468 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 475 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 472 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 <accept> when we use AIO_CONTROL_BLOCKS strategy. Definition at line 464 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 478 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 483 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 487 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 490 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 469 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 493 of file POSIX_Proactor.h. Referenced by getq_result, and putq_result.

---

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

• POSIX_Proactor.h
• POSIX_Proactor.cpp
• POSIX_Proactor.i

---