Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# 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 | 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 ACE_Asynch_Read_Stream_Impl * | create_asynch_read_stream (void)
| Create the correct implementation class for doing Asynch_Read_Stream. More...
virtual ACE_Asynch_Write_Stream_Impl * | create_asynch_write_stream (void)
| Create the correct implementation class for doing Asynch_Write_Stream. More...
virtual ACE_Asynch_Read_Dgram_Impl * | create_asynch_read_dgram (void)
| Create the correct implementation class for doing Asynch_Read_Dgram. More...
virtual ACE_Asynch_Write_Dgram_Impl * | create_asynch_write_dgram (void)
| Create the correct implementation class for doing Asynch_Write_Dgram. More...
virtual ACE_Asynch_Read_File_Impl * | create_asynch_read_file (void)
| Create the correct implementation class for doing Asynch_Read_File. More...
virtual ACE_Asynch_Write_File_Impl * | create_asynch_write_file (void)
| Create the correct implementation class for doing Asynch_Write_File. More...
virtual ACE_Asynch_Accept_Impl * | create_asynch_accept (void)
| Create the correct implementation class for doing Asynch_Accept. More...
virtual ACE_Asynch_Transmit_File_Impl * | create_asynch_transmit_file (void)
| Create the correct implementation class for doing Asynch_Transmit_File. More...
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...
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...
virtual int | handle_events (u_long milli_seconds)
void | application_specific_code (ACE_POSIX_Asynch_Result *asynch_result, u_long bytes_transferred, int success, const void *completion_key, u_long error)
| We will call the base class's application_specific_code from here. More...
virtual int | register_and_start_aio (ACE_POSIX_Asynch_Result *result, int op)
virtual int | start_aio (ACE_POSIX_Asynch_Result *result)
| Op code now is saved in ACE_POSIX_Asynch_Result. More...
int | start_deferred_aio ()
| 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, int &return_status, size_t &index, size_t &count)
| Extract the results of aio. More...
virtual int | allocate_aio_slot (ACE_POSIX_Asynch_Result *result)
| Find free slot to store result and aiocb pointer. 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_AIOCB_Asynch_Operation
| This class does the registering of Asynch Operations with the Proactor which is necessary in the AIOCB strategy. More...

## Detailed Description

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

## Constructor & Destructor Documentation

ACE_POSIX_AIOCB_Proactor::ACE_POSIX_AIOCB_Proactor | ( | size_t | max_aio_operations = ACE_AIO_DEFAULT_SIZE | ) |

| Constructor defines max number asynchronous operations which can be started at the same time.

ACE_POSIX_AIOCB_Proactor::~ACE_POSIX_AIOCB_Proactor | ( | void |  | ) | `[virtual]`

| Destructor.

ACE_POSIX_AIOCB_Proactor::ACE_POSIX_AIOCB_Proactor | ( | size_t | max_aio_operations,
|  | ACE_POSIX_Proactor::Proactor_Type | ptype
| ) | `[protected]`

| Special constructor for ACE_SUN_Proactor and ACE_POSIX_SIG_Proactor.

## Member Function Documentation

int 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_SIG_Proactor.

void ACE_POSIX_AIOCB_Proactor::application_specific_code | ( | ACE_POSIX_Asynch_Result * | asynch_result,
|  | u_long | bytes_transferred,
|  | int | success,
|  | const void * | completion_key,
|  | u_long | error
| ) | `[protected]`

| We will call the base class's application_specific_code from here. Reimplemented from ACE_POSIX_Proactor.

int ACE_POSIX_AIOCB_Proactor::cancel_aio | ( | ACE_HANDLE | handle | ) | `[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

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

| Cancel running or deferred AIO.

void ACE_POSIX_AIOCB_Proactor::check_max_aio_num | ( | void |  | ) | `[protected]`

| Define the maximum number of asynchronous I/O requests for the current OS.

int ACE_POSIX_AIOCB_Proactor::clear_result_queue | ( | void |  | ) | `[protected]`

| Clear the internal results queue.

ACE_Asynch_Accept_Impl * ACE_POSIX_AIOCB_Proactor::create_asynch_accept | ( | void |  | ) | `[virtual]`

| Create the correct implementation class for doing Asynch_Accept. Reimplemented from ACE_Proactor_Impl.

ACE_Asynch_Read_Dgram_Impl * ACE_POSIX_AIOCB_Proactor::create_asynch_read_dgram | ( | void |  | ) | `[virtual]`

| Create the correct implementation class for doing Asynch_Read_Dgram. Reimplemented from ACE_Proactor_Impl.

ACE_Asynch_Read_File_Impl * ACE_POSIX_AIOCB_Proactor::create_asynch_read_file | ( | void |  | ) | `[virtual]`

| Create the correct implementation class for doing Asynch_Read_File. Reimplemented from ACE_Proactor_Impl.

ACE_Asynch_Read_Stream_Impl * ACE_POSIX_AIOCB_Proactor::create_asynch_read_stream | ( | void |  | ) | `[virtual]`

| Create the correct implementation class for doing Asynch_Read_Stream. Reimplemented from ACE_Proactor_Impl.

ACE_Asynch_Transmit_File_Impl * ACE_POSIX_AIOCB_Proactor::create_asynch_transmit_file | ( | void |  | ) | `[virtual]`

| Create the correct implementation class for doing Asynch_Transmit_File. Reimplemented from ACE_Proactor_Impl.

ACE_Asynch_Write_Dgram_Impl * ACE_POSIX_AIOCB_Proactor::create_asynch_write_dgram | ( | void |  | ) | `[virtual]`

| Create the correct implementation class for doing Asynch_Write_Dgram. Reimplemented from ACE_Proactor_Impl.

ACE_Asynch_Write_File_Impl * ACE_POSIX_AIOCB_Proactor::create_asynch_write_file | ( | void |  | ) | `[virtual]`

| Create the correct implementation class for doing Asynch_Write_File. Reimplemented from ACE_Proactor_Impl.

ACE_Asynch_Write_Stream_Impl * ACE_POSIX_AIOCB_Proactor::create_asynch_write_stream | ( | void |  | ) | `[virtual]`

| Create the correct implementation class for doing Asynch_Write_Stream. Reimplemented from ACE_Proactor_Impl.

void ACE_POSIX_AIOCB_Proactor::create_notify_manager | ( | void |  | ) | `[protected]`

| Call these methods from derived class when virtual table is built.

void ACE_POSIX_AIOCB_Proactor::delete_notify_manager | ( | void |  | ) | `[protected]`

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

| Extract the results of aio.

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_SIG_Proactor.

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

| Get "post_completed" result from the internal queue.

int ACE_POSIX_AIOCB_Proactor::handle_events | ( | u_long | milli_seconds | ) | `[protected, virtual]`

| 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_SIG_Proactor.

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. Reimplemented from ACE_Proactor_Impl. Reimplemented in ACE_POSIX_SIG_Proactor.

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. Reimplemented from ACE_Proactor_Impl. Reimplemented in ACE_POSIX_SIG_Proactor.

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_SIG_Proactor.

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

| Post a result to the completion port of the Proactor. Reimplemented from ACE_POSIX_Proactor.

int ACE_POSIX_AIOCB_Proactor::process_result_queue | ( | void |  | ) | `[protected]`

| Process the internal results queue.

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

| Put "post_completed" result into the internal queue.

int ACE_POSIX_AIOCB_Proactor::register_and_start_aio | ( | ACE_POSIX_Asynch_Result * | result,
|  | int | op
| ) | `[protected, virtual]`

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

| To identify requests from Notify_Pipe_Manager.

int ACE_POSIX_AIOCB_Proactor::start_aio | ( | ACE_POSIX_Asynch_Result * | result | ) | `[protected, virtual]`

| Op code now is saved in ACE_POSIX_Asynch_Result.

int ACE_POSIX_AIOCB_Proactor::start_deferred_aio | ( |  | ) | `[protected]`

| Start deferred AIO if necessary.

## Friends And Related Function Documentation

friend class ACE_AIOCB_Notify_Pipe_Manager`[friend]`

| Handler needs to call application specific code.

friend class ACE_POSIX_AIOCB_Asynch_Operation`[friend]`

| This class does the registering of Asynch Operations with the Proactor which is necessary in the AIOCB strategy.

## 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.

size_t ACE_POSIX_AIOCB_Proactor::aiocb_list_cur_size_`[protected]`

| To maintain the current size of the array (list).

size_t ACE_POSIX_AIOCB_Proactor::aiocb_list_max_size_`[protected]`

| To maintain the maximum size of the array (list).

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.

ACE_SYNCH_MUTEX ACE_POSIX_AIOCB_Proactor::mutex_`[protected]`

| Mutex to protect work with lists.

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.

size_t ACE_POSIX_AIOCB_Proactor::num_deferred_aiocb_`[protected]`

| number of ACE_POSIX_Asynch_Result's waiting for start i.e. deferred AIOs.

size_t ACE_POSIX_AIOCB_Proactor::num_started_aio_`[protected]`

| Number active,i.e. running requests.

ACE_POSIX_Asynch_Result** ACE_POSIX_AIOCB_Proactor::result_list_`[protected]`

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

| Queue which keeps "post_completed" ACE_POSIX_Asynch_Result's.

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

- POSIX_Proactor.h
- POSIX_Proactor.cpp
- POSIX_Proactor.i