Hello community,

here is the log from the commit of package bonnie for openSUSE:Factory checked 
in at 2019-11-06 14:05:20
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/bonnie (Old)
 and      /work/SRC/openSUSE:Factory/.bonnie.new.2990 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "bonnie"

Wed Nov  6 14:05:20 2019 rev:22 rq:745342 version:1.6

Changes:
--------
--- /work/SRC/openSUSE:Factory/bonnie/bonnie.changes    2016-07-03 
12:27:48.000000000 +0200
+++ /work/SRC/openSUSE:Factory/.bonnie.new.2990/bonnie.changes  2019-11-06 
14:05:22.276739891 +0100
@@ -1,0 +2,26 @@
+Tue Nov  5 08:10:10 UTC 2019 - Martin Pluskal <[email protected]>
+
+- Do not use download url anymore
+
+-------------------------------------------------------------------
+Thu Oct 17 14:50:53 UTC 2019 - Richard Brown <[email protected]>
+
+- Remove obsolete Groups tag (fate#326485)
+
+-------------------------------------------------------------------
+Fri Jan 11 11:17:49 CET 2019 - [email protected]
+
+- bonnie-fix-o_direct.diff: Don't use O_DIRECT for character input,
+  as newer kernels don't allow this.
+
+-------------------------------------------------------------------
+Fri Jan 11 11:17:02 CET 2019 - [email protected]
+
+- Update to bonnie-1.6:
+  * Use 16 threads by default
+  * Smaller 4k reads (seeking)
+  * Larger blocks in intelligent read/write
+  * Smaller I/O size for char in/out
+  * More digits for formatting.
+
+-------------------------------------------------------------------

Old:
----
  bonnie-1.5.tar.bz2

New:
----
  bonnie-1.6.tar.bz2
  bonnie-fix-o_direct.diff

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ bonnie.spec ++++++
--- /var/tmp/diff_new_pack.lIyGRK/_old  2019-11-06 14:05:22.976740624 +0100
+++ /var/tmp/diff_new_pack.lIyGRK/_new  2019-11-06 14:05:22.976740624 +0100
@@ -1,7 +1,7 @@
 #
 # spec file for package bonnie
 #
-# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany.
 #
 # All modifications and additions to the file contributed by third parties
 # remain the property of their copyright owners, unless otherwise agreed
@@ -12,19 +12,18 @@
 # license that conforms to the Open Source Definition (Version 1.9)
 # published by the Open Source Initiative.
 
-# Please submit bugfixes or comments via http://bugs.opensuse.org/
+# Please submit bugfixes or comments via https://bugs.opensuse.org/
 #
 
 
 Name:           bonnie
-Version:        1.5
+Version:        1.6
 Release:        0
 Summary:        File System Benchmark
-License:        GPL-2.0+
-Group:          System/Benchmark
-Url:            https://code.google.com/p/bonnie-64/
-Source0:        https://fossies.org/linux/privat/old/%{name}-%{version}.tar.bz2
-BuildRoot:      %{_tmppath}/%{name}-%{version}-build
+License:        GPL-2.0-or-later
+URL:            https://code.google.com/p/bonnie-64/
+Source0:        %{name}-%{version}.tar.bz2
+Patch0:         bonnie-fix-o_direct.diff
 
 %description
 Bonnie is a popular performance benchmark that targets various aspects
@@ -32,6 +31,7 @@
 
 %prep
 %setup -q -n %{name}
+%patch0
 
 %build
 make SYSFLAGS="%{optflags}" %{?_smp_mflags}
@@ -40,9 +40,8 @@
 %make_install
 
 %files
-%defattr(-, root, root)
 %doc bonnie.doc README
 %{_bindir}/bonnie
-%{_mandir}/man1/bonnie.1%{ext_man}
+%{_mandir}/man1/bonnie.1%{?ext_man}
 
 %changelog

++++++ bonnie-1.5.tar.bz2 -> bonnie-1.6.tar.bz2 ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/bonnie/Bonnie.c new/bonnie/Bonnie.c
--- old/bonnie/Bonnie.c 2012-02-04 15:27:50.000000000 +0100
+++ new/bonnie/Bonnie.c 2016-02-17 14:09:47.000000000 +0100
@@ -3,6 +3,11 @@
  * it is named 'Bonnie' after Bonnie Raitt, who knows how to use one.
  * 
  * TODO: Reproducable random numbers
+ * Modified, 13/02/17, Kurt Garloff <[email protected]>
+ * Use 4MB chunks for block rw/rd/wr, use 16 seeker threads with 4k reads from
+ * 8k aligned bufs. This gives better perf on high-end storage. Smaller tests
+ * with getc/putc.
+ * 
  * Modified, 03/10/21, Kurt Garloff <[email protected]>
  * Patch from Christian Kirsch (ix) to support MacOS X: Define PAGE_MASK.
  * 
@@ -59,7 +64,7 @@
  *  or consequential damage, loss, costs or fees or expenses of any
  *  nature or kind.
  */
-/* $Id: Bonnie.c,v 1.3 2012/02/04 14:27:50 garloff Exp $ */
+/* $Id: Bonnie.c,v 1.5 2016/02/17 13:09:47 garloff Exp $ */
 
 #include <unistd.h>
 #include <stdio.h>
@@ -105,15 +110,15 @@
 //#define Seeks (4000)
 unsigned Seeks = 4000;
 #define UpdateSeek (10)
-//#define SeekProcCount (3)
-unsigned SeekProcCount = 3;
-#define Chunk (1UL<<20)
-#define SmallChunk (8192UL)
-#define SeekChunk (16384UL)
+//#define SeekProcCount (16)
+unsigned SeekProcCount = 16;
+#define Chunk (4UL<<20)
+#define SmallChunk (4096UL)
+#define SeekChunk (8192UL)
 
 #if defined(__linux__)
 //# include <asm/fcntl.h>
-# if !defined(O_DIRECT) && (defined(__alpha__) || defined(__i386__) || 
defined(__x86_64__))
+# if !defined(O_DIRECT) && (defined(__alpha__) || defined(__i386__) || 
defined(__x86_64__)) || defined(__arm__)
 #  define O_DIRECT 040000 /* direct disk access */
 # endif
 # ifdef O_DIRECT
@@ -144,8 +149,8 @@
 static void   srandom(int);
 #endif
 
-static void   report(char *, off_t, int);
-static void   write_html(char *, off_t, int);
+static void   report(char *, off_t, off_t, off_t, int);
+static void   write_html(char *, off_t, off_t, off_t, int);
 static double time_so_far(void);
 static void   timestamp(void);
 static void   usage(void);
@@ -163,7 +168,7 @@
 static double last_cpustamp = 0.0;       /* for computing delta-t */
 static double last_timestamp = 0.0;      /* for computing delta-t */
 
-static const char * version = "1.5";
+static const char * version = "1.6";
 
 #define MAXVOLUMES 512
 
@@ -327,12 +332,14 @@
   signal (SIGIO, breakhandler);
 #endif 
   /* Fill up a file, writing it a char at a time with the stdio putc() call */
+  off_t psz = size/4;
 #if defined(__GLIBC__) && __GLIBC__ >= 2
-  if (useunlock) 
-       fprintf(stderr, "Writing with putc_unlocked()...");
-  else
+  if (useunlock) {
+       psz = size/2;
+       fprintf(stderr, "Writing  %7iMiB with putc_unlocked()...", 
(int)(psz>>20));
+  } else
 #endif
-       fprintf(stderr, "Writing with putc()...         ");
+       fprintf(stderr, "Writing  %7iMiB with putc()...         ", 
(int)(psz>>20));
   fflush(stderr);
   for(volcnt = 0; volcnt < volumes; volcnt++)
     newfile(name, &fd[volcnt], &stream[volcnt], 1, volcnt, 0);
@@ -342,14 +349,14 @@
 #if defined(__GLIBC__) && __GLIBC__ >= 2
     if (useunlock)
     {
-      for (words = 0; words < size; words++)
+      for (words = 0; words < psz; words++)
         if (putc_unlocked(words & 0x7f, stream[volcnt]) == EOF)
           io_error("putc_unlocked");
     }
     else 
 #endif
     {
-      for (words = 0; words < size; words++)
+      for (words = 0; words < psz; words++)
         if (putc(words & 0x7f, stream[volcnt]) == EOF)
           io_error("putc");
     }
@@ -368,8 +375,8 @@
   get_delta_t(Putc);
   if (flshbfdev)
        flshbf(); 
-  fprintf(stderr, "done: %6d kiB/s %5.1f %%CPU\n",
-       (int) (((double) size * (double) volumes) / (delta[(int) Putc][Elapsed] 
* 1024.0)),
+  fprintf(stderr, "done:%7d kiB/s %5.1f %%CPU\n",
+       (int) (((double) psz * (double) volumes) / (delta[(int) Putc][Elapsed] 
* 1024.0)),
        delta[(int) Putc][CPU] / delta[(int) Putc][Elapsed] * 100.0);
 
   /* Now read & rewrite it using block I/O.  Dirty one word in each block */
@@ -378,7 +385,7 @@
   for(volcnt = 0; volcnt < volumes; volcnt++)
     if (lseek(fd[volcnt], (off_t) 0, 0) == (off_t) -1)
       io_error("lseek(2) before rewrite");
-  fprintf(stderr, "Rewriting... "); fflush(stderr);
+  fprintf(stderr, "Rewriting%7iMiB... ", (int)(size>>20)); fflush(stderr);
   timestamp();
   for(volcnt = 0; volcnt < volumes; volcnt++)
   {
@@ -407,14 +414,14 @@
   get_delta_t(ReWrite);
   if (flshbfdev)
        flshbf(); 
-  fprintf(stderr, "                  done: %6d kiB/s %5.1f %%CPU\n",
+  fprintf(stderr, "                    done:%7d kiB/s %5.1f %%CPU\n",
        (int) (((double) size * (double) volumes) / (delta[(int) 
ReWrite][Elapsed] * 1024.0)),
        delta[(int) ReWrite][CPU] / delta[(int) ReWrite][Elapsed] * 100.0);
 
   /* Write the whole file from scratch, again, with block I/O */
   for(volcnt = 0; volcnt < volumes; volcnt++)
     newfile(name, &fd[volcnt], &stream[volcnt], 1, volcnt, o_direct);
-  fprintf(stderr, "Writing intelligently... "); fflush(stderr);
+  fprintf(stderr, "Writing  %7iMiB intelligently... ", (int)(size>>20)); 
fflush(stderr);
   for (words = 0; words < Chunk / IntSize; words++)
     buf[words] = 0;
   timestamp();
@@ -436,7 +443,7 @@
   get_delta_t(FastWrite);
   if (flshbfdev)
        flshbf(); 
-  fprintf(stderr, "      done: %6d kiB/s %5.1f %%CPU\n",
+  fprintf(stderr, "      done:%7d kiB/s %5.1f %%CPU\n",
        (int) (((double) size * (double) volumes) / (delta[(int) 
FastWrite][Elapsed] * 1024.0)),
        delta[(int) FastWrite][CPU] / delta[(int) FastWrite][Elapsed] * 100.0);
 
@@ -445,19 +452,21 @@
     newfile(name, &fd[volcnt], &stream[volcnt], 0, volcnt, o_direct);
   for (words = 0; words < 256; words++)
     chars[words] = 0;
+  off_t gsz = size/8;
 #if defined(__GLIBC__) && __GLIBC__ >= 2
-  if (useunlock) 
-       fprintf(stderr, "Reading with getc_unlocked()...");
-  else  
+  if (useunlock) {
+       gsz = size/4;
+       fprintf(stderr, "Reading  %7iMiB with getc_unlocked()...", 
(int)(gsz>>20));
+  } else  
 #endif
-       fprintf(stderr, "Reading with getc()...         ");
+       fprintf(stderr, "Reading  %7iMiB with getc()...         ", 
(int)(gsz>>20));
   fflush(stderr);
   timestamp();
   for(volcnt = 0; volcnt < volumes; volcnt++)
 #if defined(__GLIBC__) && __GLIBC__ >= 2
     if (useunlock) 
     {
-      for (words = 0; words < size; words++)
+      for (words = 0; words < gsz; words++)
       { /* for each byte */
         if ((next = getc_unlocked(stream[volcnt])) == EOF)
           io_error("getc_unlocked(3)");
@@ -469,7 +478,7 @@
     else
 #endif
     {
-      for (words = 0; words < size; words++)
+      for (words = 0; words < gsz; words++)
       { /* for each byte */
         if ((next = getc(stream[volcnt])) == EOF)
           io_error("getc(3)");
@@ -485,8 +494,8 @@
   get_delta_t(Getc);
   if (flshbfdev)
        flshbf(); 
-  fprintf(stderr, "done: %6d kiB/s %5.1f %%CPU\n",
-       (int) (((double) size * (double) volumes) / (delta[(int) Getc][Elapsed] 
* 1024.0)),
+  fprintf(stderr, "done:%7d kiB/s %5.1f %%CPU\n",
+       (int) (((double) gsz * (double) volumes) / (delta[(int) Getc][Elapsed] 
* 1024.0)),
        delta[(int) Getc][CPU] / delta[(int) Getc][Elapsed] * 100.0);
 
   /* use the frequency count */
@@ -499,7 +508,7 @@
   for(volcnt = 0; volcnt < volumes; volcnt++)
     if (lseek(fd[volcnt], (off_t) 0, 0) == -1)
       io_error("lseek before read");
-  fprintf(stderr, "Reading intelligently... "); fflush(stderr);
+  fprintf(stderr, "Reading  %7iMiB intelligently... ", (int)(size>>20)); 
fflush(stderr);
   timestamp();
   for(volcnt = 0; volcnt < volumes; volcnt++)
     do
@@ -515,7 +524,7 @@
   get_delta_t(FastRead);
   if (flshbfdev)
        flshbf(); 
-  fprintf(stderr, "      done: %6d kiB/s %5.1f %%CPU\n",
+  fprintf(stderr, "      done:%7d kiB/s %5.1f %%CPU\n",
        (int) (((double) size * (double) volumes) / (delta[(int) 
FastRead][Elapsed] * 1024.0)),
        delta[(int) FastRead][CPU] / delta[(int) FastRead][Elapsed] * 100.0);
 
@@ -555,6 +564,7 @@
   for ( ; next < (Seeks + SeekProcCount); next++)
     seek_tickets[next] = 0;
 
+  fprintf(stderr, "Seeker"); fflush(stderr);
   /* launch some parallel seek processes */
   for (next = 0; next < SeekProcCount; next++)
   { /* for each seek proc */
@@ -569,7 +579,7 @@
       /* don't bother with direct io here */
       newfile(name, &fd[0], &stream[0], 0, 0, 0);
       srandom(getpid() ^ (int) time((time_t *) 0));
-      fprintf(stderr, "Seeker %d...", next + 1);
+      fprintf(stderr, " %d", next + 1); fflush(stderr);
 
       /* wait for the go-ahead */
       if (read(seek_control[0], seek_tickets, 1) != 1)
@@ -607,7 +617,7 @@
   close(seek_feedback[1]);
   close(seek_control[0]);
   sleep(2+(SeekProcCount+4)/8);
-  fprintf(stderr, "start 'em...");
+  fprintf(stderr, " start 'em ");
   if (write(seek_control[1], seek_tickets, (Seeks+SeekProcCount)) 
       != (Seeks+SeekProcCount))
     io_error("write tickets");
@@ -639,7 +649,7 @@
     } /* not first time */
     if (wait(&child) == -1)
       io_error("wait");
-    fprintf(stderr, "done...");
+    fprintf(stderr, ".");
   } /* for each child */
   delta[(int) Lseek][Elapsed] = last_stop - first_start;
   read_bw = ((double) size * (double) volumes) / 
@@ -658,9 +668,9 @@
   fprintf(stderr, "\n");
 
   if (html)
-    write_html(machine, size, volumes);
+    write_html(machine, size, psz, gsz, volumes);
   else
-    report(machine, size, volumes);
+    report(machine, size, psz, gsz, volumes);
 
   delfiles ();
   free(__buf) ;
@@ -683,18 +693,20 @@
 write_html(
   char * machine,
   off_t  size,
+  off_t  psz,
+  off_t  gsz,
   int volumes)
 {
   printf("<TR><TD>%s</TD><TD>%ld * %d</TD>", machine, size / (1024 * 1024), 
volumes);
   printf("<TD>%d</TD><TD>%s</TD><TD>%d</TD><TD>%s</TD><TD>%d</TD><TD>%s</TD>",
-    (int) (((double) size * (double) volumes) / (delta[(int) Putc][Elapsed] * 
1024.0)),
+    (int) (((double) psz * (double) volumes) / (delta[(int) Putc][Elapsed] * 
1024.0)),
     cpupc(Putc),
     (int) (((double) size * (double) volumes) / (delta[(int) 
FastWrite][Elapsed] * 1024.0)),
     cpupc(FastWrite),
     (int) (((double) size * (double) volumes) / (delta[(int) ReWrite][Elapsed] 
* 1024.0)),
     cpupc(ReWrite));
   printf("<TD>%d</TD><TD>%s</TD><TD>%d</TD><TD>%s</TD>",
-    (int) (((double) size * (double) volumes) / (delta[(int) Getc][Elapsed] * 
1024.0)),
+    (int) (((double) gsz * (double) volumes) / (delta[(int) Getc][Elapsed] * 
1024.0)),
     cpupc(Getc),
     (int) (((double) size * (double) volumes) / (delta[(int) 
FastRead][Elapsed] * 1024.0)),
     cpupc(FastRead));
@@ -707,48 +719,50 @@
 report(
   char * machine,
   off_t  size,
+  off_t  psz,
+  off_t  gsz,
   int volumes)
 {
-  printf("              ");
+  printf("                ");
   printf(
-    "---Sequential Output %s--- ---Sequential Input-- --Rnd Seek-\n",
+    "----Sequential Output %s----- ----Sequential Input--- --Rnd Seek-\n",
     (dosync? "(sync)--": "(nosync)"));
-  printf("              ");
+  printf("                ");
   if (o_direct && useunlock)
   printf(
-    "-CharUnlk- -DIOBlock- -DRewrite- -CharUnlk- -DIOBlock- --%02uk (%02u)-\n",
+    "-CharUnlk-- -DIOBlock-- -DRewrite-- -CharUnlk-- -DIOBlock-- --%02uk 
(%02u)-\n",
     (Seeks+500)/1000, SeekProcCount);
   else if (o_direct && !useunlock)
   printf(
-    "-Per Char- -DIOBlock- -DRewrite- -Per Char- -DIOBlock- --%02uk (%02u)-\n",
+    "-Per Char-- -DIOBlock-- -DRewrite-- -Per Char-- -DIOBlock-- --%02uk 
(%02u)-\n",
     (Seeks+500)/1000, SeekProcCount);
   else if (!o_direct && useunlock)
   printf(
-    "-CharUnlk- --Block--- -Rewrite-- -CharUnlk- --Block--- --%02uk (%02u)-\n",
+    "-CharUnlk-- --Block---- -Rewrite--- -CharUnlk-- --Block---- --%02uk 
(%02u)-\n",
     (Seeks+500)/1000, SeekProcCount);
   else if (!o_direct && !useunlock)
   printf(
-    "-Per Char- --Block--- -Rewrite-- -Per Char- --Block--- --%02uk (%02u)-\n",
+    "-Per Char-- --Block---- -Rewrite--- -Per Char-- --Block---- --%02uk 
(%02u)-\n",
     (Seeks+500)/1000, SeekProcCount);
        
-  printf("Machine    MB ");
-  printf("kiB/s %%CPU kiB/s %%CPU kiB/s %%CPU kiB/s %%CPU kiB/s ");
+  printf("Machine     MiB ");
+  printf(" kiB/s %%CPU  kiB/s %%CPU  kiB/s %%CPU  kiB/s %%CPU  kiB/s ");
   printf("%%CPU   /sec %%CPU\n");
 
-  printf("%-6.6s %d*%4ld ", machine, volumes, size / (1024 * 1024));
-  printf("%5d %s%6d %s %5d %s ",
-    (int) (((double) size * (double) volumes) / (delta[(int) Putc][Elapsed] * 
1024.0)),
+  printf("%-7.7s %d*%5ld", machine, volumes, size / (1024 * 1024));
+  printf("%7d %s%7d %s%7d %s",
+    (int) (((double) psz * (double) volumes) / (delta[(int) Putc][Elapsed] * 
1024.0)),
     cpupc(Putc),
     (int) (((double) size * (double) volumes) / (delta[(int) 
FastWrite][Elapsed] * 1024.0)),
     cpupc(FastWrite),
     (int) (((double) size * (double) volumes) / (delta[(int) ReWrite][Elapsed] 
* 1024.0)),
     cpupc(ReWrite));
-  printf("%5d %s%6d %s ",
-    (int) (((double) size * (double) volumes) / (delta[(int) Getc][Elapsed] * 
1024.0)),
+  printf("%7d %s%7d %s",
+    (int) (((double) gsz * (double) volumes) / (delta[(int) Getc][Elapsed] * 
1024.0)),
     cpupc(Getc),
     (int) (((double) size * (double) volumes) / (delta[(int) 
FastRead][Elapsed] * 1024.0)),
     cpupc(FastRead));
-  printf("%6.1f %s\n",
+  printf("%7.0f %s\n",
     ((double) Seeks) / delta[(int) Lseek][Elapsed],
     cpupc(Lseek));
 }
@@ -923,7 +937,7 @@
   probe = where * SeekChunk;
   if (lseek(fd, probe, 0) != probe)
     io_error("lseek in doseek");
-  if ((size = read(fd, (char *) buf, SeekChunk)) == -1)
+  if ((size = read(fd, (char *) buf, SeekChunk/2)) == -1)
     io_error("read in doseek");
 
   /* every so often, update a block */

++++++ bonnie-fix-o_direct.diff ++++++
? bonnie2
Index: Bonnie.c
===================================================================
RCS file: /share/MD0_DATA/cvsroot/C/bonnie/Bonnie.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -p -r1.5 -r1.6
--- Bonnie.c    17 Feb 2016 13:09:47 -0000      1.5
+++ Bonnie.c    23 Nov 2018 09:45:08 -0000      1.6
@@ -64,7 +64,7 @@
  *  or consequential damage, loss, costs or fees or expenses of any
  *  nature or kind.
  */
-/* $Id: Bonnie.c,v 1.5 2016/02/17 13:09:47 garloff Exp $ */
+/* $Id: Bonnie.c,v 1.6 2018/11/23 09:45:08 garloff Exp $ */
 
 #include <unistd.h>
 #include <stdio.h>
@@ -449,7 +449,7 @@ int main(
 
   /* read them all back with getc() */
   for(volcnt = 0; volcnt < volumes; volcnt++)
-    newfile(name, &fd[volcnt], &stream[volcnt], 0, volcnt, o_direct);
+    newfile(name, &fd[volcnt], &stream[volcnt], 0, volcnt, 0/*+o_direct*/);
   for (words = 0; words < 256; words++)
     chars[words] = 0;
   off_t gsz = size/8;

Reply via email to