ISCSIConsole-Fork/DiskAccessLibrary/Mod/LargeRaMDisk.cs

using System;

namespace DiskAccessLibrary.Mod
{
    public class LargeRamDisk : Disk
    {
        private const int SectorSize = 512;
        private const int BlockSize = Consts.Gigabyte;

        private byte[][] _blocks;

        public LargeRamDisk(int sizeInGigabyte)
        {
            var arr = new byte[sizeInGigabyte][];
            for (var i = 0; i < sizeInGigabyte; i++)
            {
                arr[i] = new byte[Consts.Gigabyte];
            }

            _blocks = arr;
            Size = (long)sizeInGigabyte * Consts.Gigabyte;
        }

        public void Free()
        {
            for (var i = 0; i < _blocks.Length; i++)
            {
                _blocks[i] = null;
            }
            _blocks = null;
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }

        private void ReadBlock(byte[] buffer, int offset, int count, int blockIndex, int blockOffset)
        {
            Buffer.BlockCopy(_blocks[blockIndex], blockOffset, buffer, offset, count);
        }

        private void WriteBlock(byte[] buffer, int offset, int count, int blockIndex, int blockOffset)
        {
            Buffer.BlockCopy(buffer, offset, _blocks[blockIndex], blockOffset, count);
        }

        public override byte[] ReadSectors(long sectorIndex, int sectorCount)
        {
            var rawOffset = sectorIndex * SectorSize;
            var rawSize = sectorCount * SectorSize;

            var buffer = new byte[rawSize];

            for (var i = 0; i < rawSize;)
            {
                var blockIndex = (int)(rawOffset / BlockSize);
                var blockOffset = (int)(rawOffset % BlockSize);
                var bytesToRead = BlockSize - blockOffset;

                if (i + bytesToRead > rawSize)
                {
                    bytesToRead = rawSize - i;
                }

                ReadBlock(buffer, i, bytesToRead, blockIndex, blockOffset);

                i += bytesToRead;
                rawOffset += bytesToRead;
            }

            return buffer;
        }

        public override void WriteSectors(long sectorIndex, byte[] data)
        {
            var rawOffset = sectorIndex * SectorSize;

            for (var i = 0; i < data.Length;)
            {
                var blockIndex = (int)(rawOffset / BlockSize);
                var blockOffset = (int)(rawOffset % BlockSize);
                var bytesToWrite = BlockSize - blockOffset;

                if (i + bytesToWrite > data.Length)
                {
                    bytesToWrite = data.Length - i;
                }

                WriteBlock(data, i, bytesToWrite, blockIndex, blockOffset);

                i += bytesToWrite;
                rawOffset += bytesToWrite;
            }
        }

        public override int BytesPerSector => SectorSize;
        public override long Size { get; }
    }
}