[Mldonkey-commits] mldonkey distrib/ChangeLog src/networks/donkey/...

[mldonkey-commits]

CVSROOT:        /sources/mldonkey
Module name:    mldonkey
Changes by:     spiralvoice <spiralvoice>       07/04/19 13:44:16

Modified files:
        distrib        : ChangeLog 
        src/networks/donkey: donkeyFiles.ml donkeyOptions.ml 

Log message:
        patch #5857

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/mldonkey/distrib/ChangeLog?cvsroot=mldonkey&r1=1.1236&r2=1.1237
http://cvs.savannah.gnu.org/viewcvs/mldonkey/src/networks/donkey/donkeyFiles.ml?cvsroot=mldonkey&r1=1.28&r2=1.29
http://cvs.savannah.gnu.org/viewcvs/mldonkey/src/networks/donkey/donkeyOptions.ml?cvsroot=mldonkey&r1=1.63&r2=1.64

Patches:
Index: distrib/ChangeLog
===================================================================
RCS file: /sources/mldonkey/mldonkey/distrib/ChangeLog,v
retrieving revision 1.1236
retrieving revision 1.1237
diff -u -b -r1.1236 -r1.1237
--- distrib/ChangeLog   19 Apr 2007 13:37:10 -0000      1.1236
+++ distrib/ChangeLog   19 Apr 2007 13:44:16 -0000      1.1237
@@ -15,6 +15,7 @@
 =========
 
 2007/04/19
+5857: EDK: Remove upload compression (patch #5665) due to ineffective caching
 5875: Swarmer: Some cosmetic changes (pango)
 5856: EDK: Set TCP backlog to max_upload_slots for donkey_port socket
 5869: EDK/Swarmer: Try harder to read corrupt files.ini

Index: src/networks/donkey/donkeyFiles.ml
===================================================================
RCS file: /sources/mldonkey/mldonkey/src/networks/donkey/donkeyFiles.ml,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -b -r1.28 -r1.29
--- src/networks/donkey/donkeyFiles.ml  19 Feb 2007 21:19:44 -0000      1.28
+++ src/networks/donkey/donkeyFiles.ml  19 Apr 2007 13:44:16 -0000      1.29
@@ -61,51 +61,6 @@
 where nseconds = Fifo.length upload_clients
   
   *)
-exception Cache_table_hit of string * string
-type cache_entry = {
-  md4 : Md4.t;
-  begin_offset : int64;
-  end_offset : int64;
-  cached_part : string;
-  comp_part : string
-  }
-let cache_table_index = ref 0
-let cache_table_size = !!upload_compression_table_size
-let ( cache_table : cache_entry Weak.t ) = Weak.create cache_table_size
-let cached_load file begin_offset end_offset compress=
-  try
-    for i = 0 to cache_table_size-1 do
-      match Weak.get cache_table i with
-        Some 
({md4=md4;begin_offset=bo;end_offset=eo;cached_part=cached_file;comp_part=cached_comp})
 when (md4 = file.file_md4) && (bo=begin_offset) && (eo=end_offset) ->
-          if !verbose_upload then
-            lprintf_nl "Cache Hit for %s (%Ld,%Ld)" (file_best_name file) 
begin_offset end_offset;
-          if (compress && (String.length cached_comp > 0)) || not compress 
then raise (Cache_table_hit(cached_file,cached_comp))
-        | _ -> ()
-    done;
-    let entry_length = Int64.to_int(end_offset -- begin_offset) in
-    let cached_file = String.create entry_length in
-    Unix32.read (file_fd file) begin_offset cached_file 0 entry_length;
-    let cached_comp = if compress then
-      Zlib.compress_string ~level:!!upload_compression_level cached_file
-    else
-      ""
-    in
-    cache_table_index := (!cache_table_index + 1) mod cache_table_size;
-    let (entry : cache_entry)={
-      md4=file.file_md4;
-      begin_offset=begin_offset;
-      end_offset=end_offset;
-      cached_part=cached_file;
-      comp_part=cached_comp} in
-      Weak.set cache_table !cache_table_index (Some entry);
-    if !verbose_upload then
-      lprintf_nl "Cache Miss for %s (%Ld,%Ld) orig.len %d comp.len %d" 
(file_best_name file) begin_offset end_offset (String.length cached_file) 
(String.length cached_comp);
-    Some (cached_file,cached_comp)
-  with
-    | Cache_table_hit (cached_file,cached_comp) -> Some 
(cached_file,cached_comp)
-    | End_of_file -> if !verbose then lprintf_nl
-              "End_of_file in cached_load file %s size %Ld begin %Ld end %Ld" 
(file_best_name file) (file_size file) begin_offset end_offset; None
-
   
 module NewUpload = struct
     
@@ -119,22 +74,25 @@
            M.CloseSlotReq Q.t)
 *)
     
-    let rec send_small_block_plain c sock file begin_offset cfile pos len_int 
sixtyfour = 
+    let rec send_small_block c sock file begin_pos len_int = 
+(*      lprintf "send_small_block %d\n" len_int; *)
+(*      let len_int = Int32.to_int len in *)
       try
        if !verbose_upload then
-          lprintf_nl "Sending plain %s to %s, begin_offset %Ld pos %d len %d"
+         lprintf_nl "Sending %s to %s, begin %Ld len %d"
            (file_best_name file) (full_client_identifier c)
-          (begin_offset) (pos) (len_int);
+            (begin_pos) (len_int);
         
+        if file_is_largefile file && c.client_emule_proto.emule_largefiles <> 
1 then raise Donkey_large_file;
         let msg =  
           (
             let module M = DonkeyProtoClient in
             let module B = M.Bloc in
             M.BlocReq {  
               B.md4 = file.file_md4;
-              B.usesixtyfour = sixtyfour;
-              B.start_pos = begin_offset ++ (Int64.of_int pos);
-              B.end_pos = begin_offset ++ (Int64.of_int(pos + len_int));
+              B.usesixtyfour = (begin_pos ++ (Int64.of_int len_int)) > 
old_max_emule_file_size;
+              B.start_pos = begin_pos;
+              B.end_pos = begin_pos ++ (Int64.of_int len_int);
               B.bloc_str = "";
               B.bloc_begin = 0;
               B.bloc_len = 0; 
@@ -145,7 +103,7 @@
         let upload_buffer = String.create (slen + len_int) in
         String.blit s 0 upload_buffer 0 slen;
         DonkeyProtoCom.new_string msg upload_buffer;
-        String.blit cfile pos upload_buffer slen len_int;
+        Unix32.read (file_fd file) begin_pos upload_buffer slen len_int;
         let uploaded = Int64.of_int len_int in
         count_upload c uploaded;
        CommonUploads.consume_bandwidth len_int;
@@ -158,91 +116,32 @@
         write_string sock upload_buffer;
         check_end_upload c sock
       with
-      | e -> if !verbose then lprintf_nl
-              "Exception %s in send_small_block_plain" (Printexc2.to_string e)
-    
-    let rec send_small_block_compressed c sock file begin_offset ccomp pos 
len_int pay_len sixtyfour = 
-      try
-        if !verbose_upload then
-          lprintf_nl "Sending compressed %s to %s, begin_offset %Ld pos %d len 
%d"
+      | End_of_file -> lprintf_nl "Can not send file %s to %s, file removed?"
+                        (file_best_name file) (full_client_identifier c)
+      | Donkey_large_file -> lprintf_nl "File %s is too large for %s."
                         (file_best_name file) (full_client_identifier c)
-          (begin_offset) (pos) (len_int);
-        
-        let msg =  
-          (
-            let module M = DonkeyProtoClient in
-            let module B = M.EmuleCompressedPart in
-            M.EmuleCompressedPart {  
-              B.md4 = file.file_md4;
-              B.usesixtyfour = sixtyfour;
-              B.statpos = begin_offset;
-              B.newsize = Int64.of_int pay_len;
-              B.bloc = "";
-            }
-          ) in
-        let s = client_msg_to_string c.client_emule_proto msg in
-        let slen = String.length s in
-        let upload_buffer = String.create (slen + len_int) in
-        String.blit s 0 upload_buffer 0 slen;
-        DonkeyProtoCom.new_string msg upload_buffer;
-        String.blit ccomp pos upload_buffer slen len_int;
-        CommonUploads.consume_bandwidth len_int;
-        
-        write_string sock upload_buffer;
-        check_end_upload c sock
-      with
       | e -> if !verbose then lprintf_nl
-              "Exception %s in send_small_block_compressed" 
(Printexc2.to_string e)
+              "Exception %s in send_small_block" (Printexc2.to_string e)
     
     let rec send_client_block c sock per_client =
-      try
+(*      lprintf "send_client_block\n"; *)
       if per_client > 0 && CommonUploads.can_write_len sock max_msg_size then
         match c.client_upload with
-        | Some ({ up_chunks = (begin_offset,end_offset) :: chunks } as up)  ->
-            if file_is_largefile up.up_file && 
c.client_emule_proto.emule_largefiles <> 1 then begin
-              DonkeyOneFile.remove_client_slot c;
-              lprintf_nl "File %s is too large for %s." (file_best_name 
up.up_file) (full_client_identifier c);
-            end else
-            if up.up_file.file_shared = None then
+        | Some ({ up_chunks = current_chunk :: chunks } as up)  ->
+            if up.up_file.file_shared = None then begin
 (* Is there a message to warn that a file is not shared anymore ? *)
-              DonkeyOneFile.remove_client_slot c
-              else
-            let compress =
-              !!upload_compression &&
-              (c.client_emule_proto.emule_compression <> 0) &&
-              not (List.mem (String.lowercase (Filename2.last_extension2 
(file_best_name up.up_file)))
-                  !!upload_compression_ext_exclude)
-            in
-            let cfile,ccomp = match cached_load up.up_file begin_offset 
end_offset compress with
-              Some (cached_file,cached_comp) -> cached_file,cached_comp
-              | _ -> "",""
-            in
-            let compressed = compress && ((String.length ccomp) + 
!!upload_compression_threshold < (String.length cfile)) in
-            let pay_len = if compressed then (String.length ccomp) else 
(String.length cfile) in
-            let pos = Int64.to_int (up.up_pos -- begin_offset) in
-            let max_len = pay_len - pos in
-            let allowed_msg_block_size_int = min msg_block_size_int per_client 
in
-            let sixtyfour = end_offset >= old_max_emule_file_size in
-            if max_len <= allowed_msg_block_size_int then
+                c.client_upload <- None;
+              end else
+            let max_len = up.up_end_chunk -- up.up_pos in
+            let max_len = Int64.to_int max_len in
+            let msg_block_size_int = min msg_block_size_int per_client in
+            if max_len <= msg_block_size_int then
 (* last block from chunk *)
               begin
-                if compressed then
-                  begin
-                    send_small_block_compressed c sock up.up_file begin_offset 
ccomp pos max_len pay_len sixtyfour;
-                    let uploaded = end_offset -- begin_offset in
-                    count_upload c uploaded;
-                    (match up.up_file.file_shared with None -> ()
-                      | Some impl ->
-                        shared_must_update_downloaded (as_shared impl);
-                        impl.impl_shared_uploaded <- 
-                        impl.impl_shared_uploaded ++ uploaded)
-                  end
-                else 
-                  send_small_block_plain c sock up.up_file begin_offset cfile 
pos max_len sixtyfour
-                ;
+                send_small_block c sock up.up_file up.up_pos max_len;
                 if !verbose_upload then
-                    lprintf_nl "End of chunk %Ld %Ld %s" begin_offset 
end_offset (file_best_name up.up_file);
-               up.up_flying_chunks <- up.up_flying_chunks @ 
[(begin_offset,end_offset)];
+                    lprintf_nl "End of chunk (%d) %Ld %s" max_len 
up.up_end_chunk (file_best_name up.up_file);
+               up.up_flying_chunks <- up.up_flying_chunks @ [current_chunk];
                 up.up_chunks <- chunks;
                 let per_client = per_client - max_len in
                 match chunks with
@@ -259,25 +158,14 @@
               end
             else
 (* small block from chunk *)
-              if allowed_msg_block_size_int >= msg_block_size_int then
-                begin
-                  if compressed then
               begin
-                      send_small_block_compressed c sock up.up_file 
begin_offset ccomp pos msg_block_size_int pay_len sixtyfour;
-                    end
-                  else
-                    begin
-                      send_small_block_plain c sock up.up_file begin_offset 
cfile pos msg_block_size_int sixtyfour;
-                    end
-                  ;
+                send_small_block c sock up.up_file up.up_pos 
+                  msg_block_size_int;
                 up.up_pos <- up.up_pos ++ (Int64.of_int msg_block_size_int);
                 let per_client = per_client-msg_block_size_int in
                 send_client_block c sock per_client
               end
         | _ -> ()
-      with
-      | e -> if !verbose then lprintf_nl
-              "Exception %s in send_client_block" (Printexc2.to_string e)
     
     let upload_to_client c size = 
 (*      lprintf "upload_to_client %d\n" size; *)

Index: src/networks/donkey/donkeyOptions.ml
===================================================================
RCS file: /sources/mldonkey/mldonkey/src/networks/donkey/donkeyOptions.ml,v
retrieving revision 1.63
retrieving revision 1.64
diff -u -b -r1.63 -r1.64
--- src/networks/donkey/donkeyOptions.ml        8 Apr 2007 14:31:43 -0000       
1.63
+++ src/networks/donkey/donkeyOptions.ml        19 Apr 2007 13:44:16 -0000      
1.64
@@ -195,55 +195,6 @@
   "Uploaded zones (1 zone = 180 kBytes) needed to enable the dynamic upload 
lifetime"
     int_option 10
 
-let upload_compression = define_expert_option donkey_section 
["upload_compression"]
-  "Enables compressed upload as part of the protocol"
-    bool_option true
-
-let upload_compression_threshold = define_expert_option donkey_section 
["upload_compression_threshold"]
-  "Sizedifference in bytes between one zone (180 kBytes) and its compressed
-  counterpart, which has to occure, to send compressed parts instead of plain."
-    int_option 2000
-
-let upload_compression_ext_exclude = define_expert_option donkey_section 
["upload_compression_ext_exclude"]
-  "Disable upload compression based on file extensions (without dot)"
-    string_list_option ["zip"; "7z"; "gz"; "bz2"; "rar"; "ace"; "ogm"; "avi"; 
"mpg"]
-
-let _ =
-  option_hook upload_compression_threshold (fun _ ->
-    if !!upload_compression_threshold < 0 then
-        upload_compression_threshold =:= 0
-  );
-  option_hook upload_compression_ext_exclude (fun _ ->
-    let l = List.map String.lowercase !!upload_compression_ext_exclude in
-    if !!upload_compression_ext_exclude <> l then 
upload_compression_ext_exclude =:= l
-  )
-
-let upload_compression_level = define_expert_option donkey_section 
["upload_compression_level"]
-  "Level of the used zlibcompression. allowed are values between 0 and 9. 
higher
-  level means better compression, but higher cpu usage too. (emules default
-  compression level for compressed parts is 9)"
-    int_option 9
-
-let _ =
-  option_hook upload_compression_level (fun _ ->
-    if !!upload_compression_level < 0
-      || !!upload_compression_level > 9 then
-        upload_compression_level =:= 9
-  )
-
-let upload_compression_table_size = define_expert_option donkey_section 
["upload_compression_table_size"]
-  ~restart: true
-  "Size of the cache table in entries (ca. 2 * 180 kbytes). zones have to be
-  compressed at once, but only parts of it are sent at a time (10 kbytes).
-  Minimum value is the number of total upload slots."
-    int_option 20
-
-let _ =
-  option_hook upload_compression_table_size (fun _ ->
-    if !!upload_compression_table_size < !!max_upload_slots then
-        upload_compression_table_size =:= !!max_upload_slots
-  )
-
 let connected_server_timeout = define_expert_option donkey_section 
["connected_server_timeout"]
   "How long can a silent server stay connected"
     float_option 1800.