From 6313ff19b322a2801c633324bb0d77dc4f59b9a1 Mon Sep 17 00:00:00 2001
From: bendikro <bendikro@gmail.com>
Date: Mon, 26 Nov 2012 00:23:00 +0100
Subject: [PATCH] Improved the speed of set_prioritize_first_last in torrent.py

set_prioritize_first_last is rewritten for better performance, and is now only called when necessary. It should now properly set the priority for the beginning and end of each file in the torrent.
---
 deluge/core/torrent.py                |  64 +++++++++----
 deluge/tests/dir_with_6_files.torrent | Bin 0 -> 9630 bytes
 deluge/tests/test_torrent.py          | 127 ++++++++++++++++++++++++++
 3 files changed, 171 insertions(+), 20 deletions(-)
 create mode 100644 deluge/tests/dir_with_6_files.torrent
 create mode 100644 deluge/tests/test_torrent.py

diff --git a/deluge/core/torrent.py b/deluge/core/torrent.py
index ba6ec285a..c5fd81955 100644
--- a/deluge/core/torrent.py
+++ b/deluge/core/torrent.py
@@ -232,8 +232,13 @@ class Torrent(object):
             "max_upload_speed": self.set_max_upload_speed,
             "prioritize_first_last_pieces": self.set_prioritize_first_last,
             "sequential_download": self.set_sequential_download
-
         }
+
+        # set_prioritize_first_last is called by set_file_priorities,
+        # so remove if file_priorities is set in options.
+        if "file_priorities" in options:
+            del OPTIONS_FUNCS["prioritize_first_last_pieces"]
+
         for (key, value) in options.items():
             if OPTIONS_FUNCS.has_key(key):
                 OPTIONS_FUNCS[key](value)
@@ -296,26 +301,44 @@ class Torrent(object):
 
     def set_prioritize_first_last(self, prioritize):
         self.options["prioritize_first_last_pieces"] = prioritize
-        if self.handle.has_metadata():
-            if self.options["compact_allocation"]:
-                log.debug("Setting first/last priority with compact "
-                          "allocation does not work!")
-                return
+        if not prioritize:
+            # If we are turning off this option, call set_file_priorities to
+            # reset all the piece priorities
+            self.set_file_priorities(self.options["file_priorities"])
+            return
+        if not self.handle.has_metadata():
+            return
+        if self.options["compact_allocation"]:
+            log.debug("Setting first/last priority with compact "
+                      "allocation does not work!")
+            return
+        # A list of priorities for each piece in the torrent
+        priorities = self.handle.piece_priorities()
+        prioritized_pieces = []
+        ti = self.handle.get_torrent_info()
+        for i in range(ti.num_files()):
+            f = ti.file_at(i)
+            two_percent_bytes = int(0.02 * f.size)
+            # Get the pieces for the byte offsets
+            first_start = ti.map_file(i, 0, 0).piece
+            first_end = ti.map_file(i, two_percent_bytes, 0).piece
+            last_start = ti.map_file(i, f.size - two_percent_bytes, 0).piece
+            last_end = ti.map_file(i, max(f.size - 1, 0), 0).piece
 
-            paths = {}
-            ti = self.handle.get_torrent_info()
-            for n in range(ti.num_pieces()):
-                slices = ti.map_block(n, 0, ti.piece_size(n))
-                for slice in slices:
-                    if self.handle.file_priority(slice.file_index):
-                        paths.setdefault(slice.file_index, []).append(n)
+            first_end += 1
+            last_end += 1
+            prioritized_pieces.append((first_start, first_end))
+            prioritized_pieces.append((last_start, last_end))
 
-            priorities = self.handle.piece_priorities()
-            for pieces in paths.itervalues():
-                two_percent = int(0.02*len(pieces)) or 1
-                for piece in pieces[:two_percent]+pieces[-two_percent:]:
-                    priorities[piece] = 7 if prioritize else 1
-            self.handle.prioritize_pieces(priorities)
+            # Creating two lists with priorites for the first/last pieces
+            # of this file, and insert the priorities into the list
+            first_list = [7] * (first_end - first_start)
+            last_list = [7] * (last_end - last_start)
+            priorities[first_start:first_end] = first_list
+            priorities[last_start:last_end] = last_list
+        # Setting the priorites for all the pieces of this torrent
+        self.handle.prioritize_pieces(priorities)
+        return prioritized_pieces, priorities
 
     def set_sequential_download(self, set_sequencial):
         self.options["sequential_download"] = set_sequencial
@@ -372,7 +395,8 @@ class Torrent(object):
             log.warning("File priorities were not set for this torrent")
 
         # Set the first/last priorities if needed
-        self.set_prioritize_first_last(self.options["prioritize_first_last_pieces"])
+        if self.options["prioritize_first_last_pieces"]:
+            self.set_prioritize_first_last(self.options["prioritize_first_last_pieces"])
 
     def set_trackers(self, trackers):
         """Sets trackers"""
diff --git a/deluge/tests/dir_with_6_files.torrent b/deluge/tests/dir_with_6_files.torrent
new file mode 100644
index 0000000000000000000000000000000000000000..2c6b5fb020b31a7964a0a598eccec744c22cdfdc
GIT binary patch
literal 9630
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

literal 0
HcmV?d00001

diff --git a/deluge/tests/test_torrent.py b/deluge/tests/test_torrent.py
new file mode 100644
index 000000000..f55b4d4e2
--- /dev/null
+++ b/deluge/tests/test_torrent.py
@@ -0,0 +1,127 @@
+from twisted.trial import unittest
+import os
+
+import deluge.core.torrent
+import test_torrent
+import common
+from deluge.core.rpcserver import RPCServer
+from deluge.core.core import Core
+
+deluge.core.torrent.component = test_torrent
+
+from deluge._libtorrent import lt
+
+import deluge.component as component
+from deluge.core.torrent import Torrent
+
+config_setup = False
+core = None
+rpcserver = None
+
+# This is called by torrent.py when calling component.get("...")
+def get(key):
+    if key is "Core":
+        return core
+    elif key is "RPCServer":
+        return rpcserver
+    else:
+        return None
+
+class TorrentTestCase(unittest.TestCase):
+
+    def setup_config(self):
+        global config_setup
+        config_setup = True
+        config_dir = common.set_tmp_config_dir()
+        core_config = deluge.config.Config("core.conf", defaults=deluge.core.preferencesmanager.DEFAULT_PREFS, config_dir=config_dir)
+        core_config.save()
+
+    def setUp(self):
+        self.setup_config()
+        global rpcserver
+        global core
+        rpcserver = RPCServer(listen=False)
+        core = Core()
+        self.session = lt.session()
+        self.torrent = None
+        return component.start()
+
+    def tearDown(self):
+        if self.torrent:
+            self.torrent.prev_status_cleanup_loop.stop()
+
+        def on_shutdown(result):
+            component._ComponentRegistry.components = {}
+        return component.shutdown().addCallback(on_shutdown)
+
+    def print_priority_list(self, priorities):
+        tmp = ''
+        for i, p in enumerate(priorities):
+            if i % 100 == 0:
+                print tmp
+                tmp = ''
+            tmp += "%s" % p
+        print tmp
+
+    def get_torrent_atp(self, filename):
+        filename = os.path.join(os.path.dirname(__file__), filename)
+        e = lt.bdecode(open(filename, 'rb').read())
+        info = lt.torrent_info(e)
+        atp = {"ti": info}
+        atp["save_path"] = os.getcwd()
+        atp["storage_mode"] = lt.storage_mode_t.storage_mode_sparse
+        atp["add_paused"] = False
+        atp["auto_managed"] = True
+        atp["duplicate_is_error"] = True
+        return atp
+
+    def test_set_prioritize_first_last(self):
+        piece_indexes = [(0,1), (0,1), (0,1), (0,1), (0,2), (50,52),
+                         (51,53), (110,112), (111,114), (200,203),
+                         (202,203), (212,213), (212,218), (457,463)]
+        self.run_test_set_prioritize_first_last("dir_with_6_files.torrent", piece_indexes)
+
+    def run_test_set_prioritize_first_last(self, torrent_file, prioritized_piece_indexes):
+        atp = self.get_torrent_atp(torrent_file)
+        handle = self.session.add_torrent(atp)
+
+        self.torrent = Torrent(handle, {})
+        priorities_original = handle.piece_priorities()
+        prioritized_pieces, new_priorites = self.torrent.set_prioritize_first_last(True)
+        priorities = handle.piece_priorities()
+        non_prioritized_pieces = list(range(len(priorities)))
+
+        # The prioritized indexes are the same as we expect
+        self.assertEquals(prioritized_pieces, prioritized_piece_indexes)
+
+        # Test the priority of the prioritized pieces
+        for first, last in prioritized_pieces:
+            for i in range(first, last):
+                if i in non_prioritized_pieces:
+                    non_prioritized_pieces.remove(i)
+                self.assertEquals(priorities[i], 7)
+
+        # Test the priority of all the non-prioritized pieces
+        for i in non_prioritized_pieces:
+            self.assertEquals(priorities[i], 1)
+
+        # The length of the list of new priorites is the same as the original
+        self.assertEquals(len(priorities_original), len(new_priorites))
+
+        #self.print_priority_list(priorities)
+
+    def test_set_prioritize_first_last_false(self):
+        atp = self.get_torrent_atp("dir_with_6_files.torrent")
+        handle = self.session.add_torrent(atp)
+        self.torrent = Torrent(handle, {})
+        # First set some pieces prioritized
+        self.torrent.set_prioritize_first_last(True)
+        # Reset pirorities
+        self.torrent.set_prioritize_first_last(False)
+        priorities = handle.piece_priorities()
+
+        # Test the priority of the prioritized pieces
+        for i in priorities:
+            self.assertEquals(priorities[i], 1)
+
+        #self.print_priority_list(priorities)