diff options
| -rw-r--r-- | ChangeLog-99b | 11 | ||||
| -rw-r--r-- | configure.in | 19 | ||||
| -rw-r--r-- | m4/features.m4 | 545 |
3 files changed, 557 insertions, 18 deletions
diff --git a/ChangeLog-99b b/ChangeLog-99b index b71b26f2db4..99ab98e2622 100644 --- a/ChangeLog-99b +++ b/ChangeLog-99b @@ -1,3 +1,14 @@ +Mon Mar 29 20:22:44 1999 Ossama Othman <othman@cs.wustl.edu> + + * configure.in: + * m4/features.m4: + Added new M4 macro include file, and moved asynchronous IO tests + to `m4/features.m4'. The asynchronous IO tests were improved by + making them run-time tests. Cross-compiled platforms will fall + back to a compile-time test. Thanks to Alex for providing + run-time tests. The tests are based on his AIO tests found in + the examples/Reactor/Proactor directory. + Sun Mar 28 18:02:54 1999 Ossama Othman <othman@cs.wustl.edu> * configure.in: diff --git a/configure.in b/configure.in index 5f320409919..5aab52caa7a 100644 --- a/configure.in +++ b/configure.in @@ -5503,24 +5503,7 @@ if test "$ace_user_enable_threads" = yes; then fi dnl Check for asynchronous IO calls -if test "$ace_has_aio_funcs" = yes; then - ACE_CACHE_CHECK(for asynchronous IO calls, - ace_cv_feature_aio_calls,[ - AC_TRY_COMPILE( - [ -#include <aio.h> - ], - [ - aiocb* aiocb_ptr (void); - ], - [ - ace_cv_feature_aio_calls=yes - ], - [ - ace_cv_feature_aio_calls=no - ]) - ], AC_DEFINE(ACE_HAS_AIO_CALLS),) -fi dnl test "$ace_has_aio_funcs" = yes +ACE_CHECK_ASYNCH_IO dnl Check for UNIX domain sockets ACE_CACHE_CHECK(for UNIX domain sockets, diff --git a/m4/features.m4 b/m4/features.m4 new file mode 100644 index 00000000000..b247ff6e97a --- /dev/null +++ b/m4/features.m4 @@ -0,0 +1,545 @@ +dnl ------------------------------------------------------------------------- +dnl $Id$ +dnl +dnl features.m4 +dnl +dnl ACE M4 include file which contains ACE specific M4 macros +dnl that determine availablility of certain OS features for ACE. +dnl +dnl ------------------------------------------------------------------------- + +dnl Copyright (C) 1998, 1999 Ossama Othman +dnl +dnl All Rights Reserved +dnl +dnl This library is free software; you can redistribute it and/or +dnl modify it under the current ACE distribution terms. +dnl +dnl This library is distributed in the hope that it will be useful, +dnl but WITHOUT ANY WARRANTY; without even the implied warranty of +dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +dnl Asynchronous IO check +dnl Use this macro to determine if asynchronous IO is working on a +dnl given platform. +dnl Usage: ACE_CHECK_ASYNCH_IO +AC_DEFUN(ACE_CHECK_ASYNCH_IO, dnl +[ + AC_REQUIRE([AC_PROG_CXX]) + AC_REQUIRE([AC_PROG_CXXCPP]) + AC_REQUIRE([AC_LANG_CPLUSPLUS]) + + dnl Asynchronous IO library check + dnl Some platforms, such as Solaris puts aio_read in -lposix4, for example. + dnl In some cases, the thread library must be linked to in addition to the + dnl real-time support library. As such, make sure these checks are done + dnl after the thread library checks. + ace_has_aio_funcs=yes + AC_CHECK_FUNC(aio_read, , dnl + AC_CHECK_LIB(aio, aio_read, , + AC_CHECK_LIB(posix4, aio_read, , + AC_CHECK_LIB(rt, aio_read, , ace_has_aio_funcs=no)))) + +if test "$ace_has_aio_funcs" = yes; then + ACE_CACHE_CHECK(for working asynchronous IO, + ace_cv_feature_aio_calls, + [ + AC_TRY_RUN( + [ +#ifndef ACE_LACKS_UNISTD_H +#include <unistd.h> +#endif +#include <fcntl.h> +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/stat.h> +#include <signal.h> +#include <string.h> +#include <errno.h> +#include <stdio.h> + +#include <aio.h> + +class Test_Aio +{ +public: + Test_Aio (void); + // Default constructor. + + int init (void); + // Initting the output file and the buffer. + + int do_aio (void); + // Doing the testing stuff. + + ~Test_Aio (void); + // Destructor. +private: + int out_fd_; + // Output file descriptor. + + struct aiocb *aiocb_write_; + // For writing to the file. + + struct aiocb *aiocb_read_; + // Reading stuff from the file. + + char *buffer_write_; + // The buffer to be written to the out_fd. + + char *buffer_read_; + // The buffer to be read back from the file. +}; + +Test_Aio::Test_Aio (void) + : aiocb_write_ (new struct aiocb), + aiocb_read_ (new struct aiocb), + buffer_write_ (0), + buffer_read_ (0) +{ +} + +Test_Aio::~Test_Aio (void) +{ + delete aiocb_write_; + delete aiocb_read_; + delete buffer_write_; + delete buffer_read_; +} + +// Init the output file and init the buffer. +int +Test_Aio::init (void) +{ + // Open the output file. + this->out_fd_ = open ("conftest.log", O_RDWR | O_CREAT | O_TRUNC, 0666); + if (this->out_fd_ == 0) + { + return -1; + } + + // Init the buffers. + this->buffer_write_ = strdup ("Welcome to the world of AIO... AIO Rules !!!"); + this->buffer_read_ = new char [strlen (this->buffer_write_)]; +} + +// Set the necessary things for the AIO stuff. +// Write the buffer asynchly.hmm Disable signals. +// Go on aio_suspend. Wait for completion. +// Print out the result. +int +Test_Aio::do_aio (void) +{ + // = Write to the file. + + // Setup AIOCB. + this->aiocb_write_->aio_fildes = this->out_fd_; + this->aiocb_write_->aio_offset = 0; + this->aiocb_write_->aio_buf = this->buffer_write_; + this->aiocb_write_->aio_nbytes = strlen (this->buffer_write_); + this->aiocb_write_->aio_reqprio = 0; + this->aiocb_write_->aio_sigevent.sigev_notify = SIGEV_NONE; + //this->this->aiocb_.aio_sigevent.sigev_signo = SIGRTMAX; + this->aiocb_write_->aio_sigevent.sigev_value.sival_ptr = + (void *) this->aiocb_write_; + + // Fire off the aio write. + if (aio_write (this->aiocb_write_) != 0) + { + perror ("aio_write"); + return -1; + } + + // = Read from that file. + + // Setup AIOCB. + this->aiocb_read_->aio_fildes = this->out_fd_; + this->aiocb_read_->aio_offset = 0; + this->aiocb_read_->aio_buf = this->buffer_read_; + this->aiocb_read_->aio_nbytes = strlen (this->buffer_write_); + this->aiocb_read_->aio_reqprio = 0; + this->aiocb_read_->aio_sigevent.sigev_notify = SIGEV_NONE; + //this->this->aiocb_.aio_sigevent.sigev_signo = SIGRTMAX; + this->aiocb_read_->aio_sigevent.sigev_value.sival_ptr = + (void *) this->aiocb_read_; + + // Fire off the aio write. If it doesnt get queued, carry on to get + // the completion for the first one. + if (aio_read (this->aiocb_read_) < 0) + perror ("aio_read"); + + // Wait for the completion on aio_suspend. + struct aiocb *list_aiocb[2]; + list_aiocb [0] = this->aiocb_write_; + list_aiocb [1] = this->aiocb_read_; + + // Do suspend till all the aiocbs in the list are done. + int done = 0; + int return_val = 0; + while (!done) + { + return_val = aio_suspend (list_aiocb, + 2, + 0); + + // Analyze return and error values. + if (aio_error (list_aiocb [0]) != EINPROGRESS) + { + if (aio_return (list_aiocb [0]) == -1) + { + perror ("aio_return"); + return -1; + } + else + { + // Successful. Store the pointer somewhere and make the + // entry NULL in the list. + this->aiocb_write_ = list_aiocb [0]; + list_aiocb [0] = 0; + } + } + + if (aio_error (list_aiocb [1]) != EINPROGRESS) + { + if (aio_return (list_aiocb [1]) == -1) + { + perror ("aio_return"); + return -1; + } + else + { + // Successful. Store the pointer somewhere and make the + // entry NULL in the list. + this->aiocb_read_ = list_aiocb [1]; + list_aiocb [1] = 0; + } + } + + // Is it done? + if ((list_aiocb [0] == 0) && (list_aiocb [1] == 0)) + done = 1; + } + + return 0; +} + +int +main (int argc, char *argv[]) +{ + Test_Aio test_aio; + + if (test_aio.init () != 0) + { + return -1; + } + + if (test_aio.do_aio () != 0) + { + return -1; + } + + return 0; +} + ], + [ + dnl Now try another test + AC_TRY_RUN( + [ +#ifndef ACE_LACKS_UNISTD_H +#include <unistd.h> +#endif +#include <fcntl.h> +#ifndef ACE_LACKS_SYS_TYPES_H +# include <sys/types.h> +#endif +#include <sys/stat.h> +#include <signal.h> +#include <string.h> +#include <errno.h> +#include <stdio.h> + +#include <limits.h> + +#include <aio.h> + +int file_handle = -1; +char mb1 [BUFSIZ + 1]; +char mb2 [BUFSIZ + 1]; +aiocb aiocb1, aiocb2; +sigset_t completion_signal; + +/* Function prototypes. */ +int setup_signal_delivery (void); +int issue_aio_calls (void); +int query_aio_completions (void); +int test_aio_calls (void); + +int +setup_signal_delivery (void) +{ + /* Make the sigset_t consisting of the completion signal. */ + if (sigemptyset (&completion_signal) == -1) + { + perror ("Error:Couldnt init the RT completion signal set\n"); + return -1; + } + + if (sigaddset (&completion_signal, SIGRTMIN) == -1) + { + perror ("Error:Couldnt init the RT completion signal set\n"); + return -1; + } + + /* Mask them. */ + if (sigprocmask (SIG_BLOCK, &completion_signal, 0) == -1) + { + perror ("Error:Couldnt maks the RT completion signals\n"); + return -1; + } + + /* Setting up the handler(!) for these signals. */ + struct sigaction reaction; + sigemptyset (&reaction.sa_mask); /* Nothing else to mask. */ + reaction.sa_flags = SA_SIGINFO; /* Realtime flag. */ +#if defined (SA_SIGACTION) + /* Lynx says, it is better to set this bit to be portable. */ + reaction.sa_flags &= SA_SIGACTION; +#endif /* SA_SIGACTION */ + reaction.sa_sigaction = 0; /* No handler. */ + int sigaction_return = sigaction (SIGRTMIN, + &reaction, + 0); + if (sigaction_return == -1) + { + perror ("Error:Proactor couldnt do sigaction for the RT SIGNAL"); + return -1; + } + + return 0; +} + +int +issue_aio_calls (void) +{ + /* Setup AIOCB. */ + aiocb1.aio_fildes = file_handle; + aiocb1.aio_offset = 0; + aiocb1.aio_buf = mb1; + aiocb1.aio_nbytes = BUFSIZ; + aiocb1.aio_reqprio = 0; + aiocb1.aio_sigevent.sigev_notify = SIGEV_SIGNAL; + aiocb1.aio_sigevent.sigev_signo = SIGRTMIN; + aiocb1.aio_sigevent.sigev_value.sival_ptr = (void *) &aiocb1; + + /* Fire off the aio write. */ + if (aio_read (&aiocb1) == -1) + { + /* Queueing failed. */ + perror ("Error:Asynch_Read_Stream: aio_read queueing failed\n"); + return -1; + } + + /* Setup AIOCB. */ + aiocb2.aio_fildes = file_handle; + aiocb2.aio_offset = BUFSIZ + 1; + aiocb2.aio_buf = mb2; + aiocb2.aio_nbytes = BUFSIZ; + aiocb2.aio_reqprio = 0; + aiocb2.aio_sigevent.sigev_notify = SIGEV_SIGNAL; + aiocb2.aio_sigevent.sigev_signo = SIGRTMIN; + aiocb2.aio_sigevent.sigev_value.sival_ptr = (void *) &aiocb2; + + /* Fire off the aio write. */ + if (aio_read (&aiocb2) == -1) + { + /* Queueing failed. */ + perror ("Error:Asynch_Read_Stream: aio_read queueing failed\n"); + return -1; + } + return 0; +} + +int +query_aio_completions (void) +{ + int result = 0; + size_t number_of_compleions = 0; + for (number_of_compleions = 0; + number_of_compleions < 2; + number_of_compleions ++) + { + /* Wait for <milli_seconds> amount of time. */ + /* @@ Assigning <milli_seconds> to tv_sec. */ + timespec timeout; + timeout.tv_sec = INT_MAX; + timeout.tv_nsec = 0; + + /* To get back the signal info. */ + siginfo_t sig_info; + + /* Await the RT completion signal. */ + int sig_return = sigtimedwait (&completion_signal, + &sig_info, + &timeout); + + /* Error case. */ + /* If failure is coz of timeout, then return *0* but set */ + /* errno appropriately. This is what the WinNT proactor */ + /* does. */ + if (sig_return == -1) + { + perror ("Error:Error waiting for RT completion signals\n"); + return -1; + } + + /* RT completion signals returned. */ + if (sig_return != SIGRTMIN) + { + printf ("Unexpected signal (%d) has been received while waiting for RT Completion Signals\n", + sig_return); + return -1; + } + + /* @@ Debugging. */ + printf ("Sig number found in the sig_info block : %d\n", + sig_info.si_signo); + + /* Is the signo returned consistent? */ + if (sig_info.si_signo != sig_return) + { + printf ("Inconsistent signal number (%d) in the signal info block\n", + sig_info.si_signo); + return -1; + } + + /* @@ Debugging. */ + printf ("Signal code for this signal delivery : %d\n", + sig_info.si_code); + + /* Is the signal code an aio completion one? */ + if ((sig_info.si_code != SI_ASYNCIO) && + (sig_info.si_code != SI_QUEUE)) + { + printf ("Unexpected signal code (%d) returned on completion querying\n", + sig_info.si_code); + return -1; + } + + /* Retrive the aiocb. */ + aiocb* aiocb_ptr = (aiocb *) sig_info.si_value.sival_ptr; + + /* Analyze error and return values. Return values are */ + /* actually <errno>'s associated with the <aio_> call */ + /* corresponding to aiocb_ptr. */ + int error_code = aio_error (aiocb_ptr); + if (error_code == -1) + { + perror ("Error:Invalid control block was sent to <aio_error> for compleion querying\n"); + return -1; + } + + if (error_code != 0) + { + /* Error occurred in the <aio_>call. Return the errno */ + /* corresponding to that <aio_> call. */ + printf ("Error:An AIO call has failed:Error code = %d\n", + error_code); + return -1; + } + + /* No error occured in the AIO operation. */ + int nbytes = aio_return (aiocb_ptr); + if (nbytes == -1) + { + perror ("Error:Invalid control block was send to <aio_return>\n"); + return -1; + } + + if (number_of_compleions == 0) + /* Print the buffer. */ + printf ("Number of bytes transferred : %d\n The buffer : %s \n", + nbytes, + mb1); + else + /* Print the buffer. */ + printf ("Number of bytes transferred : %d\n The buffer : %s \n", + nbytes, + mb2); + } + return 0; +} + +int +test_aio_calls (void) +{ + /* Set up the input file. */ + /* Open file (in SEQUENTIAL_SCAN mode) */ + file_handle = open ("test_aiosig.cpp", O_RDONLY); + + if (file_handle == -1) + { + perror ("Error:Opening the inputfile"); + return -1; + } + + if (setup_signal_delivery () < 0) + return -1; + + if (issue_aio_calls () < 0) + return -1; + + if (query_aio_completions () < 0) + return -1; + + return 0; +} + +int +main (int, char *[]) +{ + if (test_aio_calls () != 0) + return -1; + else + return 0; +} + ], + [ + ace_cv_feature_aio_calls=yes + ], + [ + ace_cv_feature_aio_calls=no + ], + [ + dnl Don't bother doing anything for cross-compiling here + dnl since the outer run-time test will prevent this + dnl inner run-time test from ever running when cross-compiling. + dnl We just put something in here to prevent autoconf + dnl from complaining. + ace_just_a_place_holder=ignoreme + ]) + ], + [ + ace_cv_feature_aio_calls=no + ], + [ + dnl Asynchronous IO test for cross-compiled platforms + dnl This test is weaker than the above run-time tests but it will + dnl have to do. + AC_TRY_COMPILE( + [ +#include <aio.h> + ], + [ + aiocb* aiocb_ptr (void); + ], + [ + ace_cv_feature_aio_calls=yes + ], + [ + ace_cv_feature_aio_calls=no + ]) + ]) + ], AC_DEFINE(ACE_HAS_AIO_CALLS),) +fi dnl test "$ace_has_aio_funcs" = yes +]) |