Though for a program like cp, this may qualify as a big diff. :)
Continuing in my "make IO suck less" phase, cp would be a lot more
efficient if it didn't bounce the disk heads around so much. Instead of
using a tiny 64k buffer, use an amount based on a small fraction of RAM.
Index: utils.c
===================================================================
RCS file: /home/tedu/cvs/src/bin/cp/utils.c,v
retrieving revision 1.30
diff -u -r1.30 utils.c
--- utils.c 27 Oct 2009 23:59:21 -0000 1.30
+++ utils.c 6 Feb 2010 01:46:42 -0000
@@ -34,6 +34,7 @@
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/time.h>
+#include <sys/sysctl.h>
#include <err.h>
#include <errno.h>
@@ -46,29 +47,75 @@
#include "extern.h"
-int
-copy_file(FTSENT *entp, int dne)
+static void *
+allocbuf(size_t *sizep)
{
- static char *buf;
- static char *zeroes;
- struct stat to_stat, *fs;
- int ch, checkch, from_fd, rcount, rval, to_fd, wcount;
-#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
- char *p;
-#endif
-
- if (!buf) {
- buf = malloc(MAXBSIZE);
- if (!buf)
- err(1, "malloc");
+ int mib[2];
+ uint64_t physmem;
+ void *buf;
+ size_t size = 0;
+ size_t oldlen;
+
+ mib[0] = CTL_HW;
+ mib[1] = HW_PHYSMEM64;
+ oldlen = sizeof(physmem);
+ if (sysctl(mib, 2, &physmem, &oldlen, NULL, 0) == 0) {
+ size = physmem / 512;
+ size -= size % MAXBSIZE;
}
+ if (size < MAXBSIZE)
+ size = MAXBSIZE;
+ buf = malloc(size);
+ if (!buf)
+ err(1, "allocbuf(%ld)", size);
+
+ *sizep = size;
+ return buf;
+}
+
+static ssize_t
+writebuf(int to_fd, void *buf, ssize_t rcount, int skipholes)
+{
+ static void *zeroes;
+ ssize_t wcount = 0;
+ int amt = MAXBSIZE;
+ const char *bp = buf;
+ ssize_t left = rcount;
+
if (!zeroes) {
- zeroes = malloc(MAXBSIZE);
+ zeroes = calloc(1, amt);
if (!zeroes)
- err(1, "malloc");
- memset(zeroes, 0, MAXBSIZE);
+ err(1, "calloc");
+ }
+ while (left > 0) {
+ amt = MIN(amt, rcount);
+ if (skipholes && memcmp(bp, zeroes, amt) == 0)
+ wcount = lseek(to_fd, amt, SEEK_CUR) == -1 ? -1 : amt;
+ else
+ wcount = write(to_fd, bp, amt);
+ if (wcount != amt)
+ return -1;
+ bp += wcount;
+ left -= wcount;
}
+ return rcount;
+}
+
+int
+copy_file(FTSENT *entp, int dne)
+{
+ static void *buf;
+ static size_t bufsize;
+ struct stat to_stat, *fs;
+ int ch, checkch, from_fd, rval, to_fd;
+ size_t rcount, wcount;
+ int skipholes = 0;
+ struct stat tosb;
+
+ if (!buf)
+ buf = allocbuf(&bufsize);
+
if ((from_fd = open(entp->fts_path, O_RDONLY, 0)) == -1) {
warn("%s", entp->fts_path);
return (1);
@@ -114,54 +161,21 @@
}
rval = 0;
-
- /*
- * Mmap and write if less than 8M (the limit is so we don't totally
- * trash memory on big files. This is really a minor hack, but it
- * wins some CPU back.
- */
-#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
- if (fs->st_size <= 8 * 1048576) {
- if ((p = mmap(NULL, (size_t)fs->st_size, PROT_READ,
- MAP_FILE|MAP_SHARED, from_fd, (off_t)0)) == MAP_FAILED) {
- warn("mmap: %s", entp->fts_path);
- rval = 1;
- } else {
- madvise(p, fs->st_size, MADV_SEQUENTIAL);
- if (write(to_fd, p, fs->st_size) != fs->st_size) {
- warn("%s", to.p_path);
- rval = 1;
- }
- /* Some systems don't unmap on close(2). */
- if (munmap(p, fs->st_size) < 0) {
- warn("%s", entp->fts_path);
- rval = 1;
- }
- }
- } else
-#endif
- {
- int skipholes = 0;
- struct stat tosb;
- if (!fstat(to_fd, &tosb) && S_ISREG(tosb.st_mode))
- skipholes = 1;
- while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
- if (skipholes && memcmp(buf, zeroes, rcount) == 0)
- wcount = lseek(to_fd, rcount, SEEK_CUR) == -1 ?
-1 : rcount;
- else
- wcount = write(to_fd, buf, rcount);
- if (rcount != wcount || wcount == -1) {
- warn("%s", to.p_path);
- rval = 1;
- break;
- }
- }
- if (skipholes && rcount >= 0)
- rcount = ftruncate(to_fd, fs->st_size);
- if (rcount < 0) {
- warn("%s", entp->fts_path);
+ if (!fstat(to_fd, &tosb) && S_ISREG(tosb.st_mode))
+ skipholes = 1;
+ while ((rcount = read(from_fd, buf, bufsize)) > 0) {
+ wcount = writebuf(to_fd, buf, rcount, skipholes);
+ if (rcount != wcount) {
+ warn("%s", to.p_path);
rval = 1;
+ break;
}
+ }
+ if (skipholes && rcount >= 0)
+ rcount = ftruncate(to_fd, fs->st_size);
+ if (rcount < 0) {
+ warn("%s", entp->fts_path);
+ rval = 1;
}
if (rval == 1) {
