예제 #1
0
        public static DiskNode LoadNode(LockedNodeFileStream backingStream, long offset, bool memoryManaged = false)
        {
            if (offset == 0)
            {
                return(null);
            }

            if (!CacheNodes)
            {
                if (RootNode is null)
                {
                    RootNode = new DiskNode(backingStream, DiskNode.HEADER_BYTES);
                    foreach (long l in RootNode.ChildOffsets)
                    {
                        SmallCache.Add(l);
                    }
                }

                if (offset == DiskNode.HEADER_BYTES)
                {
                    return(RootNode);
                }

                if (!RootNodes.TryGetValue(offset, out DiskNode thisNode))
                {
                    thisNode = new DiskNode(backingStream, offset);

                    if (SmallCache.Contains(offset) || SmallCache.Contains(thisNode.ParentOffset))
                    {
                        RootNodes.TryAdd(offset, thisNode);
                    }
                }

                return(thisNode);
            }

            if (MemoryManaged.TryGetValue(offset, out DiskNode dn))
            {
                return(dn);
            }
            else if (memoryManaged && CurrentCacheCount < MaxCacheCount)
            {
                dn = new DiskNode(_backingStream, offset);
                CurrentCacheCount++;
                MemoryManaged.Add(offset, dn);
                return(dn);
            }

            if (!Cache.TryGetValue(offset, out DiskNode toReturn))
            {
                toReturn = new DiskNode(backingStream, offset);

                if (CurrentCacheCount < MaxCacheCount && Cache.TryAdd(offset, toReturn))
                {
                    CurrentCacheCount++;
                }
            }

            return(toReturn ?? new DiskNode(_backingStream, offset));
        }
예제 #2
0
        internal static void DisposeAll()
        {
            try
            {
                MemoryManaged.Clear();
            }
            catch (Exception)
            {
            }

            try
            {
                Cache.Clear();
            }
            catch (Exception)
            {
            }

            try
            {
                _backingStream.Dispose();
            }
            catch (Exception)
            {
            }

            _backingStream = null;
        }
예제 #3
0
        public DiskNode(LockedNodeFileStream fileStream, long offset)
        {
            if (fileStream is null)
            {
                throw new ArgumentNullException(nameof(fileStream));
            }

            this.Offset            = offset;
            this.BackingDataOffset = offset;

            this.BackingData = fileStream.ReadBlock(offset);

            this.ChildOffsets = new long[this.ChildCount];

            for (int i = 0; i < this.ChildOffsets.Length; i++)
            {
                int oset = NODE_SIZE + (i * NEXT_SIZE) + (offset == 16 ? 4 : 2);

                this.ChildOffsets[i] = this.BackingData.GetInt40(oset);
            }

            _backingStream = _backingStream ?? fileStream ?? throw new ArgumentNullException(nameof(fileStream));
        }
예제 #4
0
        public async Task Preload(string FilePath)
        {
            await Task.Run(() =>
            {
                try
                {
                    Dictionary <long, NodeBlock> nodeblocks = new Dictionary <long, NodeBlock>();

                    for (int header = 0; header < next.Length; header++)
                    {
                        for (int value = 0; value < next[header].Length; value++)
                        {
                            foreach (INodeBlock inb in next[header][value])
                            {
                                if (inb is NodeBlock nb)
                                {
                                    nodeblocks.Add(nb.Offset, nb);
                                }
                            }
                        }
                    }
                    using (LockedNodeFileStream ns = new LockedNodeFileStream(new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.RandomAccess)))
                    {
                        using (FileStream fs = new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.RandomAccess))
                        {
                            using (FileStream fsn = new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.RandomAccess))
                            {
                                byte[] offsetBytes = new byte[DiskNode.HEADER_BYTES];

                                fs.Read(offsetBytes, 0, offsetBytes.Length);

                                long JsonOffset = offsetBytes.GetLong(0);
                                long SortOffset = offsetBytes.GetLong(8);

                                fs.Seek(SortOffset, SeekOrigin.Begin);

                                ulong freeMem = SystemInterop.Memory.Status.ullAvailPhys;

                                while (freeMem > this.Settings.MinFreeMemory + this.Settings.RangeFreeMemory)
                                {
                                    for (int i = 0; i < this.Settings.PreloadChunkSize / 2; i++)
                                    {
                                        if (fs.Position >= JsonOffset)
                                        {
                                            return;
                                        }

                                        byte[] thisNodeBytes = new byte[5];

                                        fs.Read(thisNodeBytes, 0, thisNodeBytes.Length);

                                        long offset = thisNodeBytes.GetInt40();

                                        if (!NoCache.Contains(offset))
                                        {
                                            if (!nodeblocks.TryGetValue(offset, out NodeBlock nb))
                                            {
                                                continue;
                                            }

                                            DiskNode dn = new DiskNode(ns, offset);

                                            if (dn.NextOffset != 0)
                                            {
                                                long bLength = dn.NextOffset - dn.Offset;

                                                ByteCache cachedBytes = new ByteCache()
                                                {
                                                    Data = new byte[bLength]
                                                };

                                                fsn.Seek(dn.Offset, SeekOrigin.Begin);

                                                fsn.Read(cachedBytes.Data, 0, (int)bLength);

                                                CachedBytes[nb.Index] = cachedBytes;

                                                freeMem -= (ulong)cachedBytes.Data.Length;
                                            }
                                        }

                                        if (freeMem < this.Settings.MinFreeMemory + this.Settings.RangeFreeMemory)
                                        {
                                            return;
                                        }
                                    }

                                    freeMem = SystemInterop.Memory.Status.ullAvailPhys;
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    if (Debugger.IsAttached)
                    {
                        Debugger.Break();
                    }
                }
            });
        }