speedcheck: track SSK creation time separately

diff --git a/src/allmydata/control.py b/src/allmydata/control.py
index 5e57f229d6d7f9c5db55b0747e696abec9f0cb30..2fc3afc3887db54e2014819b94d4196e1300c254 100644 (file)
--- a/src/allmydata/control.py
+++ b/src/allmydata/control.py
@@ -55,7 +55,7 @@ class ControlServer(Referenceable, service.Service, testutil.PollMixin):
 
     def remote_speed_test(self, count, size, mutable):
         assert size > 8
-        log.msg("speed_test: count=%d, size=%d, mutable=%d" % (count, size,
+        log.msg("speed_test: count=%d, size=%d, mutable=%s" % (count, size,
                                                                mutable))
         st = SpeedTest(self.parent, count, size, mutable)
         return st.run()
@@ -101,7 +101,7 @@ class SpeedTest:
         self.parent = parent
         self.count = count
         self.size = size
-        self.mutable = mutable
+        self.mutable_mode = mutable
         self.uris = {}
         self.basedir = os.path.join(self.parent.basedir, "_speed_test_data")
 
@@ -130,18 +130,33 @@ class SpeedTest:
             f.close()
 
     def do_upload(self):
-        start = time.time()
         d = defer.succeed(None)
+        def _create_slot(res):
+            d1 = self.parent.create_mutable_file("")
+            def _created(n):
+                self._n = n
+            d1.addCallback(_created)
+            return d1
+        if self.mutable_mode == "upload":
+            d.addCallback(_create_slot)
+        def _start(res):
+            self._start = time.time()
+        d.addCallback(_start)
+
         def _record_uri(uri, i):
             self.uris[i] = uri
         def _upload_one_file(ignored, i):
             if i >= self.count:
                 return
             fn = os.path.join(self.basedir, str(i))
-            if self.mutable:
+            if self.mutable_mode == "create":
                 data = open(fn,"rb").read()
                 d1 = self.parent.create_mutable_file(data)
                 d1.addCallback(lambda n: n.get_uri())
+            elif self.mutable_mode == "upload":
+                data = open(fn,"rb").read()
+                d1 = self._n.replace(data)
+                d1.addCallback(lambda res: self._n.get_uri())
             else:
                 up = upload.FileName(fn)
                 d1 = self.parent.upload(up)
@@ -151,7 +166,7 @@ class SpeedTest:
         d.addCallback(_upload_one_file, 0)
         def _upload_done(ignored):
             stop = time.time()
-            self.upload_time = stop - start
+            self.upload_time = stop - self._start
         d.addCallback(_upload_done)
         return d
 

diff --git a/src/allmydata/interfaces.py b/src/allmydata/interfaces.py
index 54a16d7258845d4031c9dfc8ee0a8444d085cfc0..bbc354ee4fff53ede45114b5a752a6882d6d39fb 100644 (file)
--- a/src/allmydata/interfaces.py
+++ b/src/allmydata/interfaces.py
@@ -1245,11 +1245,13 @@ class RIControlClient(RemoteInterface):
         measuring memory consupmtion in bytes."""
         return DictOf(str, int)
 
-    def speed_test(count=int, size=int, mutable=bool):
+    def speed_test(count=int, size=int, mutable=Any()):
         """Write 'count' tempfiles to disk, all of the given size. Measure
         how long (in seconds) it takes to upload them all to the servers.
         Then measure how long it takes to download all of them. If 'mutable'
-        is True, use mutable files instead of immutable ones.
+        is 'create', time creation of mutable files. If 'mutable' is
+        'upload', then time access to the same mutable file instead of
+        creating one.
 
         Returns a tuple of (upload_time, download_time).
         """

diff --git a/src/allmydata/test/check_speed.py b/src/allmydata/test/check_speed.py
index 7d4449a8f3cedaad48148c11ffb0d1f3b0b48a24..a006f4b8ba60897e6c8408a51be75a4f66376653 100644 (file)
--- a/src/allmydata/test/check_speed.py
+++ b/src/allmydata/test/check_speed.py
@@ -63,6 +63,11 @@ class SpeedTest:
         self.upload_times[key], self.download_times[key] = times
 
     def one_test(self, res, name, count, size, mutable):
+        # values for 'mutable':
+        #   False (upload a different CHK file for each 'count')
+        #   "create" (upload different contents into a new SSK file)
+        #   "upload" (upload different contents into the same SSK file. The
+        #             time consumed does not include the creation of the file)
         d = self.client_rref.callRemote("speed_test", count, size, mutable)
         d.addCallback(self.record_times, name)
         return d
@@ -89,6 +94,8 @@ class SpeedTest:
         d = defer.succeed(None)
         d.addCallback(self.one_test, "startup", 1, 1000, False) #ignore this one
         d.addCallback(self.measure_rtt)
+
+        # immutable files
         d.addCallback(self.one_test, "1x 200B", 1, 200, False)
         d.addCallback(self.one_test, "10x 200B", 10, 200, False)
         def _maybe_do_100x_200B(res):
@@ -105,9 +112,19 @@ class SpeedTest:
                 return
             return self.one_test(None, "100MB", 1, 100*MB, False)
         d.addCallback(_maybe_do_100MB)
-        d.addCallback(self.one_test, "1x 200B SSK", 1, 200, True)
-        d.addCallback(self.one_test, "10x 200B SSK", 10, 200, True)
-        d.addCallback(self.one_test, "1MB SSK", 1, 1*MB, True)
+
+        # mutable file creation
+        d.addCallback(self.one_test, "10x 200B SSK creation", 10, 200, "create")
+
+        # mutable file upload/download
+        d.addCallback(self.one_test, "10x 200B SSK", 10, 200, "upload")
+        def _maybe_do_100x_200B_SSK(res):
+            if self.upload_times["10x 200B SSK"] < 5:
+                print "10x 200B SSK test went too fast, doing 100x 200B SSK"
+                return self.one_test(None, "100x 200B SSK", 100, 200, "upload")
+            return
+        d.addCallback(_maybe_do_100x_200B_SSK)
+        d.addCallback(self.one_test, "1MB SSK", 1, 1*MB, "upload")
         d.addCallback(self.calculate_speeds)
         return d
 
@@ -147,6 +164,9 @@ class SpeedTest:
             A3 = 100*MB / (self.download_times["100MB"] - B)
             print "download speed (100MB):", self.number(A3, "Bps")
 
+        # SSK creation
+        B = self.upload_times["10x 200B SSK creation"] / 10
+        print "create per-file time SSK: %.3fs" % B
 
         # upload SSK
         if "100x 200B SSK" in self.upload_times: