ACE/examples/Mem_Map/IO-tests/IO_Test.cpp

   1 #include "ace/OS_NS_string.h"
   2 #include "ace/OS_NS_unistd.h"
   3 #include "ace/OS_NS_stdio.h"
   4 #include "ace/Mem_Map.h"
   5 #include "ace/Log_Msg.h"
   6 #include "IO_Test.h"
   7
   8 #if !defined(ACE_WIN32)
   9
  10
  11 IO_Test::IO_Test (const char *name,
  12                   ACE_Profile_Timer &tm)
  13   : name_ (name), tm_ (tm)
  14 {
  15 }
  16
  17 IO_Test::~IO_Test ()
  18 {
  19 }
  20
  21 const char *
  22 IO_Test::name ()
  23 {
  24   return this->name_;
  25 }
  26
  27 Slow_Read_Write_Test::Slow_Read_Write_Test (const char *name,
  28                                             ACE_Profile_Timer &tm)
  29   : IO_Test (name, tm)
  30 {
  31 }
  32
  33 int
  34 Slow_Read_Write_Test::run_test (int iterations,
  35                                 FILE *input_fp,
  36                                 FILE *output_fp)
  37 {
  38   ACE_HANDLE ifd = ACE_OS::fileno (input_fp);
  39   ACE_HANDLE ofd = ACE_OS::fileno (output_fp);
  40
  41   this->tm_.start ();
  42
  43   while (--iterations >= 0)
  44     {
  45       char c;
  46
  47       while (ACE_OS::read (ifd, &c, sizeof c) > 0)
  48         ACE_OS::write (ofd, &c, sizeof c);
  49
  50       ACE_OS::lseek (ifd, 0, SEEK_SET);
  51       ACE_OS::lseek (ofd, 0, SEEK_SET);
  52     }
  53
  54   this->tm_.stop ();
  55   return 0;
  56 }
  57
  58 Stdio_Test::Stdio_Test (const char *name,
  59                         ACE_Profile_Timer &tm)
  60   : IO_Test (name, tm)
  61 {
  62 }
  63
  64 int
  65 Stdio_Test::run_test (int iterations,
  66                       FILE *input_fp,
  67                       FILE *output_fp)
  68 {
  69   this->tm_.start ();
  70
  71   while (--iterations >= 0)
  72     {
  73       int c;
  74
  75       while ((c = ACE_OS::getc (input_fp)) != EOF)
  76         ACE_OS::putc (c, output_fp);
  77
  78       ACE_OS::rewind (input_fp);
  79       ACE_OS::rewind (output_fp);
  80     }
  81   this->tm_.stop ();
  82   return 0;
  83 }
  84
  85 Block_Read_Write_Test::Block_Read_Write_Test (const char *name,
  86                                               ACE_Profile_Timer &tm)
  87   : IO_Test (name, tm)
  88 {
  89 }
  90
  91 int
  92 Block_Read_Write_Test::run_test (int iterations,
  93                                  FILE *input_fp,
  94                                  FILE *output_fp)
  95 {
  96   ACE_HANDLE ifd = ACE_OS::fileno (input_fp);
  97   ACE_HANDLE ofd = ACE_OS::fileno (output_fp);
  98
  99   this->tm_.start ();
 100
 101   while (--iterations >= 0)
 102     {
 103       char buf[BUFSIZ];
 104       ssize_t n;
 105
 106       while ((n = ACE_OS::read (ifd,
 107                                 buf,
 108                                 sizeof buf)) > 0)
 109                                 ACE_OS::write (ofd, buf, n);
 110
 111       ACE_OS::lseek (ifd, 0, SEEK_SET);
 112       ACE_OS::lseek (ofd, 0, SEEK_SET);
 113     }
 114
 115   this->tm_.stop ();
 116   return 0;
 117 }
 118
 119 Block_Fread_Fwrite_Test::Block_Fread_Fwrite_Test (const char *name,
 120                                                   ACE_Profile_Timer &tm)
 121   : IO_Test (name, tm)
 122 {
 123 }
 124
 125 int
 126 Block_Fread_Fwrite_Test::run_test (int iterations,
 127                                    FILE *input_fp,
 128                                    FILE *output_fp)
 129 {
 130   this->tm_.start ();
 131
 132   while (--iterations >= 0)
 133     {
 134       char buf[BUFSIZ];
 135       ssize_t n;
 136
 137       while ((n = ACE_OS::fread (buf,
 138                                  1,
 139                                  sizeof buf,
 140                                  input_fp)) != 0)
 141                                  ACE_OS::fwrite (buf, n, 1, output_fp);
 142
 143       ACE_OS::rewind (input_fp);
 144       ACE_OS::rewind (output_fp);
 145     }
 146
 147   this->tm_.stop ();
 148   return 0;
 149 }
 150
 151 Mmap1_Test::Mmap1_Test (const char *name,
 152                         ACE_Profile_Timer &tm)
 153   : IO_Test (name, tm)
 154 {
 155 }
 156
 157 int
 158 Mmap1_Test::run_test (int iterations,
 159                       FILE *input_fp,
 160                       FILE *output_fp)
 161 {
 162   ACE_Mem_Map map_input (ACE_OS::fileno (input_fp));
 163   void *src = map_input.addr ();
 164
 165   if (src == MAP_FAILED)
 166     ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%C"), this->name ()), -1);
 167   else
 168     {
 169       this->tm_.start ();
 170
 171       while (--iterations >= 0)
 172       {
 173         if (ACE_OS::write (ACE_OS::fileno (output_fp),
 174                            src,
 175                            map_input.size ()) == -1)
 176           ACE_ERROR_RETURN ((LM_ERROR,
 177                              ACE_TEXT ("%C"),
 178                              this->name ()),
 179                             -1);
 180         ACE_OS::lseek (ACE_OS::fileno (output_fp),
 181                        0,
 182                        SEEK_SET);
 183       }
 184
 185       this->tm_.stop ();
 186     }
 187
 188   if (map_input.unmap () == -1)
 189     ACE_ERROR_RETURN ((LM_ERROR,
 190                        ACE_TEXT ("%C"),
 191                        this->name ()),
 192                       -1);
 193   else
 194     return 0;
 195 }
 196
 197 Mmap2_Test::Mmap2_Test (const char *name,
 198                         ACE_Profile_Timer &tm)
 199   : IO_Test (name, tm)
 200 {
 201 }
 202
 203 int
 204 Mmap2_Test::run_test (int iterations,
 205                       FILE *input_fp,
 206                       FILE *output_fp)
 207 {
 208   ACE_Mem_Map map_input (ACE_OS::fileno (input_fp));
 209   int size = map_input.size ();
 210   ACE_Mem_Map map_output (ACE_OS::fileno (output_fp),
 211                           size,
 212                           PROT_WRITE,
 213                           MAP_SHARED);
 214   void *src = map_input.addr ();
 215   void *dst = map_output.addr ();
 216
 217   if (src == MAP_FAILED || dst == MAP_FAILED)
 218     return -1;
 219   else
 220     {
 221       this->tm_.start ();
 222
 223       while (--iterations >= 0)
 224         ACE_OS::memcpy (dst, src, size);
 225
 226       this->tm_.stop ();
 227     }
 228
 229   if (map_input.unmap () == -1
 230       || map_output.unmap () == -1)
 231     return -1;
 232   else
 233     return 0;
 234 }
 235 #endif