Changeset 924b0a0

Timestamp:

05/18/10 13:46:30 (12 years ago)

Author:

Perry Lorier <perry@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes

Children:

270fb67

Parents:

d5a42c2

Message:

Enforce alignment constraints

File:

• lib/ior-peek.c (modified) (5 diffs)

lib/ior-peek.c

@@ -40 +40 @@
 #include <string.h>
 #include <assert.h>
+#include <stddef.h>
 
 /* Libtrace IO module implementing a peeking reader.
@@ -107 +108 @@
                 DATA(io)->length = bytes_read;
                 DATA(io)->offset = 0;
+#ifdef _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
+                /* We need to do this as read() of O_DIRECT might happen into this buffer.
+                 * The docs suggest 512 bytes is all we need to align to, but I'm suspicious
+                 * I expect disks with 4k blocks will arrive soon, and thus 4k is the minimum I'm
+                 * willing to live with.
+                 */
+                posix_memalign(&DATA(io)->buffer, 4096, DATA(io)->length);
+#else
                 DATA(io)->buffer = malloc(DATA(io)->length);
+#endif
         }
         else
                 DATA(io)->length = bytes_read;
+
+        assert(DATA(io)->buffer);
 
         /* Now actually attempt to read that many bytes */
@@ -151 +163 @@
                 off_t bytes_read;
                 /* If they're reading exactly a block size, just use that, no point in malloc'ing 
-                 * and memcpy()ing needlessly 
+                 * and memcpy()ing needlessly.  However, if the buffer isn't aligned, we need to
+                 * pass on an aligning buffer, skip this and do it into our own aligned buffer.
                  */
-                if (len % MIN_READ_SIZE  == 0) {
+                if ((len % MIN_READ_SIZE  == 0) && ((ptrdiff_t)buffer % 4096)==0) {
+                        assert(((ptrdiff_t)buffer % 4096) == 0);
                         bytes_read = DATA(io)->child->source->read(
                                         DATA(io)->child, buffer, len);
@@ -196 +210 @@
 }
 
+static void *alignedrealloc(void *old, size_t oldsize, size_t size)
+{
+#if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
+        void *new;
+        /* Shortcut resizing */
+        if (size < oldsize)
+                return old;
+        posix_memalign(&new, 4096, size);
+        assert(oldsize<size);
+        memcpy(new,old,oldsize);
+        free(old);
+        return new;
+#else
+        return realloc(old,size);
+#endif
+}
+
 
 static off_t peek_peek(io_t *io, void *buffer, off_t len)
@@ -207 +238 @@
                 /* Round the read_amount up to the nearest MB */
                 read_amount += PEEK_SIZE - ((DATA(io)->length + read_amount) % PEEK_SIZE);
-                DATA(io)->buffer = realloc(DATA(io)->buffer, DATA(io)->length + read_amount);
+                DATA(io)->buffer = alignedrealloc(DATA(io)->buffer, DATA(io)->length, 
+                        DATA(io)->length + read_amount);
                 /* Use the child reader to read more data into our managed
                  * buffer */