I rather suspect its the difference in strategies for our file systems. OpenBSD uses ffs and I've enabled soft updates as well (normal and common). The filesystem is normally in sync mode and IIRC soft updates relaxes that somewhat for the data while continuing to be strict about meta-data. Again, IIRC Linux's ext2/3 operates in async mode by default which is faster but is less able to handle interruptions.

$ perl perrin-bench3.pl
Benchmark: timing 10 iterations of berkeley write, file print, file sy
+swrite, file write...
berkeley write: 96 wallclock secs (25.02 usr + 21.67 sys = 46.69 CPU) 
+@  0.21/s (n=10)
file print: 54 wallclock secs (23.83 usr + 12.98 sys = 36.81 CPU) @  0
+.27/s (n=10)
file syswrite: 44 wallclock secs (23.17 usr + 11.72 sys = 34.89 CPU) @
+  0.29/s (n=10)
file write: 54 wallclock secs (23.65 usr + 12.34 sys = 35.99 CPU) @  0
+.28/s (n=10)
               s/iter berkeley write     file print     file write fil
+e syswrite
berkeley write   4.67             --           -21%           -23%    
+      -25%
file print       3.68            27%             --            -2%    
+       -5%
file write       3.60            30%             2%             --    
+       -3%
file syswrite    3.49            34%             6%             3%    
+        --
Benchmark: timing 10 iterations of berkeley read, file read, file slur
+p, file sysread...
berkeley read: 170 wallclock secs (10.95 usr +  7.75 sys = 18.70 CPU) 
+@  0.53/s (n=10)
file read: 156 wallclock secs ( 7.68 usr +  6.01 sys = 13.69 CPU) @  0
+.73/s (n=10)
file slurp: 173 wallclock secs (11.71 usr +  6.62 sys = 18.33 CPU) @  
+0.55/s (n=10)
file sysread: 194 wallclock secs ( 6.80 usr +  5.45 sys = 12.25 CPU) @
+  0.82/s (n=10)
              s/iter berkeley read    file slurp     file read  file s
+ysread
berkeley read   1.87            --           -2%          -27%        
+  -34%
file slurp      1.83            2%            --          -25%        
+  -33%
file read       1.37           37%           34%            --        
+  -11%
file sysread    1.23           53%           50%           12%        
+    --


--- perrin-bench2.pl    Tue Mar 18 12:00:06 2003
+++ perrin-bench3.pl    Tue Mar 18 14:00:21 2003
@@ -35,6 +35,34 @@
   return $value;
 }

+sub slurp_file {
+  my $key = shift;
+  my $file = "$file_dir/$key";
+  local $/;
+  open(FH, '<', $file) or die $!;
+  my $value = <FH>;
+  close FH;
+  return $value;
+}
+
+sub sysread_file {
+  my $key = shift;
+  my $file = "$file_dir/$key";
+  my $value;
+  open(FH, '<', $file) or die $!;
+  sysread FH, $value, (stat FH)[7];
+  close FH;
+  return $value;
+}
+
+sub print_file {
+  my ($key, $value) = @_;
+  my $file = "$file_dir/$key";
+  open(FH, '>', $file) or die $!;
+  print FH $value;
+  close FH;
+}
+
 sub write_file {
   my ($key, $value) = @_;
   my $file = "$file_dir/$key";
@@ -43,13 +71,30 @@
   close FH;
 }

+sub syswrite_file {
+  my ($key, $value) = @_;
+  my $file = "$file_dir/$key";
+  open(FH, '>', $file) or die $!;
+  print FH $value;
+  close FH;
+}
+
 cmpthese(10, {
     'file write' => sub {
       for (0..1000) {
        write_file($_, $_ x 8000);
       }
     },
-
+    'file print' => sub {
+      for (0..1000) {
+       print_file($_, $_ x 8000);
+      }
+    },
+    'file syswrite' => sub {
+      for (0..1000) {
+       syswrite_file($_, $_ x 8000);
+      }
+    },
     'berkeley write' => sub {
       for (0..1000) {
        $db_obj->db_put($_, $_ x 8000);
@@ -62,6 +107,18 @@
       my $test;
       for (0..1000) {
        $test = read_file($_);
+      }
+    },
+    'file slurp' => sub {
+      my $test;
+      for (0..1000) {
+       $test = slurp_file($_);
+      }
+    },
+    'file sysread' => sub {
+      my $test;
+      for (0..1000) {
+       $test = sysread_file($_);
       }
     },
     'berkeley read' => sub {
[download]

Here are mine on Linux:

Benchmark: timing 50 iterations of berkeley write, file print, file sy
+swrite, file write...
berkeley write: 20 wallclock secs ( 5.60 usr +  3.57 sys =  9.17 CPU) 
+@  5.45/s (n=50)
file print: 24 wallclock secs ( 4.81 usr +  4.31 sys =  9.12 CPU) @  5
+.48/s (n=50)
file syswrite: 24 wallclock secs ( 4.67 usr +  4.21 sys =  8.88 CPU) @
+  5.63/s (n=50)
file write: 26 wallclock secs ( 4.63 usr +  4.15 sys =  8.78 CPU) @  5
+.69/s (n=50)
                 Rate berkeley write     file print file syswrite     
+file write
berkeley write 5.45/s             --            -1%           -3%     
+       -4%
file print     5.48/s             1%             --           -3%     
+       -4%
file syswrite  5.63/s             3%             3%            --     
+       -1%
file write     5.69/s             4%             4%            1%     
+        --
Benchmark: timing 100 iterations of berkeley read, file read, file slu
+rp, file sysread...
berkeley read: 16 wallclock secs ( 3.67 usr +  3.32 sys =  6.99 CPU) @
+ 14.31/s (n=100)
 file read:  9 wallclock secs ( 2.96 usr +  2.25 sys =  5.21 CPU) @ 19
+.19/s (n=100)
file slurp: 12 wallclock secs ( 4.63 usr +  2.26 sys =  6.89 CPU) @ 14
+.51/s (n=100)
file sysread:  8 wallclock secs ( 2.85 usr +  2.05 sys =  4.90 CPU) @ 
+20.41/s (n=100)
                Rate berkeley read    file slurp     file read  file s
+ysread
berkeley read 14.3/s            --           -1%          -25%        
+  -30%
file slurp    14.5/s            1%            --          -24%        
+  -29%
file read     19.2/s           34%           32%            --        
+   -6%
file sysread  20.4/s           43%           41%            6%        
+    --
[download]

Pretty similar, except that syswrite() seems to be a better choice on Linux while read() is a better choice on BSD.