read_in implemented. Read tests implemented

1 files changed, 82 insertions, 41 deletions

diff --git a/benchy.py b/benchy.py
index d73f206..cf109ab 100755
--- a/benchy.py
+++ b/benchy.py
@@ -5,9 +5,7 @@ import string
 import StringIO
 import tempfile
 import numpy
-import sqlite3
 from matplotlib import pyplot
-from matplotlib import pylab
 
 class Statistics:
     def __init__(self):
@@ -72,10 +70,14 @@ class Sequencial_test(Statistics):
         async is True or False
         '''
         Statistics.__init__(self)
-        Statistics.store(self, 'buffered_sync', [])
-        Statistics.store(self, 'buffered_async', [])
-        Statistics.store(self, 'unbuffered_sync', [])
-        Statistics.store(self, 'unbuffered_async', [])
+        Statistics.store(self, 'write_buffered_sync', [])
+        Statistics.store(self, 'write_buffered_async', [])
+        Statistics.store(self, 'write_unbuffered_sync', [])
+        Statistics.store(self, 'write_unbuffered_async', [])
+        Statistics.store(self, 'read_buffered_sync', [])
+        Statistics.store(self, 'read_buffered_async', [])
+        Statistics.store(self, 'read_unbuffered_sync', [])
+        Statistics.store(self, 'read_unbuffered_async', [])        
         self.MEGABYTE = 1024000
         self.size = size
         self.timer = Stopwatch()
@@ -90,10 +92,12 @@ class Sequencial_test(Statistics):
         
     def __del__(self):
         if os.path.exists(self.filename):
-            print('deleting %s' % (self.filename))
             os.remove(os.path.join(self.filename))
-            
-    def stress_test_wrapper(self, iter_max):
+    
+    def _cleanup(self):
+        self.__del__()
+    
+    def stress_test_wrapper(self, iter_max=1):
         self.stress_buffered_sync(iter_max)
         self.stress_buffered_async(iter_max)
         self.stress_unbuffered_sync(iter_max)
@@ -102,45 +106,69 @@ class Sequencial_test(Statistics):
     def stress_buffered_sync(self, iter_max=1):
         print("Synchronous buffered I/O")
         for i in range(iter_max):
-            print("\tTest: %d of %d" % (i+1, iter_max))
-            self.buffered_sync()
+            print("\rTest: %d of %d" % (i+1, iter_max))
+            self.write_buffered_sync()
+            self.read_buffered_sync()
+            self._cleanup()
     
     def stress_buffered_async(self, iter_max=1):
         print("Asynchronous buffered I/O")
         for i in range(iter_max):
-            print("\tTest: %d of %d" % (i+1, iter_max))
-            self.buffered_async()
+            print("\rTest: %d of %d" % (i+1, iter_max))
+            self.write_buffered_async()
+            self.read_buffered_async()
+            self._cleanup()
     
     def stress_unbuffered_sync(self, iter_max=1):
         print("Synchronous unbuffered I/O")
         for i in range(iter_max):
-            print("\tTest: %d of %d" % (i+1, iter_max))
-            self.unbuffered_sync()
+            print("\rTest: %d of %d\r" % (i+1, iter_max))
+            self.write_unbuffered_sync()
+            self.read_unbuffered_sync()
+            self._cleanup()
             
     def stress_unbuffered_async(self, iter_max=1):
         print("Asynchronous unbuffered I/O")
         for i in range(iter_max):
-            print("\tTest: %d of %d" % (i+1, iter_max))
-            self.unbuffered_async()            
-            
+            print("\rTest: %d of %d\r" % (i+1, iter_max))
+            self.write_unbuffered_async()
+            self.read_unbuffered_async()
+            self._cleanup()
     
+    def write_buffered_sync(self):
+        Statistics.append(self,'write_buffered_sync', self.write_out(size=self.size))
     
-    def buffered_sync(self):
-        Statistics.append(self,'buffered_sync', self.write_out(size=self.size))
+    def write_buffered_async(self):
+        Statistics.append(self, 'write_buffered_async', self.write_out(size=self.size, async=True))
     
-    def buffered_async(self):
-        Statistics.append(self, 'buffered_async', self.write_out(size=self.size, async=True))
+    def write_buffered_stepping(self):
+        pass
     
-    def buffered_stepping(self):
+    def write_unbuffered_sync(self):
+        Statistics.append(self, 'write_unbuffered_sync', self.write_out(size=self.size, mode='unbuffered'))
+    
+    def write_unbuffered_async(self):
+        Statistics.append(self, 'write_unbuffered_async', self.write_out(size=self.size, mode='unbuffered', async=True))
+    
+    def write_unbuffered_stepping(self):
         pass
+
+    def read_buffered_sync(self):
+        Statistics.append(self,'read_buffered_sync', self.read_in(size=self.size))
     
-    def unbuffered_sync(self):
-        Statistics.append(self, 'unbuffered_sync', self.write_out(size=self.size, mode='unbuffered'))
+    def read_buffered_async(self):
+        Statistics.append(self, 'read_buffered_async', self.read_in(size=self.size, async=True))
     
-    def unbuffered_async(self):
-        Statistics.append(self, 'unbuffered_async', self.write_out(size=self.size, mode='unbuffered', async=True))
+    def read_buffered_stepping(self):
+        pass
     
-    def unbuffered_stepping(self):
+    def read_unbuffered_sync(self):
+        Statistics.append(self, 'read_unbuffered_sync', self.read_in(size=self.size, mode='unbuffered'))
+    
+    def read_unbuffered_async(self):
+        Statistics.append(self, 'read_unbuffered_async', self.read_in(size=self.size, mode='unbuffered', async=True))
+    
+    def read_unbuffered_stepping(self):
         pass
     
     def write_out(self, size, bufsiz=1024000, mode='buffered', async=False):
@@ -163,14 +191,7 @@ class Sequencial_test(Statistics):
                     outfile.flush()
                     os.fsync(outfile)
                 total_bytes += len(buf)
-                rate_current = (total_bytes / self.timer.now() / 1024 / 1024)
                 source.close()
-                '''
-                if mode == 'buffered':
-                    print("Buf:%d    Sz:%d    R:%0.2f    Te:%0.4f\r" % (bufsiz, size, rate_current, self.timer.now())),
-                else:
-                    print("Sz:%d    R:%0.2f    Te:%0.4f\r" % (size, rate_current, self.timer.now())),
-                '''
             except:
                 print('Failed')
                 self.timer.stop()
@@ -179,18 +200,39 @@ class Sequencial_test(Statistics):
         self.timer.stop()
         rate = (total_bytes / self.timer.result() / 1024 / 1024)
         elapsed = self.timer.result()
-        #print('TR:%0.4fs    R:%0.2f MB/s' % (self.timer.result(), rate))
-        os.remove(self.filename)
         return rate, elapsed
     
-    def read_in(self):
-        pass
+    def read_in(self, size, bufsiz=1024000, mode='buffered', async=False):
+        size = size * self.MEGABYTE
+        infile = file(self.filename, 'rb')
+        total_bytes = 0
+        
+        self.timer.start()
+        while total_bytes <= size:
+            try:                
+                if mode == 'buffered':
+                    buf = infile.read(bufsiz)
+                else:
+                    buf = infile.read()
+                if not async:
+                    infile.flush()
+                    os.fsync(infile)
+                total_bytes += len(buf)
+            except:
+                print('Failed')
+                self.timer.stop()
+                return False
+        infile.close()
+        self.timer.stop()
+        rate = (total_bytes / self.timer.result() / 1024 / 1024)
+        elapsed = self.timer.result()
+        return rate, elapsed
 
 if __name__ == "__main__":
     size_steps = [ 1, 4, 8 ]
     buffer_steps = [ 512000, 1024000, 4096000 ]
     
-    iter_max=10
+    iter_max=25
     for size in size_steps:
         print("### %dMB ####" % (size))
         sequence_test = Sequencial_test(size)
@@ -219,7 +261,6 @@ if __name__ == "__main__":
             #pyplot.plot(rate_average)
             pyplot.plot(rate_mean)
             
-            
             pyplot.subplot(212)
             pyplot.grid(True)
             pyplot.xlabel('Iteration')