FileStatistics.cs

using System;
using System.Text;
using Waher.Runtime.Collections;
 
namespace Waher.Persistence.Files.Statistics
{
    public class FileStatistics
    {
        private readonly uint blockSize;
        private uint nrObjects = 0;
        private uint nrBlocks = 0;
        private uint nrBlobBlocks = 0;
        private uint minObjSize = uint.MaxValue;
        private uint maxObjSize = uint.MinValue;
        private uint minDepth = uint.MaxValue;
        private uint maxDepth = uint.MinValue;
        private uint minObjPerBlock = uint.MaxValue;
        private uint maxObjPerBlock = uint.MinValue;
        private uint minBytesUsedPerBlock = uint.MaxValue;
        private uint maxBytesUsedPerBlock = uint.MinValue;
        private ulong sumObjSize = 0;
        private ulong nrBytesUsed = 0;
        private ulong nrBytesUnused = 0;
        private ulong nrBytesTotal = 0;
        private ulong nrBlobBytesUsed = 0;
        private ulong nrBlobBytesUnused = 0;
        private ulong nrBlobBytesTotal = 0;
        private readonly ulong nrBlockLoads = 0;
        private readonly ulong nrCacheLoads = 0;
        private readonly ulong nrBlockSaves = 0;
        private readonly ulong nrBlobBlockLoads = 0;
        private readonly ulong nrBlobBlockSaves = 0;
        private readonly ulong nrFullFileScans;
        private readonly ulong nrSearches;
        private bool isCorrupt = false;
        private bool isBalanced = true;
        private ChunkedList<string> comments = null;
        private readonly object synchObject = new object();
        private int[] unreferencedBlocks = null;
        private int[] unreferencedBlobBlocks = null;
 
        public FileStatistics(uint BlockSize, ulong NrBlockLoads, ulong NrCacheLoads, ulong NrBlockSaves, 
            ulong NrBlobBlockLoads, ulong NrBlobBlockSaves, ulong NrFullFileScans, ulong NrSearches)
        {
            this.blockSize = BlockSize;
            this.nrBlockLoads = NrBlockLoads;
            this.nrCacheLoads = NrCacheLoads;
            this.nrBlockSaves = NrBlockSaves;
            this.nrBlobBlockLoads = NrBlobBlockLoads;
            this.nrBlobBlockSaves = NrBlobBlockSaves;
            this.nrFullFileScans = NrFullFileScans;
            this.nrSearches = NrSearches;
        }
 
        public uint BlockSize => this.blockSize;
 
        public ulong NrSearches => this.nrSearches;
 
        public ulong NrFullFileScans => this.nrFullFileScans;
 
        public uint NrBlocks
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBlocks;
                }
            }
        }
 
        public ulong NrBytesUsed
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBytesUsed;
                }
            }
        }
 
        public ulong NrBytesUnused
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBytesUnused;
                }
            }
        }
 
        public ulong NrBytesTotal
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBytesTotal;
                }
            }
        }
 
        public uint NrBlobBlocks
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBlobBlocks;
                }
            }
        }
 
        public ulong NrBlobBytesUsed
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBlobBytesUsed;
                }
            }
        }
 
        public ulong NrBlobBytesUnused
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBlobBytesUnused;
                }
            }
        }
 
        public ulong NrBlobBytesTotal
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBlobBytesTotal;
                }
            }
        }
 
        public double Usage
        {
            get
            {
                lock (this.synchObject)
                {
                    return (100.0 * (this.nrBytesUsed + this.nrBlobBytesUsed)) / (this.nrBytesTotal + this.nrBlobBytesTotal);
                }
            }
        }
 
        public uint NrObjects
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrObjects;
                }
            }
        }
 
        public uint MinObjectSize
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.minObjSize;
                }
            }
 
            internal set
            {
                lock (this.synchObject)
                {
                    this.minObjSize = value;
                }
            }
        }
 
        public uint MaxObjectSize
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.maxObjSize;
                }
            }
        }
 
        public uint MinObjectsPerBlock
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.minObjPerBlock;
                }
            }
        }
 
        public uint MaxObjectsPerBlock
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.maxObjPerBlock;
                }
            }
        }
 
        public uint MinBytesUsedPerBlock
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.minBytesUsedPerBlock;
                }
            }
        }
 
        public uint MaxBytesUsedPerBlock
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.maxBytesUsedPerBlock;
                }
            }
        }
 
        public double AverageObjectSize
        {
            get
            {
                lock (this.synchObject)
                {
                    return ((double)this.sumObjSize) / this.nrObjects;
                }
            }
        }
 
        public double AverageObjectsPerBlock
        {
            get
            {
                lock (this.synchObject)
                {
                    return ((double)this.nrObjects) / this.nrBlocks;
                }
            }
        }
 
        public double AverageBytesUsedPerBlock
        {
            get
            {
                lock (this.synchObject)
                {
                    return ((double)this.nrBytesUsed) / this.nrBlocks;
                }
            }
        }
 
        public uint MinDepth
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.minDepth;
                }
            }
        }
 
        public uint MaxDepth
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.maxDepth;
                }
            }
        }
 
        public ulong NrBlockLoads
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBlockLoads;
                }
            }
        }
 
        public ulong NrCacheLoads
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrCacheLoads;
                }
            }
        }
 
        public ulong NrBlockSaves
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBlockSaves;
                }
            }
        }
 
        public ulong NrBlobBlockLoads
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBlobBlockLoads;
                }
            }
        }
 
        public ulong NrBlobBlockSaves
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.nrBlobBlockSaves;
                }
            }
        }
 
        public bool IsCorrupt
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.isCorrupt;
                }
            }
        }
 
        public bool IsBalanced
        {
            get
            {
                lock (this.synchObject)
                {
                    return this.isBalanced && this.minDepth == this.maxDepth;
                }
            }
 
            internal set
            {
                lock (this.synchObject)
                {
                    this.isBalanced = value;
                }
            }
        }
 
        public string[] Comments
        {
            get
            {
                lock (this.synchObject)
                {
                    if (this.comments is null)
                        return Array.Empty<string>();
                    else
                        return this.comments.ToArray();
                }
            }
        }
 
        public bool HasComments
        {
            get
            {
                lock (this.synchObject)
                {
                    return !(this.comments is null);
                }
            }
        }
 
        public int[] UnreferencedBlocks
        {
            get => this.unreferencedBlocks;
            internal set => this.unreferencedBlocks = value;
        }
 
        public int[] UnreferencedBlobBlocks
        {
            get => this.unreferencedBlobBlocks;
            internal set => this.unreferencedBlobBlocks = value;
        }
 
        internal void ReportBlockStatistics(uint NrBytesUsed, uint NrBytesUnused, uint NrObjects)
        {
            lock (this.synchObject)
            {
                this.nrBlocks++;
                this.nrBytesUsed += NrBytesUsed;
                this.nrBytesUnused += NrBytesUnused;
                this.nrBytesTotal += NrBytesUsed + NrBytesUnused;
 
                if (NrObjects < this.minObjPerBlock)
                    this.minObjPerBlock = NrObjects;
 
                if (NrObjects > this.maxObjPerBlock)
                    this.maxObjPerBlock = NrObjects;
 
                if (NrBytesUsed < this.minBytesUsedPerBlock)
                    this.minBytesUsedPerBlock = NrBytesUsed;
 
                if (NrBytesUsed > this.maxBytesUsedPerBlock)
                    this.maxBytesUsedPerBlock = NrBytesUsed;
            }
        }
 
        internal void ReportBlobBlockStatistics(uint NrBytesUsed, uint NrBytesUnused)
        {
            lock (this.synchObject)
            {
                this.nrBlobBlocks++;
                this.nrBlobBytesUsed += NrBytesUsed;
                this.nrBlobBytesUnused += NrBytesUnused;
                this.nrBlobBytesTotal += NrBytesUsed + NrBytesUnused;
 
                if (NrBytesUsed < this.minBytesUsedPerBlock)
                    this.minBytesUsedPerBlock = NrBytesUsed;
 
                if (NrBytesUsed > this.maxBytesUsedPerBlock)
                    this.maxBytesUsedPerBlock = NrBytesUsed;
            }
        }
 
        internal void ReportObjectStatistics(uint ObjectSize)
        {
            lock (this.synchObject)
            {
                if (ObjectSize < this.minObjSize)
                    this.minObjSize = ObjectSize;
 
                if (ObjectSize > this.maxObjSize)
                    this.maxObjSize = ObjectSize;
 
                this.sumObjSize += ObjectSize;
                this.nrObjects++;
            }
        }
 
        internal void ReportDepthStatistics(uint Depth)
        {
            lock (this.synchObject)
            {
                if (Depth < this.minDepth)
                    this.minDepth = Depth;
 
                if (Depth > this.maxDepth)
                    this.maxDepth = Depth;
            }
        }
 
        internal void LogError(string Message)
        {
            lock (this.synchObject)
            {
                this.isCorrupt = true;
 
                if (this.comments is null)
                    this.comments = new ChunkedList<string>();
 
                this.comments.Add(Message);
            }
        }
 
        internal void LogComment(string Message)
        {
            lock (this.synchObject)
            {
                if (this.comments is null)
                    this.comments = new ChunkedList<string>();
 
                this.comments.Add(Message);
            }
        }
 
        public void ToString(StringBuilder Output, bool WriteStat)
        {
            lock (this.synchObject)
            {
                if (WriteStat)
                {
                    Output.AppendLine("Block Size: " + this.blockSize.ToString());
                    Output.AppendLine("#Blocks: " + this.nrBlocks.ToString());
                    Output.AppendLine("#BLOB Blocks: " + this.nrBlobBlocks.ToString());
                    Output.AppendLine("#Bytes used: " + this.nrBytesUsed.ToString());
                    Output.AppendLine("#Bytes unused: " + this.nrBytesUnused.ToString());
                    Output.AppendLine("#Bytes total: " + this.nrBytesTotal.ToString());
                    Output.AppendLine("#BLOB Bytes used: " + this.nrBlobBytesUsed.ToString());
                    Output.AppendLine("#BLOB Bytes unused: " + this.nrBlobBytesUnused.ToString());
                    Output.AppendLine("#BLOB Bytes total: " + this.nrBlobBytesTotal.ToString());
                    Output.AppendLine("#Block loads: " + this.nrBlockLoads.ToString());
                    Output.AppendLine("#Cache loads: " + this.nrCacheLoads.ToString());
                    Output.AppendLine("#Block saves: " + this.nrBlockSaves.ToString());
                    Output.AppendLine("#BLOB Block loads: " + this.nrBlobBlockLoads.ToString());
                    Output.AppendLine("#BLOB Block saves: " + this.nrBlobBlockSaves.ToString());
                    Output.AppendLine("#Objects: " + this.nrObjects.ToString());
                    Output.AppendLine("Smallest object: " + this.minObjSize.ToString());
                    Output.AppendLine("Largest object: " + this.maxObjSize.ToString());
                    Output.AppendLine("Average object: " + this.AverageObjectSize.ToString("F1"));
                    Output.AppendLine("Usage: " + this.Usage.ToString("F2") + " %");
                    Output.AppendLine("Min(Depth): " + this.minDepth.ToString());
                    Output.AppendLine("Max(Depth): " + this.maxDepth.ToString());
                    Output.AppendLine("Min(Objects/Block): " + this.minObjPerBlock.ToString());
                    Output.AppendLine("Max(Objects/Block): " + this.maxObjPerBlock.ToString());
                    Output.AppendLine("Avg(Objects/Block): " + this.AverageObjectsPerBlock.ToString("F1"));
                    Output.AppendLine("Min(Bytes Used/Block): " + this.minBytesUsedPerBlock.ToString());
                    Output.AppendLine("Max(Bytes Used/Block): " + this.maxBytesUsedPerBlock.ToString());
                    Output.AppendLine("Avg(Bytes Used/Block): " + this.AverageBytesUsedPerBlock.ToString("F1"));
                    Output.AppendLine("Is Corrupt: " + this.isCorrupt.ToString());
                    Output.AppendLine("Is Balanced: " + this.isBalanced.ToString());
                    Output.AppendLine("Has Comments: " + this.HasComments.ToString());
                }
 
                if (this.HasComments)
                {
                    Output.AppendLine();
                    foreach (string Comment in this.Comments)
                        Output.AppendLine(Comment);
                }
            }
        }
 
    }
}