xfs
[Top] [All Lists]

[PATCH 02/11] xfstests: randholes: only allocate write buffer when neede

To: xfs@xxxxxxxxxxx
Subject: [PATCH 02/11] xfstests: randholes: only allocate write buffer when needed
From: Alex Elder <aelder@xxxxxxx>
Date: Thu, 14 Oct 2010 09:49:52 -0500
Reply-to: aelder@xxxxxxx
If nothing is being written (i.e., in "test" mode), there's no need
for "randholes" to allocate a write buffer.  But to do this we make
this series of changes:
- When "very" verbose (> 1), there's no point in printing the values
  that have just been written to the file.  They are just the file
  offset, and the buffer will not have changed between initializing
  those values and writing it out.
- If we don't print the values at those offsets, then there's no
  need to fill them in at all when we're in test mode.
- Now we only use the write buffer if we're not in test mode,
  so we can skip the allocation.

Signed-off-by: Alex Elder <aelder@xxxxxxx>

---
 src/randholes.c |   45 ++++++++++++++++++++++++++-------------------
 1 file changed, 26 insertions(+), 19 deletions(-)

Index: b/src/randholes.c
===================================================================
--- a/src/randholes.c
+++ b/src/randholes.c
@@ -233,17 +233,21 @@ writeblks(char *fname, int fd)
        int block;
        struct flock64 fl;
 
-       if (direct)
-               buffer = memalign(diob.d_mem, blocksize);
-       else
-               buffer = malloc(blocksize);
-       if (buffer == NULL) {
-               perror("malloc");
-               exit(1);
+       if (test)
+               buffer = NULL;
+       else {
+               if (direct)
+                       buffer = memalign(diob.d_mem, blocksize);
+               else
+                       buffer = malloc(blocksize);
+               if (buffer == NULL) {
+                       perror("malloc");
+                       exit(1);
+               }
+               memset(buffer, 0, blocksize);
        }
-       memset(buffer, 0, blocksize);
 
-       for (  ; count > 0; count--) {
+       do {
                if (verbose && ((count % 100) == 0)) {
                        printf(".");
                        fflush(stdout);
@@ -285,23 +289,26 @@ bozo!
                                perror("lseek");
                                exit(1);
                        }
-                }
-               *(__uint64_t *)buffer = *(__uint64_t *)(buffer+256) =
-                       fileoffset + offset;
-                if (!test) {
+                       /*
+                        * Before writing, record offset at the base
+                        * of the buffer and at offset 256 bytes
+                        * into it.  We'll verify this when we read
+                        * it back in again.
+                        */
+                       *(__uint64_t *) buffer = fileoffset + offset;
+                       *(__uint64_t *) (buffer + 256) = fileoffset + offset;
+
                        if (write(fd, buffer, blocksize) < blocksize) {
                                perror("write");
                                exit(1);
                        }
                 }
-                if (test && verbose>1) printf("NOT ");
                if (verbose > 1) {
-                       printf("writing data at offset=%llx, value 0x%llx and 
0x%llx\n",
-                              (unsigned long long)(fileoffset + offset),
-                              *(unsigned long long *)buffer,
-                              *(unsigned long long *)(buffer+256));
+                       printf("%swriting data at offset=%llx\n",
+                               test ? "NOT " : "",
+                               (unsigned long long) (fileoffset + offset));
                }
-       }
+       } while (--count);
 
        free(buffer);
 }


<Prev in Thread] Current Thread [Next in Thread>
  • [PATCH 02/11] xfstests: randholes: only allocate write buffer when needed, Alex Elder <=