public BlockDiskWorker(IO.DataProviders.BlockDataProvider input, IO.DataProviders.BlockDataProvider Output, Compression.Strategy.Compression compression, Compression.Enums.CompressionType compressionType) { initialize(input, Output, compression, compressionType); }
public Cpu(object readLock, object writeLock, Queue <ByteBlock> writeQueue, Queue <ByteBlock> readQueue, Compression.Strategy.Compression compression, Compression.Enums.CompressionType compressionType) : base(readLock, writeLock, writeQueue, readQueue) { this.compression = compression; this.CompressionType = compressionType; }
public BlockCpuWorker(IO.DataProviders.BlockDataProvider input, IO.DataProviders.BlockDataProvider output, Compression.Strategy.Compression compression, Compression.Enums.CompressionType compressionType, int currentCore) { Initialize(input, output, compression, compressionType, currentCore); }
/// <summary> /// Get rid of nasty things /// </summary> public void Stop() { this._input = null; this._output = null; this.compression = null; foreach (var t in this._threads) { t.Abort(); } this._threads = null; }
/// <summary> /// Get rid of nasty things /// </summary> public void Stop() { _disk.CleanResources(); _cpu.CleanResources(); this.input = null; this.Output = null; this.compression = null; this.readQueue = null; this.writeQueue = null; foreach (var t in this._threads) { t.Abort(); } this._threads = null; }
/// <summary> /// Class initialization /// </summary> /// <param name="input">DataProvider for reading data from source</param> /// <param name="output">DataProvider for writing data to destionation</param> /// <param name="compression">High level of compression class</param> /// <param name="compressionType">Compress/Decompress</param> /// <param name="currentCore">Lowest idle core</param> public void Initialize(IO.DataProviders.BlockDataProvider input, IO.DataProviders.BlockDataProvider output, Compression.Strategy.Compression compression, Compression.Enums.CompressionType compressionType, int currentCore) { _threads = new Thread[2]; this._input = input; this._output = output; //Create new parameterize threads _threads[0] = new Thread(new ParameterizedThreadStart(Processing)); _threads[1] = new Thread(new ParameterizedThreadStart(Processing)); _currentBlock = 0; _last = false; this.compression = compression; _compressionType = compressionType; this.currentCore = currentCore; }
/// <summary> /// Initialize /// </summary> /// <param name="input">DataProvider for reading data</param> /// <param name="Output">DataProvider for writing data</param> /// <param name="compression">High level class for compression</param> /// <param name="compressionType">Compress/Decompress</param> void initialize(IO.DataProviders.BlockDataProvider input, IO.DataProviders.BlockDataProvider Output, Compression.Strategy.Compression compression, Compression.Enums.CompressionType compressionType) { Console.WriteLine("\n\r[Output]: Computation started!\n\r"); //get info about chunks var chunkSize = input.GetChunkSize(); var fileChunks = Computation.Utils.GetComputationInfo.GetNumberOfChunksForFile(chunkSize, input.GetObjectSize()); var numberOfChunks = Computation.Utils.GetComputationInfo.GetMaximumChunks(chunkSize); //we will be using half of the system free ram for queue, so we won't have any problem with memory leaks int queueCapacity = (int)(numberOfChunks / 2); this.input = input; this.Output = Output; this.readQueue = new Queue <Data.ByteBlock>(queueCapacity); this.writeQueue = new Queue <Data.ByteBlock>(queueCapacity); this.compression = compression; //Inner classes _disk = new Disk(this.readLock, this.writeLock, this.input, this.Output, this.readQueue, this.writeQueue, queueCapacity, ref waitHandler, this.compression.algorithms, compressionType); _cpu = new Cpu(this.readLock, this.writeQueue, this.writeQueue, this.readQueue, this.compression, compressionType); //Creating threads with innder classes realizations _threads = new Thread[3]; _threads[0] = new Thread(new ThreadStart(_disk.StartRead)); _threads[1] = new Thread(new ThreadStart(_disk.StartWrite)); _threads[2] = new Thread(new ThreadStart(_cpu.StartWork)); }
public override void CleanResources() { base.CleanResources(); this.compression = null; }
/// <summary> /// Main process /// </summary> /// <remarks> /// Using this method for milti threading file computation /// </remarks> /// <param name="param">Compression clone</param> private void Processing(object param) { //Each thread get his own compression copy of class Compression.Strategy.Compression compression = (Compression.Strategy.Compression)param; Compression.Enums.CompressionType type; bool last = false; lock (comptypeLock) { type = _compressionType; } while (!last) { lock (lastLock) { last = _last; } byte[] byteBlock = null; int current = GetCurrentBlock(); bool latest = false; lock (readLock) { switch (type) { //Read Next chunk of datam, if this is a compress, so we can read const size of block case Compression.Enums.CompressionType.Compress: byteBlock = _input.ReadNext(out latest); break; //Then we are decompressing we don't know the size of the block, so we need to read from the file by specification of //headers for compression case Compression.Enums.CompressionType.Decompress: byteBlock = _input.SpecificRead( Compression.Utils.MagicNumbersAlgorithmDictionary .AlgorithmMagicNumbers[compression.algorithms].completeMask, out latest); break; } } ByteBlock block = new ByteBlock(byteBlock, current, latest); current++; lock (currentLock) { _currentBlock++; } lock (lastLock) { _last = latest; } //Call method to compress or decompress switch (type) { case Compression.Enums.CompressionType.Compress: block.Slice = compression.Compress(block.Slice); break; case Compression.Enums.CompressionType.Decompress: block.Slice = compression.Decompress(block.Slice); break; } //Writing next chunk to the destination lock (writeLock) { _output.WriteNext(block.Slice); } block.Slice = null; //if the last block - call the handler if (latest) { waitHandle.Set(); } } }