/trunk/Pithos.Network/BlockHashAlgorithms.cs - Diff - Pithos MS Client - Greek Research and Technology Network's projects

Revision 9d2c0fc0 trunk/Pithos.Network/BlockHashAlgorithms.cs

     namespace Pithos.Network
+    {
         using System;
         using System.Collections.Generic;
         using System.Linq;
         using System.Text;
         /// <summary>
         /// TODO: Update summary.
-...
+        {
             private static readonly log4net.ILog Log = log4net.LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
     /*
             public static Func<FileStream, int, string, ConcurrentDictionary<int, byte[]>, int, Task<ConcurrentDictionary<int, byte[]>>> CalculateBlockHash;
             public static Task<ConcurrentDictionary<int, byte[]>> CalculateBlockHashesRecursiveAsync(FileStream stream, int blockSize, string algorithm, ConcurrentDictionary<int, byte[]> hashes = null, int index = 0)
-...
                 int read;
                 while ((read = await stream.ReadAsync(buffer, 0, blockSize)) > 0)
+                {
                     //TODO: identify the value of index
                     using (var hasher = HashAlgorithm.Create(algorithm))
+                    {
                         //This code was added for compatibility with the way Pithos calculates the last hash
-...
                         hashes[index] = hash;
+                    }
                     index += read;
                 };
+                }
                 return hashes;
+            }
-...
                 var size = stream.Length;
                 Log.DebugFormat("Hashing [{0}] size [{1}]",path,size);
     /*
                 var options = new ExecutionDataflowBlockOptions {BoundedCapacity = parallelism,MaxDegreeOfParallelism=parallelism};
                 var hashBlock=new ActionBlock<Tuple<int,byte[]>>(input=>
+                                  {
-...
                                           hashes[idx] = hash;
+                                      }
                                   },options);
     */
                 var buffer = new byte[blockSize];
                 int read;
                 int index = 0;
                 while ((read = await stream.ReadAsync(buffer, 0, blockSize)) > 0)
+                {
                     var block = new byte[read];
                     Buffer.BlockCopy(buffer, 0, block, 0, read);
                     await hashBlock.SendAsync(Tuple.Create(index, block));
                     index += read;
+                }
                 hashBlock.Complete();
                 await hashBlock.Completion;
                 return hashes;
+            }
             public static async Task<ConcurrentDictionary<int, byte[]>> CalculateBlockHashesInPlace(FileStream stream, int blockSize, string algorithm, int parallelism)
+            {
                 if (stream == null)
                     throw new ArgumentNullException("stream");
                 if (String.IsNullOrWhiteSpace(algorithm))
                     throw new ArgumentNullException("algorithm");
                 if (blockSize <= 0)
                     throw new ArgumentOutOfRangeException("blockSize", "blockSize must be a value greater than zero ");
                 Contract.EndContractBlock();
                 var hashes = new ConcurrentDictionary<int, byte[]>();
                 var path = stream.Name;
                 var size = stream.Length;
                 Log.DebugFormat("Hashing [{0}] size [{1}]",path,size);
                 var buffer = new byte[blockSize];
                 var index = 0;
                 using (var hasher = HashAlgorithm.Create(algorithm))
+                {
                     int read;
                     while ((read = await stream.ReadAsync(buffer, 0, blockSize)) > 0)
+                    {
                         //                var block = new byte[read];
                         //This code was added for compatibility with the way Pithos calculates the last hash
                         //We calculate the hash only up to the last non-null byte
                         var lastByteIndex = Array.FindLastIndex(buffer, read - 1, aByte => aByte != 0);
-...
                         hashes[index] = hash;
                         index += read;
+                    }
+                }
                 return hashes;
+            }
     */
             public static async Task<ConcurrentDictionary<long, byte[]>> CalculateBlockHashesInPlacePFor(FileStream stream, int blockSize, string algorithm, int parallelism)
+            {
                 if (stream == null)
                     throw new ArgumentNullException("stream");
                 if (String.IsNullOrWhiteSpace(algorithm))
                     throw new ArgumentNullException("algorithm");
                 if (blockSize <= 0)
                     throw new ArgumentOutOfRangeException("blockSize", "blockSize must be a value greater than zero ");
                 Contract.EndContractBlock();
                 var hashes = new ConcurrentDictionary<long, byte[]>();
                 var path = stream.Name;
                 var size = stream.Length;
                 Log.DebugFormat("Hashing [{0}] size [{1}]", path, size);
                     /*
                                     Buffer.BlockCopy(buffer,0,block,0,read);
                                     await hashBlock.SendAsync(Tuple.Create(index, block));
                     */
                 var buffer = new byte[parallelism][];
                 var hashers = new HashAlgorithm[parallelism];
                 for (var i = 0; i < parallelism; i++)
+                {
                     buffer[i] = new byte[blockSize];
                     hashers[i] = HashAlgorithm.Create(algorithm);
+                }
                 try
+                {
                     var indices = new long[parallelism];
                     var bufferCount = new int[parallelism];
     /*
                 hashBlock.Complete();
                 await hashBlock.Completion;
     */
                     int read;
                     int bufIdx = 0;
                     long index = 0;
                     while ((read = await stream.ReadAsync(buffer[bufIdx], 0, blockSize)) > 0)
+                    {
                         index += read;
                         indices[bufIdx] = index;
                         bufferCount[bufIdx] = read;
                         //If we have filled the last buffer or if we have read from the last block,
                         //we can calculate the clocks in parallel
                         if (bufIdx == parallelism - 1 || read < blockSize)
+                        {
                             //var options = new ParallelOptions {MaxDegreeOfParallelism = parallelism};
                             Parallel.For(0, bufIdx + 1, idx =>
+                            {
                                 //This code was added for compatibility with the way Pithos calculates the last hash
                                 //We calculate the hash only up to the last non-null byte
                                 var lastByteIndex = Array.FindLastIndex(buffer[idx],
                                                                         bufferCount[idx] - 1,
                                                                         aByte => aByte != 0);
                                 var hasher = hashers[idx];
                                 var hash = hasher.ComputeHash(buffer[idx], 0, lastByteIndex + 1);
                                 var filePosition = indices[idx];
                                 /*
                                                             Trace.TraceInformation("Hashed [{0}] [{1}/{2}] [{3:p}]", path,
                                                                                     filePosition, size,
                                                                                     (double)filePosition / size);
                                 */
                                 hashes[filePosition] = hash;
                             });
+                        }
                         bufIdx = (bufIdx + 1) % parallelism;
+                    }
+                }
                 finally
+                {
                     for (var i = 0; i < parallelism; i++)
+                    {
                         if (hashers[i] != null)
                             hashers[i].Dispose();
+                    }
+                }
                 return hashes;
+            }
             static BlockHashAlgorithms()
+            {
     /*
                 CalculateBlockHash = CalculateBlockHashesRecursiveAsync;
     */
+            }
+        }
+    }

Also available in: Unified diff

Synnefo » Pithos MS Client

Revision 9d2c0fc0 trunk/Pithos.Network/BlockHashAlgorithms.cs