Пример #1
0
        public static bool WriteBlockAndPreamble(TrackingPipeWriter writer, NettraceBlock block)
        {
            if (block.Type.Name != KnownTypeNames.EventBlockCompressed && block.Type.Name != KnownTypeNames.StackBlockCompressed)
            {
                return(false);
            }

            var padding      = BlockHelpers.GetPadding(writer, block);
            var prefixLength = padding + sizeof(int);

            using var decoder = new BrotliDecoder();

            var source = ArrayPool <byte> .Shared.Rent((int)block.BlockBody.Length);

            block.BlockBody.CopyTo(source);
            var           written = 0;
            Memory <byte> memory;

            try
            {
                var length = prefixLength + (int)block.BlockBody.Length;
                memory = writer.GetMemory(length);
                while (!BrotliDecoder.TryDecompress(source.AsSpan(0, (int)block.BlockBody.Length), memory.Slice(prefixLength).Span, out written))
                {
                    length = memory.Length * 2;
                    memory = writer.GetMemory(length);
                }
            }
            finally
            {
                ArrayPool <byte> .Shared.Return(source);
            }

            // Write size
            BitConverter.TryWriteBytes(memory.Span, written);
            // clear padding bits
            memory.Slice(sizeof(int), padding).Span.Clear();
            writer.Advance(written + prefixLength);

            return(true);
        }
Пример #2
0
        public static bool WriteBlockAndPreamble(TrackingPipeWriter writer, NettraceBlock block)
        {
            if (block.Type.Name != KnownTypeNames.EventBlock && block.Type.Name != KnownTypeNames.StackBlock)
            {
                return(false);
            }

            var blockSequence = block.BlockBody;
            var maxLength     = BrotliEncoder.GetMaxCompressedLength((int)blockSequence.Length);
            var padding       = BlockHelpers.GetPadding(writer !, block);
            var prefixLength  = padding + sizeof(int);
            var memory        = writer !.GetMemory(maxLength + prefixLength);

            // clear padding bits
            memory.Slice(0, prefixLength).Span.Clear();
            using var encoder = new BrotliEncoder(quality: 9, window: 10);

            var             slicedMemory = memory.Slice(prefixLength);
            var             totalWritten = 0;
            OperationStatus status;

            foreach (var sequence in blockSequence)
            {
                status = encoder.Compress(sequence.Span, slicedMemory.Span, out var consumed, out var written, false);
                Debug.Assert(consumed == sequence.Span.Length);
                Debug.Assert(status == OperationStatus.Done);
                slicedMemory  = slicedMemory.Slice(written);
                totalWritten += written;
            }
            status = encoder.Compress(ReadOnlySpan <byte> .Empty, slicedMemory.Span, out var _, out var written2, true);
            Debug.Assert(status == OperationStatus.Done);
            totalWritten += written2;

            // Write size
            BitConverter.TryWriteBytes(memory.Span, totalWritten);
            writer.Advance(totalWritten + prefixLength);

            return(true);
        }