Esempio n. 1
0
        static void Main(string[] args)
        {
            var mre        = new ManualResetEventSlim();
            var memoryTask = Task.Run(() =>
            {
                while (!mre.IsSet)
                {
                    Console.SetCursorPosition(0, 0);
                    Console.WriteLine($"Process ID: {Environment.ProcessId}");
                    Console.Write("Working, press any key to stop...");

                    Console.WriteLine();
                    GCUtils.PrintInfoAboutLastCycle();

                    Thread.Sleep(1000);
                }
            });

            var task = Task.Run(() =>
            {
                var timer = new System.Timers.Timer(500);
                timer.Start();
                int x = 0;
                while (!mre.IsSet)
                {
                    var eventDispatcher              = new TimerEventDispatcher(timer);
                    eventDispatcher.TimerElapsedNow += EventDispatcher_TimerElapsedNow;

                    if (++x % 2000 == 0)
                    {
                        Thread.Sleep(50);
                    }
                }
            });

            Console.ReadKey();
            mre.Set();

            Task.WaitAll(task, memoryTask);
            Console.WriteLine("OK, bye!");
        }
        public static void Test()
        {
            var source   = new PropertyChangedEventSource();
            var listener = new PropertyChangedEventEventListener();

            //Register listener to the source
            PropertyChangedEventManager.AddListener(source, listener, nameof(PropertyChangedEventSource.Name));

            //change property change and the ReceiveWeakEvent of PropertyChangedEventEventListener method will be called
            source.Name = "first name";

            //set listener to null so it will be ready for gc
            listener = null;

            //trigger gc and the listener will be collected.
            GCUtils.TriggerGC();

            //change property value but the ReceiveWeakEvent of PropertyChangedEventEventListener method will NOT be called
            source.Name = "second name";

            Console.Read();
        }
Esempio n. 3
0
        public static void Test()
        {
            var eventSource = new CustomEventSource();
            var listener    = new CustomEventListener();

            //add handler listener.HandleEvent to CustomEvent of CustomEventSource
            WeakEventManager <CustomEventSource, CustomEventArg> .AddHandler(eventSource, "CustomEvent", listener.HandleEvent);

            //trigger event and listener.HandleEvent will be executed
            eventSource.Raise("First message");

            //set listener to null
            listener = null;

            //trigger gc and the listener object will be collected.
            GCUtils.TriggerGC();

            //trigger event and listener.HandleEvent stil will NOT be executed
            eventSource.Raise("Second Message");

            Console.Read();
        }
        public static void Test()
        {
            var eventSource = new CustomEventSource();
            var listener    = new CustomEventListener();

            //register event listener
            eventSource.CustomEvent += listener.HandleEvent;

            //trigger event and listener.HandleEvent will be executed
            eventSource.Raise("First Message from CustomEventSource");

            //set listener to null
            listener = null;

            //trigger gc but the listener object will NOT collected.
            GCUtils.TriggerGC();

            //trigger event and listener.HandleEvent stil will be executed
            eventSource.Raise("Second Message from CustomEventSource");

            Console.Read();
        }
        public static void Test()
        {
            var eventSource = new CustomEventSource();
            var listener    = new CustomWeakEventListener();

            //add listener for eventSource via CustomizedWeakEventManager
            CustomizedWeakEventManager.AddListener(eventSource, listener);

            //trigger event and listener.ReceiveWeakEvent will be executed
            eventSource.Raise("First message");

            //set listener to null
            listener = null;

            //trigger gc and the listener object will be collected.
            GCUtils.TriggerGC();

            //trigger event and listener.HandleEvent stil will NOT be executed
            eventSource.Raise("Second Message");

            Console.Read();
        }
Esempio n. 6
0
        /// <summary>
        ///     Читаем блоки файла для архивации
        /// </summary>
        /// <param name="filepath">Входной файл</param>
        /// <param name="bufferSize">Размер блока</param>
        private void ReadForCompress(string filepath, int bufferSize)
        {
            var fileLength     = new FileInfo(filepath).Length;
            var availableBytes = fileLength;

            while (availableBytes > 0)
            {
                while (_maxChunks != 0 && InputChunkHolder.Count >= _maxChunks)
                {
                    lock (InputChunkHolder.DequeueWaitObject)
                    {
                        Monitor.Wait(InputChunkHolder.DequeueWaitObject);
                    }
                }

                while (GCUtils.FreeMemoryMb() < Constants.MinMemoryFreeMb)
                {
                    //Console.WriteLine(GCUtils.FreeMemoryMb()+"Mb left!");
                    GCUtils.ForceGc();
                }
                //сколько читать
                var readCount = availableBytes < bufferSize
                    ? (int)availableBytes
                    : bufferSize;
                using (var reader =
                           new BinaryReader(File.Open(filepath, FileMode.Open, FileAccess.Read, FileShare.Read)))
                {
                    reader.BaseStream.Seek(fileLength - availableBytes, SeekOrigin.Begin);
                    var bytes = reader.ReadBytes(readCount);
                    InputChunkHolder.Enqueu(new Chunk(ChunksReaded, bytes));
                }
                //двигаем счётчики
                availableBytes -= readCount;
                ChunksReaded++;
                //Console.WriteLine($"Readed #{ChunksReaded-1}");
            }
            FileReaded = true;
            //Console.WriteLine($"Total chunks {ChunksReaded-1}");
        }
Esempio n. 7
0
        public void Start()
        {
            _isExecuting = true;

            while (true)
            {
                GCUtils.FreeMemoryOptimizer(Constants.MinimalAvailableMemoryInPercentages);

                if (!_isExecuting || (_queue.Count() == 0 && _threadPool.Count == 0)) // Stop execution or all tasks done.
                {
                    break;
                }

                if (_threadPool.Count == _maxThreadsCount) // The whole pool is busy with threads.
                {
                    continue;
                }

                var task = _queue.Dequeue();
                if (task == null) // All tasks from the queue are pulled out.
                {
                    continue;
                }

                task.TaskDone += (sender, args) => { lock (_lock) _threadPool.Remove(args.Thread); };
                _totalTasks++;

                var thread = new Thread(() => task.Start())
                {
                    Name = "GZipTask" + _totalTasks, Priority = ThreadPriority.AboveNormal
                };
                lock (_lock) _threadPool.Add(thread);
                thread.Start();
            }

            _isExecuting = false;
            _totalTasks  = 0;
        }
Esempio n. 8
0
        static void Main(string[] args)
        {
            var mre        = new ManualResetEventSlim();
            var memoryTask = Task.Run(() =>
            {
                while (!mre.IsSet)
                {
                    Console.SetCursorPosition(0, 0);
                    Console.WriteLine($"Process ID: {Environment.ProcessId}");
                    Console.Write("Working, press any key to stop...");

                    Console.WriteLine();
                    GCUtils.PrintInfoAboutLastCycle();

                    Thread.Sleep(1000);
                }
            });

            var task = Task.Run(() =>
            {
                while (!mre.IsSet)
                {
                    //note: PhysicalFileProvider under the hood uses unmanaged resources (see https://github.com/dotnet/runtime/blob/master/src/libraries/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Win32.cs#L32)
                    try
                    {
                        var fp = new PhysicalFileProvider(Path.GetTempPath());
                        fp.Watch("*.*");
                    }
                    catch (Exception) { }
                }
            });

            Console.ReadKey();
            mre.Set();

            Task.WaitAll(task, memoryTask);
            Console.WriteLine("OK, bye!");
        }
Esempio n. 9
0
        public static StackValue Coerce(StackValue sv, Type targetType, Core core)
        {
            //@TODO(Jun): FIX ME - abort coersion for default args
            if (sv.IsDefaultArgument)
            {
                return(sv);
            }

            if (!(
                    sv.metaData.type == targetType.UID ||
                    (core.ClassTable.ClassNodes[sv.metaData.type].ConvertibleTo(targetType.UID)) ||
                    sv.IsArray))
            {
                core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kConversionNotPossible, ProtoCore.StringConstants.kConvertNonConvertibleTypes);
                return(StackValue.Null);
            }

            //if it's an array
            if (sv.IsArray && !targetType.IsIndexable)
            {
                //This is an array rank reduction
                //this may only be performed in recursion and is illegal here
                string errorMessage = String.Format(ProtoCore.StringConstants.kConvertArrayToNonArray, core.TypeSystem.GetType(targetType.UID));
                core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kConversionNotPossible, errorMessage);
                return(StackValue.Null);
            }


            if (sv.IsArray &&
                targetType.IsIndexable)
            {
                Validity.Assert(sv.IsArray);

                //We're being asked to convert an array into an array
                //walk over the structure converting each othe elements

                var hpe = core.Heap.GetHeapElement(sv);
#if GC_REFERENCE_COUNTING
                var isTemporary = hpe.Active && hpe.Refcount == 0;
#else
                var isTemporary = false;
#endif

                if (targetType.UID == (int)PrimitiveType.kTypeVar && targetType.rank == DSASM.Constants.kArbitraryRank && isTemporary)
                {
                    return(sv);
                }

                //Validity.Assert(targetType.rank != -1, "Arbitrary rank array conversion not yet implemented {2EAF557F-62DE-48F0-9BFA-F750BBCDF2CB}");

                //Decrease level of reductions by one
                Type newTargetType = new Type();
                newTargetType.UID = targetType.UID;
                if (targetType.rank != Constants.kArbitraryRank)
                {
                    newTargetType.rank = targetType.rank - 1;
                }
                else
                {
                    if (ArrayUtils.GetMaxRankForArray(sv, core) == 1)
                    {
                        //Last unpacking
                        newTargetType.rank = 0;
                    }
                    else
                    {
                        newTargetType.rank = Constants.kArbitraryRank;
                    }
                }

                return(ArrayUtils.CopyArray(sv, newTargetType, core));
            }

            if (!sv.IsArray && !sv.IsNull &&
                targetType.IsIndexable &&
                targetType.rank != DSASM.Constants.kArbitraryRank)
            {
                //We're being asked to promote the value into an array
                if (targetType.rank == 1)
                {
                    Type newTargetType = new Type();
                    newTargetType.UID  = targetType.UID;
                    newTargetType.Name = targetType.Name;
                    newTargetType.rank = 0;

                    //Upcast once
                    StackValue coercedValue = Coerce(sv, newTargetType, core);
                    GCUtils.GCRetain(coercedValue, core);
                    StackValue newSv = core.Heap.AllocateArray(new StackValue[] { coercedValue }, null);
                    return(newSv);
                }
                else
                {
                    Validity.Assert(targetType.rank > 1, "Target rank should be greater than one for this clause");

                    Type newTargetType = new Type();
                    newTargetType.UID  = targetType.UID;
                    newTargetType.Name = targetType.Name;
                    newTargetType.rank = targetType.rank - 1;

                    //Upcast once
                    StackValue coercedValue = Coerce(sv, newTargetType, core);
                    GCUtils.GCRetain(coercedValue, core);
                    StackValue newSv = core.Heap.AllocateArray(new StackValue[] { coercedValue }, null);
                    return(newSv);
                }
            }

            if (sv.IsPointer)
            {
                StackValue ret = ClassCoerece(sv, targetType, core);
                return(ret);
            }

            //If it's anything other than array, just create a new copy
            switch (targetType.UID)
            {
            case (int)PrimitiveType.kInvalidType:
                Validity.Assert(false, "Can't convert invalid type");
                break;

            case (int)PrimitiveType.kTypeBool:
                return(sv.ToBoolean(core));

            case (int)PrimitiveType.kTypeChar:
            {
                StackValue newSV = sv.ShallowClone();
                newSV.metaData = new MetaData {
                    type = (int)PrimitiveType.kTypeChar
                };
                return(newSV);
            }

            case (int)PrimitiveType.kTypeDouble:
                return(sv.ToDouble());

            case (int)PrimitiveType.kTypeFunctionPointer:
                if (sv.metaData.type != (int)PrimitiveType.kTypeFunctionPointer)
                {
                    core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeMismatch, ProtoCore.StringConstants.kFailToConverToFunction);
                    return(StackValue.Null);
                }
                return(sv);

            case (int)PrimitiveType.kTypeHostEntityID:
            {
                StackValue newSV = sv.ShallowClone();
                newSV.metaData = new MetaData {
                    type = (int)PrimitiveType.kTypeHostEntityID
                };
                return(newSV);
            }

            case (int)PrimitiveType.kTypeInt:
            {
                if (sv.metaData.type == (int)PrimitiveType.kTypeDouble)
                {
                    //TODO(lukechurch): Once the API is improved (MAGN-5174)
                    //Replace this with a log entry notification
                    //core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeConvertionCauseInfoLoss, ProtoCore.StringConstants.kConvertDoubleToInt);
                }
                return(sv.ToInteger());
            }

            case (int)PrimitiveType.kTypeNull:
            {
                if (sv.metaData.type != (int)PrimitiveType.kTypeNull)
                {
                    core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeMismatch, ProtoCore.StringConstants.kFailToConverToNull);
                    return(StackValue.Null);
                }
                return(sv);
            }

            case (int)PrimitiveType.kTypePointer:
            {
                if (sv.metaData.type != (int)PrimitiveType.kTypeNull)
                {
                    core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeMismatch, ProtoCore.StringConstants.kFailToConverToPointer);
                    return(StackValue.Null);
                }
                return(sv);
            }

            case (int)PrimitiveType.kTypeString:
            {
                StackValue newSV = sv.ShallowClone();
                newSV.metaData = new MetaData {
                    type = (int)PrimitiveType.kTypeString
                };
                if (sv.metaData.type == (int)PrimitiveType.kTypeChar)
                {
                    char ch = EncodingUtils.ConvertInt64ToCharacter(newSV.opdata);
                    newSV = StackValue.BuildString(ch.ToString(), core.Heap);
                }
                return(newSV);
            }

            case (int)PrimitiveType.kTypeVar:
            {
                return(sv);
            }

            case (int)PrimitiveType.kTypeArray:
            {
                return(ArrayUtils.CopyArray(sv, targetType, core));
            }

            default:
                if (sv.IsNull)
                {
                    return(StackValue.Null);
                }
                else
                {
                    throw new NotImplementedException("Requested coercion not implemented");
                }
            }

            throw new NotImplementedException("Requested coercion not implemented");
        }
Esempio n. 10
0
        public static StackValue Coerce(StackValue sv, Type targetType, Core core)
        {
            //@TODO(Jun): FIX ME - abort coersion for default args
            if (sv.optype == AddressType.DefaultArg)
            {
                return(sv);
            }

            if (!(
                    (int)sv.metaData.type == targetType.UID ||
                    (core.DSExecutable.classTable.ClassNodes[(int)sv.metaData.type].ConvertibleTo(targetType.UID)) ||
                    sv.optype == AddressType.ArrayPointer))
            {
                core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kConversionNotPossible, ProtoCore.RuntimeData.WarningMessage.kConvertNonConvertibleTypes);
                return(StackUtils.BuildNull());
            }



            //if it's an array
            if (sv.optype == AddressType.ArrayPointer && !targetType.IsIndexable && targetType.rank != DSASM.Constants.kUndefinedRank)// && targetType.UID != (int)PrimitiveType.kTypeVar)
            {
                //This is an array rank reduction
                //this may only be performed in recursion and is illegal here
                string errorMessage = String.Format(ProtoCore.RuntimeData.WarningMessage.kConvertArrayToNonArray, core.TypeSystem.GetType(targetType.UID));
                core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kConversionNotPossible, errorMessage);
                return(StackUtils.BuildNull());
            }


            if (sv.optype == AddressType.ArrayPointer && targetType.IsIndexable)
            {
                Validity.Assert(ArrayUtils.IsArray(sv));

                //We're being asked to convert an array into an array
                //walk over the structure converting each othe elements

                if (targetType.UID == (int)PrimitiveType.kTypeVar && targetType.rank == DSASM.Constants.kArbitraryRank && core.Heap.IsTemporaryPointer(sv))
                {
                    return(sv);
                }

                HeapElement  he        = core.Heap.Heaplist[(int)sv.opdata];
                StackValue[] newSubSVs = new StackValue[he.VisibleSize];

                //Validity.Assert(targetType.rank != -1, "Arbitrary rank array conversion not yet implemented {2EAF557F-62DE-48F0-9BFA-F750BBCDF2CB}");

                //Decrease level of reductions by one
                Type newTargetType = new Type();
                newTargetType.UID = targetType.UID;
                if (targetType.rank != ProtoCore.DSASM.Constants.kArbitraryRank)
                {
                    newTargetType.rank        = targetType.rank - 1;
                    newTargetType.IsIndexable = newTargetType.rank > 0;
                }
                else
                {
                    if (ArrayUtils.GetMaxRankForArray(sv, core) == 1)
                    {
                        //Last unpacking
                        newTargetType.rank        = 0;
                        newTargetType.IsIndexable = false;
                    }
                    else
                    {
                        newTargetType.rank        = ProtoCore.DSASM.Constants.kArbitraryRank;
                        newTargetType.IsIndexable = true;
                    }
                }


                for (int i = 0; i < he.VisibleSize; i++)
                {
                    StackValue coercedValue = Coerce(he.Stack[i], newTargetType, core);
                    GCUtils.GCRetain(coercedValue, core);
                    newSubSVs[i] = coercedValue;
                }

                StackValue newSV = HeapUtils.StoreArray(newSubSVs, core);
                return(newSV);
            }

            if (sv.optype != AddressType.ArrayPointer && sv.optype != AddressType.Null &&
                targetType.IsIndexable &&
                targetType.rank != DSASM.Constants.kArbitraryRank)
            {
                //We're being asked to promote the value into an array
                if (targetType.rank == 1)
                {
                    Type newTargetType = new Type();
                    newTargetType.UID         = targetType.UID;
                    newTargetType.IsIndexable = false;
                    newTargetType.Name        = targetType.Name;
                    newTargetType.rank        = 0;


                    //Upcast once
                    StackValue coercedValue = Coerce(sv, newTargetType, core);
                    GCUtils.GCRetain(coercedValue, core);
                    StackValue newSv = HeapUtils.StoreArray(new StackValue[] { coercedValue }, core);
                    return(newSv);
                }
                else
                {
                    Validity.Assert(targetType.rank > 1, "Target rank should be greater than one for this clause");

                    Type newTargetType = new Type();
                    newTargetType.UID         = targetType.UID;
                    newTargetType.IsIndexable = true;
                    newTargetType.Name        = targetType.Name;
                    newTargetType.rank        = targetType.rank - 1;


                    //Upcast once
                    StackValue coercedValue = Coerce(sv, newTargetType, core);
                    GCUtils.GCRetain(coercedValue, core);
                    StackValue newSv = HeapUtils.StoreArray(new StackValue[] { coercedValue }, core);
                    return(newSv);
                }
            }


            if (sv.optype == AddressType.Pointer)
            {
                StackValue ret = ClassCoerece(sv, targetType, core);
                return(ret);
            }

            //If it's anything other than array, just create a new copy
            switch (targetType.UID)
            {
            case (int)PrimitiveType.kInvalidType:
                Validity.Assert(false, "Can't convert invalid type");
                break;

            case (int)PrimitiveType.kTypeBool:
                return(sv.AsBoolean(core));

            case (int)PrimitiveType.kTypeChar:
            {
                StackValue newSV = sv.ShallowClone();
                newSV.metaData = new MetaData {
                    type = (int)PrimitiveType.kTypeChar
                };
                return(newSV);
            }

            case (int)PrimitiveType.kTypeDouble:
                return(sv.AsDouble());

            case (int)PrimitiveType.kTypeFunctionPointer:
                if (sv.metaData.type != (int)PrimitiveType.kTypeFunctionPointer)
                {
                    core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeMismatch, ProtoCore.RuntimeData.WarningMessage.kFailToConverToFunction);
                    return(StackUtils.BuildNull());
                }
                return(sv.ShallowClone());

            case (int)PrimitiveType.kTypeHostEntityID:
            {
                StackValue newSV = sv.ShallowClone();
                newSV.metaData = new MetaData {
                    type = (int)PrimitiveType.kTypeHostEntityID
                };
                return(newSV);
            }

            case (int)PrimitiveType.kTypeInt:
            {
                if (sv.metaData.type == (int)PrimitiveType.kTypeDouble)
                {
                    core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeConvertionCauseInfoLoss, ProtoCore.RuntimeData.WarningMessage.kConvertDoubleToInt);
                }
                return(sv.AsInt());
            }

            case (int)PrimitiveType.kTypeNull:
            {
                if (sv.metaData.type != (int)PrimitiveType.kTypeNull)
                {
                    core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeMismatch, ProtoCore.RuntimeData.WarningMessage.kFailToConverToNull);
                    return(StackUtils.BuildNull());
                }
                return(sv.ShallowClone());
            }

            case (int)PrimitiveType.kTypePointer:
            {
                if (sv.metaData.type != (int)PrimitiveType.kTypeNull)
                {
                    core.RuntimeStatus.LogWarning(RuntimeData.WarningID.kTypeMismatch, ProtoCore.RuntimeData.WarningMessage.kFailToConverToPointer);
                    return(StackUtils.BuildNull());
                }
                StackValue ret = sv.ShallowClone();
                return(ret);
            }

            case (int)PrimitiveType.kTypeString:
            {
                StackValue newSV = sv.ShallowClone();
                newSV.metaData = new MetaData {
                    type = (int)PrimitiveType.kTypeString
                };
                if (sv.metaData.type == (int)PrimitiveType.kTypeChar)
                {
                    char ch = ProtoCore.Utils.EncodingUtils.ConvertInt64ToCharacter(newSV.opdata);
                    newSV = StackUtils.BuildString(ch.ToString(), core.Heap);
                }
                return(newSV);
            }

            case (int)PrimitiveType.kTypeVar:
            {
                return(sv);
            }


            case (int)PrimitiveType.kTypeArray:
            {
                HeapElement  he        = core.Heap.Heaplist[(int)sv.opdata];
                StackValue[] newSubSVs = new StackValue[he.VisibleSize];

                for (int i = 0; i < he.VisibleSize; i++)
                {
                    StackValue coercedValue = Coerce(he.Stack[i], targetType, core);
                    GCUtils.GCRetain(coercedValue, core);
                    newSubSVs[i] = coercedValue;
                }

                StackValue newSV = HeapUtils.StoreArray(newSubSVs, core);
                return(newSV);
            }


            default:
                if (sv.optype == AddressType.Null)
                {
                    return(StackUtils.BuildNull());
                }
                else
                {
                    throw new NotImplementedException("Requested coercion not implemented");
                }
            }



            throw new NotImplementedException("Requested coercion not implemented");
        }
Esempio n. 11
0
        /// <summary>
        /// Resizes/scales the image data to the specified size and quality
        /// Refer: http://www.mindscapehq.com/blog/index.php/2012/02/28/windows-phone-7-working-with-camera-tasks/
        /// </summary>
        /// <param name="stream">Image stream</param>
        /// <param name="width">Target width of the image</param>
        /// <param name="height">Target height of the image</param>
        /// <param name="quality">Target quality of the image</param>
        /// <returns>Formatted image</returns>
        private byte[] FormatImage(Stream stream, int width, int height, int quality)
        {
            WriteableBitmap target = null;
            BitmapImage     image  = null;

            try
            {
                JpegInfo info  = ExifReader.ReadJpeg(stream, string.Empty);
                byte[]   data  = null;
                int      angle = 0;
                switch (info.Orientation)
                {
                case ExifOrientation.TopLeft:
                case ExifOrientation.Undefined:
                    angle = 0;
                    break;

                case ExifOrientation.TopRight:
                    angle = 90;
                    break;

                case ExifOrientation.BottomRight:
                    angle = 180;
                    break;

                case ExifOrientation.BottomLeft:
                    angle = 270;
                    break;
                }

                if (angle > 0d)
                {
                    target = RotateStream(stream, angle);
                }
                if (target == null)
                {
                    stream.Seek(0, SeekOrigin.Begin);
                    image = new BitmapImage();
                    image.SetSource(stream);
                    target = new WriteableBitmap(image);
                }

                MemoryStream outStream = new MemoryStream();
                target.SaveJpeg(outStream,
                                width,
                                height,
                                (int)((PhoneApplicationPage)Mowbly.ActivePhoneApplicationPage).Orientation,
                                quality);
                outStream.Seek(0, SeekOrigin.Begin);
                data = ((MemoryStream)outStream).ToArray();

                outStream.Close();
                outStream.Dispose();
                outStream = null;

                Logger.Debug("Camera: Formatted image [JPG " + width + "x" + height + ";quality" + quality + "]");
                return(data);
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                if (image != null)
                {
                    image.UriSource = null;
                    image           = null;
                }
                target = null;

                //outStream ,image,target are eligible for cleanup
                GCUtils.DoGC();
            }
        }
Esempio n. 12
0
        /// <summary>
        ///     Читаем блоки архива
        /// </summary>
        /// <param name="filepath">Входной файл</param>
        private void ReadForDecompress(string filepath)
        {
            using (var reader = new BinaryReader(File.Open(filepath, FileMode.Open, FileAccess.Read)))
            {
                var gzipHeader = Constants.GZipHeader;

                var fileLength     = new FileInfo(filepath).Length;
                var availableBytes = fileLength;
                while (availableBytes > 0)
                {
                    while (GCUtils.FreeMemoryMb() < Constants.MinMemoryFreeMb)
                    {
                        //Console.WriteLine(GCUtils.FreeMemoryMb() + "Mb left!");
                        GCUtils.ForceGc();
                    }
                    var gzipBlock = new List <byte>();
                    //Console.WriteLine($"Reading #{ChunksReaded}");
                    // GZip Заголовок
                    if (ChunksReaded == 0) // Получаем первый заголовок в файле. В остальных блоках - такой же
                    {
                        gzipHeader      = reader.ReadBytes(gzipHeader.Length);
                        availableBytes -= gzipHeader.Length;
                    }
                    gzipBlock.AddRange(gzipHeader); //добавляем хидер в блок

                    // Данные блока архива
                    var gzipHeaderMatchsCount = 0;
                    while (availableBytes > 0)
                    {
                        while (_maxChunks != 0 && InputChunkHolder.Count >= _maxChunks)
                        {
                            lock (InputChunkHolder.DequeueWaitObject)
                            {
                                //Console.WriteLine("Waiting for Dq");
                                Monitor.Wait(InputChunkHolder.DequeueWaitObject);
                            }
                        }

                        var curByte = reader.ReadByte();
                        gzipBlock.Add(curByte);
                        availableBytes--;

                        // Проверяем заголовок следующего блока
                        if (curByte == gzipHeader[gzipHeaderMatchsCount])
                        {
                            gzipHeaderMatchsCount++;
                            if (gzipHeaderMatchsCount != gzipHeader.Length)
                            {
                                continue;
                            }

                            gzipBlock.RemoveRange(gzipBlock.Count - gzipHeader.Length,
                                                  gzipHeader.Length); // Убираем заголовок следующего блока из текущего
                            break;
                        }

                        gzipHeaderMatchsCount = 0;
                    }
                    //отправляем блок на обработку
                    InputChunkHolder.Enqueu(new Chunk(ChunksReaded, gzipBlock.ToArray()));
                    //номер блока ++
                    ChunksReaded++;
                    //Console.WriteLine($"Readed #{ChunksReaded - 1}");
                }
            }
            FileReaded = true;
            //Console.WriteLine($"Total chunks {ChunksReaded - 1}");
        }
Esempio n. 13
0
        /// <summary>
        ///     Начинает процесс обработки файла
        /// </summary>
        public void Run()
        {
            var sw = new Stopwatch();

            sw.Start();
            //Создаем поток чтения
            var r = new Reader(0);

            _readerThread = new Thread(() => r.Read(_parameters.Operation, _parameters.InputFile, Constants.ChunkSize))
            {
                Name     = "ReaderThread",
                Priority = ThreadPriority.AboveNormal
            };
            //Создаем поток записи
            var w = new Writer();

            _writerThread = new Thread(() => w.Write(_parameters.OutputFile))
            {
                Name     = "WriterThread",
                Priority = ThreadPriority.AboveNormal
            };

            _memoryCheckThread = new Thread(() => GCUtils.RuntimeCheck(Constants.MinMemoryFreeMb));
            _memoryCheckThread.Start();
            //Запускаем чтение и запись
            _readerThread.Start();
            _writerThread.Start();
            //Console.WriteLine("Reader and Writer Started");
            var totalTasks = 0;

            //Пока все не считано и не записано
            while (!Writer.FileWrited || !Reader.FileReaded)
            {
                //проверяем на прерывание
                if (_isTerminated)
                {
                    lock (_lock)
                    {
                        for (var i = _pool.Count - 1; i >= 0; i--)
                        {
                            if (!_pool[i].IsAlive)
                            {
                                _pool[i].Abort();
                            }
                            _pool.RemoveAt(i);
                        }
                    }
                    break;
                }
                //Если весь пул занят
                lock (_lock)
                {
                    if (_pool.Count == _processorCount)
                    {
                        //Проверяем, все ли потоки работают
                        if (_pool.All(th => th.IsAlive))
                        {
                            continue;
                        }
                        //Если не все, то убираем отработавшие
                        for (var i = _pool.Count - 1; i >= 0; i--)
                        {
                            if (!_pool[i].IsAlive)
                            {
                                _pool.RemoveAt(i);
                            }
                        }
                    }
                }
                //Когда есть свободные места, создаем новый поток
                IWorker worker;
                if (_parameters.Operation == OperationCode.Compress)
                {
                    worker = new CompressWorker();
                }
                else
                {
                    worker = new DecompressWorker();
                }
                totalTasks++;
                var thr = new Thread(() => worker.DoWork())
                {
                    Name     = "Worker" + totalTasks,
                    Priority = ThreadPriority.AboveNormal
                };
                lock (_lock)
                {
                    _pool.Add(thr);
                }
                thr.Start();
            }
            sw.Stop();
            MessageSystem.AddMessage(!_isTerminated
                ? $"Операция выполнена за {sw.Elapsed.TotalSeconds:F2} секунд"
                : $"Операция прервана после {sw.Elapsed.TotalSeconds:F2} секунд");
        }