gprofng/testsuite/gprofng.display/synprog/iosyn.c

   1 /* Copyright (C) 2021-2023 Free Software Foundation, Inc.
   2    Contributed by Oracle.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <strings.h>
  25 #include <errno.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <sys/mman.h>
  31 #include <sys/time.h>
  32
  33 #include "stopwatch.h"
  34
  35 /* parameters defining various tasks */
  36 #define BUFSIZE  16384
  37 #define NBLKS  1024
  38
  39 #define SIZE ((int)(16*1024*1024))
  40 unsigned buffer[SIZE];
  41 extern FILE *fid2;
  42
  43 /*      ioerror - do some erroneous file IO operations */
  44 int
  45 ioerror ()
  46 {
  47   FILE *fp; /* FILE pointer for stdio */
  48   char *fname = NULL;
  49   char *ptr = NULL;
  50   int fd; /* file descriptor for raw IO */
  51   int fd2; /* file descriptor for raw IO */
  52   int stat;
  53   char buf[BUFSIZE];
  54   unsigned long size = 0;
  55   char sfn[23] = "";
  56
  57   /* Log the regular read */
  58   wlog ("start of ioerror", NULL);
  59
  60   /* fname is set to NULL.
  61      Use various calls to create
  62      a file.
  63    */
  64
  65   fd = creat (fname, 0666);
  66   fd = open (fname, 0666);
  67   fd2 = 0;
  68   fd = openat (fd2, fname, 0666);
  69   fp = fopen (fname, "w");
  70   fp = fopen ("/iotest", "w");
  71   fp = NULL;
  72   stat = fflush (fp);
  73   stat = chmod (fname, 755);
  74   stat = access (fname, 755);
  75   fname = "/tmp/synprogXXXXXX";
  76   strncpy (sfn, fname, sizeof (sfn));
  77   fd = mkstemp (sfn);
  78   stat = unlink (sfn);
  79   stat = rename (fname, NULL);
  80   unlink (fname);
  81   fp = fopen (fname, "w");
  82   stat = fclose (fp);
  83   stat = fread (buf, 100, 2, fp);
  84   stat = fwrite (buf, 100, 2, fp);
  85   ptr = fgets (buf, size, fp);
  86   read (10000, buf, 100);
  87   write (10000, buf, 100);
  88   stat = unlink (fname);
  89   fname = NULL;
  90   stat = mkdir (fname, 755);
  91   stat = unlink (fname);
  92   /*
  93     These functions cannot be executed
  94     if the File Pointer (fp) is set
  95     to NULL. They generate segv failure
  96     in actual call not inside of
  97     the wrapper.
  98
  99     stat = fread(buf, size, 2, fp);
 100     stat = fwrite(buf, size, 2, fp);
 101     ptr = fgets(buf, size, fp);
 102     stat = fputs(buf, fp);
 103     stat = fprintf(fp, "%d\n", size);
 104     stat = fseek(fp, size, size);
 105     rewind(fp);
 106     ftell(fp);
 107     fpos_t pos;
 108     stat = fsetpos(fp, &pos);
 109     stat = fgetpos(fp, &pos);
 110    */
 111   return 0;
 112 }
 113
 114 /*=======================================================*/
 115
 116 /* iofile - do some file io operations */
 117 int
 118 iofile ()
 119 {
 120   FILE *fp; /* FILE pointer for stdio */
 121   int k; /* temp value for loop */
 122   int i;
 123   char *buf;
 124   hrtime_t start;
 125   hrtime_t vstart;
 126   char sfn[23] = "";
 127   char *fname = "/tmp/synprogXXXXXX";
 128   int ret;
 129   int readCnt = 0;
 130   int bRead = 0;
 131   int writeCnt = 0;
 132   int bWritten = 0;
 133   int otherIOCnt = 0;
 134   int bytes = 0;
 135
 136   start = gethrtime ();
 137   vstart = gethrvtime ();
 138
 139   /* Log the event */
 140   bytes = wlog ("start of iofile -- stdio", NULL);
 141   bWritten += bytes;
 142   writeCnt++;
 143
 144   strncpy (sfn, fname, sizeof (sfn));
 145   ret = mkstemp (sfn);
 146   otherIOCnt++;
 147   if (ret == -1)
 148     {
 149       fprintf (stderr, "Unable to make a temporary name\n");
 150       exit (1);
 151     }
 152   bytes = fprintf (stderr, "\tUsing %s as scratch file\n", sfn);
 153   bWritten += bytes;
 154   writeCnt++;
 155
 156   /* allocate a buffer for the reading */
 157   /* note that this buffer is leaked! */
 158   buf = (char *) malloc (BUFSIZE);
 159
 160   /* open the file */
 161   fp = fdopen (ret, "w");
 162   otherIOCnt++;
 163   if (fp == NULL)
 164     {
 165       fprintf (stderr, "++ERROR opening %s, error %d\n", sfn, errno);
 166       exit (1);
 167     }
 168
 169   /* loop, writing the buffer to the file... */
 170   for (i = 0; i < NBLKS; i++)
 171     {
 172       k = fwrite (buf, sizeof (char), BUFSIZE, fp);
 173       writeCnt++;
 174       if (k != BUFSIZE)
 175         {
 176           fprintf (stderr, "++ERROR writing %s, error %d\n", sfn, errno);
 177           exit (1);
 178         }
 179       bWritten += k;
 180     }
 181
 182   fclose (fp);
 183   fp = NULL;
 184   otherIOCnt++;
 185
 186   sprintf (buf, "fwrite: %d blocks of %d", i, BUFSIZE);
 187   bytes = whrvlog (gethrtime () - start, gethrvtime () - vstart, buf, NULL);
 188   bWritten += bytes;
 189   writeCnt++;
 190
 191
 192   /* now reopen the file, and read it */
 193   start = gethrtime ();
 194   vstart = gethrvtime ();
 195
 196   fp = fopen (sfn, "r");
 197   otherIOCnt++;
 198   if (fp == NULL)
 199     {
 200       fprintf (stderr, "++ERROR opening %s, error %d\n", sfn, errno);
 201       exit (1);
 202     }
 203   i = 0;
 204   for (;;)
 205     {
 206       k = fread (buf, sizeof (char), BUFSIZE, fp);
 207       readCnt++;
 208       if (k < 0)
 209         fprintf (stderr, "++ERROR reading %s, error %d\n", sfn, errno);
 210
 211
 212       if (k == 0)
 213         {
 214           /* close the file */
 215           fclose (fp);
 216           fp = NULL;
 217           otherIOCnt++;
 218           break;
 219
 220         }
 221       else if (k != BUFSIZE)
 222         {
 223           /* short read */
 224           sprintf (buf, "\tunexpecter short read %d on %s\n", k, sfn);
 225           fprintf (stderr, buf);
 226           bRead += k;
 227           break;
 228         }
 229       else
 230         {
 231           /* bump the block counter */
 232           i++;
 233           bRead += k;
 234         }
 235     }
 236
 237   if (fp != NULL)
 238     {
 239       fclose (fp);
 240       fp = NULL;
 241     }
 242   sprintf (buf, "fread: %d blocks of %d", i, BUFSIZE);
 243   bytes = whrvlog (gethrtime () - start, gethrvtime () - vstart, buf, NULL);
 244   bWritten += bytes;
 245   writeCnt++;
 246
 247   bWritten += 99; /* the number of bytes are written by the next fprintf */
 248   writeCnt++;
 249
 250   unlink (sfn);
 251   otherIOCnt++;
 252   fprintf (fid2, "X   %14d  %14d  %17d  %15d  %17d   iofile\n",
 253            bRead, readCnt, bWritten, writeCnt, otherIOCnt);
 254   return 0;
 255 }
 256
 257 /*  iotest - do various io syscalls */
 258 int
 259 iotest ()
 260 {
 261   char *fname = "/tmp/foobar";
 262   int fd;   /* file descriptor for raw IO */
 263   int fd2;  /* file descriptor for raw IO */
 264   int k;    /* temp value for loop */
 265   char buf[BUFSIZE];
 266   unsigned long size = 0;
 267   int readCnt = 0;
 268   int bRead = 0;
 269   int writeCnt = 0;
 270   int bWritten = 0;
 271   int otherIOCnt = 0;
 272   int bytes = 0;
 273
 274   /* Log the regular read */
 275   bytes = wlog ("start of iotest", NULL);
 276   bWritten += bytes;
 277   writeCnt++;
 278
 279   /* create an empty file */
 280   fd = creat (fname, 0666);
 281   otherIOCnt++;
 282
 283   /* dup the file descriptor */
 284   fd2 = dup (fd);
 285   otherIOCnt++;
 286   close (fd2);
 287   otherIOCnt++;
 288   close (fd);
 289   otherIOCnt++;
 290
 291   /* now open the empty file */
 292   fd = open (fname, O_RDONLY);
 293   otherIOCnt++;
 294
 295   /* loop, reading into the buffer */
 296   size = 0;
 297   for (;;)
 298     {
 299       k = read (fd, buf, BUFSIZE);
 300       readCnt++;
 301       if (k < 0)
 302         fprintf (stderr, "++ERROR reading %s, error %d\n", fname, errno);
 303       else
 304         {
 305           size = size + k;
 306           bRead += k;
 307         }
 308       if (k != BUFSIZE)
 309         {
 310           /* close the file */
 311           close (fd);
 312           fd = -1;
 313           otherIOCnt++;
 314           bRead += k;
 315
 316           /* short eread = EOF */
 317           break;
 318         }
 319     }
 320   if (fd != -1)
 321     {
 322       close (fd);
 323       fd = -1;
 324     }
 325   bWritten += 99; /* the number of bytes are written by the next fprintf */
 326   writeCnt++;
 327
 328   /* remove the file */
 329   unlink (fname);
 330   otherIOCnt++;
 331   fprintf (fid2, "X   %14d  %14d  %17d  %15d  %17d   iotest\n",
 332            bRead, readCnt, bWritten, writeCnt, otherIOCnt);
 333
 334   return 0;
 335 }
 336
 337 /*
 338  * Memory mapping routines-
 339  *
 340  *  Allocate and deallocate memory using mmap and malloc.
 341  *
 342  *  There is one parameter--the total number of megabytes to write,
 343  *  written in as many 16 megabyte files as are needed
 344  */
 345
 346 unsigned char *start = (unsigned char*) 0x80000000;
 347 unsigned char *stop;
 348 int nblocks;
 349
 350 void
 351 memorymap (int megabytes)
 352 {
 353   int readCnt = 0;
 354   int bRead = 0;
 355   int writeCnt = 0;
 356   int bWritten = 0;
 357   int otherIOCnt = 0;
 358   int bytes;
 359
 360   /*
 361    * First, see how much time it takes to mmap all the files.
 362    *
 363    * Second, pull in just a few pages of information to see how much
 364    * time the "How much IBM do I hold?" question would take.
 365    *
 366    * Next, compare updating the database shared with updating it private
 367    * and then recopying the changed segments.
 368
 369    * (We could catch the pages that we have altered by mapping the
 370    * entire BIS read-only and then punching holes in it via an
 371    * mprotect call as we catch segfaults.  This gives us a list
 372    * of the pages that we need to write, at the added expense of
 373    * handling lots of interrupts.)
 374    * (Notice that we don't test the case where we are adding to
 375    * the BIS files.  This is an interesting situation as we either
 376    * have to open the last page past the last write point or reopen
 377    * extendable in some way.  We could do that by opening /dev/zero
 378    * with MAP_ANON for addresses above our current usage point.
 379    */
 380
 381   int i;
 382   stop = start + 1024 * 1024 * (long long) megabytes;
 383
 384   printf ("Creating %d random numbers\n", SIZE);
 385   for (i = 0; i < SIZE; i++)
 386     buffer[i] = random ();  // set pseudo-bis to noise
 387   printf ("Done creating random numbers\n");
 388
 389
 390   /*
 391    * Write a database consisting of 16 megabyte files.
 392    * Each filename contains the memory address into which
 393    * the file should be reloaded.
 394    */
 395
 396   printf ("Writing pseudo-bis files\n");
 397   unsigned char* base = start;
 398   nblocks = 0;
 399   for (i = 0; i < megabytes; i += 16)
 400     {
 401       nblocks++;
 402       // write data in 16MB files
 403       char filename[256];
 404       sprintf (filename, "bistest.%p.%d", base, i);
 405       int fd = open (filename, O_CREAT | O_TRUNC | O_WRONLY, 0660);
 406       otherIOCnt++;
 407       if (fd == -1)
 408         {
 409           printf ("open of %s failed: %s\n", filename, strerror (errno));
 410           exit (0);
 411         }
 412       bytes = write (fd, buffer, SIZE);
 413       bWritten += bytes;
 414       writeCnt++;
 415       close (fd);
 416       otherIOCnt++;
 417       printf ("\twrote %d megabytes\n", i + 16);
 418       base += 16 * 1024 * 1024;
 419     }
 420   printf ("Done writing files from %p to %p\n", start, stop);
 421
 422   int j;
 423
 424   printf ("Memory map all the files (private)\n");
 425   for (i = 0; i < megabytes; i += 16)
 426     {
 427       unsigned char* base = start;
 428       base += i * 1024 * 1024;
 429       char filename[256];
 430       sprintf (filename, "bistest.%p.%d", base, i);
 431       int fd = open (filename, O_RDWR);
 432       otherIOCnt++;
 433       if (fd < 0)
 434         printf ("open of %s failed: %s\n", filename, strerror (errno));
 435       unsigned char *mp = (unsigned char*) mmap ((char*) base,
 436                                                  SIZE, PROT_READ | PROT_WRITE,
 437                                                  MAP_PRIVATE | MAP_FIXED, fd, 0);
 438       if (mp == MAP_FAILED || mp != base)
 439         {
 440           printf ("mmap of %s failed: %s\n", filename, strerror (errno));
 441           exit (1);
 442         }
 443
 444       printf ("mapped %d bytes at %p\n", SIZE, base);
 445       close (fd); // mmap will hold the file open for us
 446       otherIOCnt++;
 447     }
 448
 449   printf ("Mapping done\n");
 450   fflush (stdout);
 451   otherIOCnt++;
 452
 453   int ranlimit = 1000;
 454   printf ("Access %d bytes at random\n", ranlimit);
 455   int sum = 0;
 456   for (i = 0; i < ranlimit; i++)
 457     {
 458       unsigned char *where = start +
 459               (((unsigned long) random ()) % (stop - start));
 460       sum += (int) *where;
 461     }
 462   printf ("Random byte access done\n");
 463
 464   ranlimit = 1000;
 465   int ranrange = 256;
 466   printf ("Alter %d random locations, %d bytes each (private)\n",
 467           ranlimit, ranrange);
 468
 469   for (i = 0; i < ranlimit; i++)
 470     {
 471       unsigned char *where = start +
 472               (((unsigned long) random ()) % (stop - start));
 473       for (j = 0; j < ranrange; j++)
 474         *where++ = j;
 475     }
 476
 477   printf ("Memory alteration done\n");
 478   fflush (stdout);
 479   otherIOCnt++;
 480
 481   printf ("Copy all memory back to disk\n");
 482
 483   for (i = 0; i < megabytes; i += 16)
 484     {
 485       unsigned char* base = start;
 486       base += i * 1024 * 1024;
 487       char filename[256];
 488       sprintf (filename, "bistest2.%p.%d", base, i);
 489       int fd = open (filename, O_RDWR | O_CREAT | O_TRUNC, 0660);
 490       otherIOCnt++;
 491       if ((bytes = write (fd, base, SIZE)) == -1)
 492         {
 493           printf ("write of %s failed: %s\n", filename, strerror (errno));
 494           exit (1);
 495         }
 496       bWritten += bytes;
 497       writeCnt++;
 498       close (fd);
 499       otherIOCnt++;
 500     }
 501
 502   printf ("Disk copy complete\n");
 503   fflush (stdout);
 504   otherIOCnt++;
 505
 506   printf ("Unmap all segments\n");
 507   for (i = 0; i < megabytes; i += 16)
 508     {
 509       unsigned char* base = start;
 510       base += i * 1024 * 1024;
 511       if (munmap ((char*) base, SIZE) == -1)
 512         {
 513           printf ("munmap failed: %s\n", strerror (errno));
 514           exit (1);
 515         }
 516       printf ("unmapped %d bytes at %p\n", SIZE, base);
 517     }
 518   printf ("Segment unmapping complete\n");
 519   fflush (stdout);
 520   otherIOCnt++;
 521
 522   printf ("Remap all segments as shared\n");
 523   for (i = 0; i < megabytes; i += 16)
 524     {
 525       unsigned char* base = start;
 526       base += i * 1024 * 1024;
 527       char filename[256];
 528       sprintf (filename, "bistest.%p.%d", base, i);
 529       int fd = open (filename, O_RDWR);
 530       otherIOCnt++;
 531       char* mp = mmap ((char*) base, SIZE, PROT_READ | PROT_WRITE,
 532                        MAP_SHARED | MAP_FIXED, fd, 0);
 533       if (mp == MAP_FAILED || (unsigned char*) mp != base)
 534         {
 535           printf ("re mmap of %s failed: %s\n", filename, strerror (errno));
 536           exit (1);
 537         }
 538       printf ("remapped %d bytes at %p\n", SIZE, base);
 539       close (fd); // mmap will hold the file open for us
 540       otherIOCnt++;
 541     }
 542   printf ("Remapping complete\n");
 543   fflush (stdout);
 544   otherIOCnt++;
 545
 546   ranlimit = 1000;
 547   ranrange = 256;
 548   printf ("Alter %d random locations, %d bytes each (shared)\n",
 549           ranlimit, ranrange);
 550   for (i = 0; i < ranlimit; i++)
 551     {
 552       unsigned char* where = start +
 553               (((unsigned long) random ()) % (stop - start));
 554       for (j = 0; j < ranrange; j++)
 555         *where++ = j;
 556     }
 557   printf ("Memory alteration done\n");
 558   fflush (stdout);
 559   otherIOCnt++;
 560
 561   printf ("Unmap all segments\n");
 562   for (i = 0; i < megabytes; i += 16)
 563     {
 564       unsigned char *base = start;
 565       base += i * 1024 * 1024;
 566       if (munmap ((char*) base, SIZE) == -1)
 567         {
 568           printf ("munmap failed: %s\n", strerror (errno));
 569           exit (1);
 570         }
 571       printf ("unmapped %d bytes at %p\n", SIZE, base);
 572     }
 573   printf ("Segment unmapping complete\n");
 574   fflush (stdout);
 575   otherIOCnt++;
 576
 577   base = start;
 578
 579   for (i = 0; i < megabytes; i += 16)
 580     {
 581       // write data in 16MB files
 582       char filename[256];
 583       sprintf (filename, "bistest.%p.%d", base, i);
 584       if (unlink (filename) != 0)
 585         {
 586           printf ("unlink of %s failed: %s\n", filename, strerror (errno));
 587         }
 588       base += 16 * 1024 * 1024;
 589       otherIOCnt++;
 590     }
 591
 592   for (i = 0; i < megabytes; i += 16)
 593     {
 594       unsigned char* base = start;
 595       base += i * 1024 * 1024;
 596       char filename[256];
 597       sprintf (filename, "bistest2.%p.%d", base, i);
 598       if (unlink (filename) != 0)
 599         {
 600           printf ("unlink of %s failed: %s\n", filename, strerror (errno));
 601         }
 602       otherIOCnt++;
 603     }
 604   bWritten += 102; /* the number of bytes are written by the next fprintf */
 605   writeCnt++;
 606
 607   fflush (fid2);
 608   otherIOCnt++;
 609
 610   /* Record accounting record */
 611   fprintf (fid2, "X   %14d  %14d  %17d  %15d  %17d   memorymap\n",
 612            bRead, readCnt, bWritten, writeCnt, otherIOCnt);
 613   printf ("Deleted scratch files\n");
 614 }