Commit c788ba8

//

using System;

using System.Collections.Generic;

using System.Runtime.CompilerServices;

using System.Text.Json;

using Telegram.Td;

#nullable disable

namespace Telegram.Td.Api

/// <summary>

/// What the generated FromPtr_* parsers call, mirroring the Utf8JsonReader helpers in

/// ClientJson.cs one for one. Lives beside the benchmark for now; when the app adopts the

/// pointer path this file moves to Telegram/Td/ unchanged.

/// </summary>

public partial class ClientJson

{

/// <summary>

/// The same table ClientJson hashes property names with, reached through the partial rather

/// than copied - the generated switches only work if both sides compute identical values.

/// </summary>

/// A property rather than a field: static field initializers run in the order the compiler

/// happens to put the partial's files in, and as a field this read null.

internal static uint[] Crc32Table => crc32_table;

public delegate T PtrParser<T>(ref TdJsonReader reader, ClientResultHandler handler);

public delegate T PtrDispatch<T>(ref TdJsonReader reader, ClientResultHandler handler, uint hash);

/// <summary>Entry point: the whole payload, straight off td_receive's pointer.</summary>

public static unsafe Object FromPtr(byte* buffer, int length, ClientResultHandler handler = null)

{

var reader = new TdJsonReader(buffer, length);

reader.Read();

if (reader.TokenType == JsonTokenType.StartObject)

{

reader.Read();

if (reader.TokenType == JsonTokenType.PropertyName && reader.ValueTextEquals("@type"u8))

{

reader.Read();

var hash = reader.ValueCrc32();

reader.Read();

return DoFromPtr(ref reader, handler, hash);

}

}

return new Error(400, "Can't deserialize");

}

/// <summary>

/// Reads a nested object of an abstract type: its @type decides which parser runs.

/// </summary>

public static T FromPtr<T>(ref TdJsonReader reader, ClientResultHandler handler, PtrDispatch<T> dispatch) where T : Object

{

if (reader.TokenType == JsonTokenType.Null)

{

return null;

}

reader.Read();

if (reader.TokenType == JsonTokenType.PropertyName && reader.ValueTextEquals("@type"u8))

{

reader.Read();

var hash = reader.ValueCrc32();

reader.Read();

return dispatch(ref reader, handler, hash);

}

return null;

}

/// <summary>

/// Steps onto the first field of an object, past the @type the sender always writes.

/// </summary>

[MethodImpl(MethodImplOptions.AggressiveInlining)]

public static void ReadStartObjectPtr(ref TdJsonReader reader)

{

if (reader.TokenType == JsonTokenType.Null)

{

return;

}

if (reader.TokenType == JsonTokenType.StartObject)

{

reader.Read();

if (reader.TokenType == JsonTokenType.PropertyName && reader.ValueTextEquals("@type"u8))

{

reader.Read();

reader.Read();

}

}

}

public static List<T> GetObjectArrayPtr<T>(ref TdJsonReader reader, ClientResultHandler handler, PtrParser<T> parser) where T : Object

{

var items = new List<T>();

reader.Read();

while (reader.TokenType == JsonTokenType.StartObject || reader.TokenType == JsonTokenType.Null)

{

items.Add(reader.TokenType == JsonTokenType.Null ? null : parser(ref reader, handler));

reader.Read();

}

return items;

}

public static List<IList<T>> GetObjectArrayArrayPtr<T>(ref TdJsonReader reader, ClientResultHandler handler, PtrParser<T> parser) where T : Object

{

var items = new List<IList<T>>();

reader.Read();

while (reader.TokenType == JsonTokenType.StartArray)

{

items.Add(GetObjectArrayPtr(ref reader, handler, parser));

reader.Read();

}

return items;

}

public static List<bool> GetBooleanArrayPtr(ref TdJsonReader reader)

{

var items = new List<bool>();

reader.Read();

while (reader.TokenType == JsonTokenType.True || reader.TokenType == JsonTokenType.False)

{

items.Add(reader.GetBoolean());

reader.Read();

}

return items;

}

public static List<int> GetInt32ArrayPtr(ref TdJsonReader reader)

{

var items = new List<int>();

reader.Read();

while (reader.TokenType == JsonTokenType.Number)

{

items.Add(reader.GetInt32());

reader.Read();

}

return items;

}

public static List<long> GetInt64ArrayPtr(ref TdJsonReader reader)

{

var items = new List<long>();

reader.Read();

while (reader.TokenType == JsonTokenType.Number)

{

items.Add(reader.GetInt64());

reader.Read();

}

return items;

}

/// <summary>int64 arrives quoted, so the elements are strings rather than numbers.</summary>

public static List<long> GetInt64StringArrayPtr(ref TdJsonReader reader)

{

var items = new List<long>();

reader.Read();

while (reader.TokenType == JsonTokenType.Number || reader.TokenType == JsonTokenType.String)

{

items.Add(reader.GetInt64String());

reader.Read();

}

return items;

}

public static List<double> GetDoubleArrayPtr(ref TdJsonReader reader)

{

var items = new List<double>();

reader.Read();

while (reader.TokenType == JsonTokenType.Number)

{

items.Add(reader.GetDouble());

reader.Read();

}

return items;

}

public static List<string> GetStringArrayPtr(ref TdJsonReader reader)

{

var items = new List<string>();

reader.Read();

while (reader.TokenType == JsonTokenType.String)

{

items.Add(reader.GetString());

reader.Read();

}

return items;

}

public static List<byte[]> GetBase64StringArrayPtr(ref TdJsonReader reader)

{

var items = new List<byte[]>();

reader.Read();

while (reader.TokenType == JsonTokenType.String)

{

items.Add(reader.GetBytesFromBase64());

reader.Read();

}

return items;

}

}

namespace Telegram.Td.Api

public unsafe ref struct TdJsonReader

/// <summary>

/// CRC32 of the current token, walking raw memory. Field dispatch compares names exactly -

/// there are few enough per class for that to be cheap and it cannot collide - but a @type

/// switch covers up to eighty constructors, where a hash is the right shape. Must agree

/// with the values SchemaGenerator bakes into the switch.

/// </summary>

public uint ValueCrc32()

{

var table = ClientJson.Crc32Table;

var crc = 0xFFFFFFFF;

for (int i = 0; i < _valueLength; i++)

{

crc = table[(crc ^ _buffer[_valueStart + i]) & 0xFF] ^ (crc >> 8);

}

return crc ^ 0xFFFFFFFF;

}

`SchemaGenerator` now emits a second set, `FromPtr_*`, reading through `TdJsonReader` instead of

`Utf8JsonReader`. Both come from the same schema, so they cannot drift. It is opt-in — set

`<TdPointerParser>true</TdPointerParser>` plus `<CompilerVisibleProperty Include="TdPointerParser" />`

— and with it off the generated file is byte for byte what it has always been, which is the check

that makes changing the generator safe without being able to build the app.

Field dispatch uses name length then an exact compare rather than CRC32: few enough fields per class

for that to be cheap, and an unknown field cannot collide with a known one. `@type` dispatch keeps

the CRC32 switch — up to eighty constructors is the wrong shape for a compare chain — using

`TdJsonReader.ValueCrc32`, which walks raw memory and must agree with the values the generator bakes

in.

Full parse on .NET Native, same payloads, same objects out:

| | `FromJson` | `FromPtr` | |

| --- | ---: | ---: | ---: |

| `updateUserStatus` | 682.2 ns | **335.6 ns** | 2.0× |

| `updateFile` | 2.78 µs | **1.12 µs** | 2.5× |

| `updateNewMessage` | 8.15 µs | **3.76 µs** | 2.2× |

| `messages` ×50 | 436.3 µs | **181.7 µs** | 2.4× |

| `updateOption` (escapes) | 1.41 µs | **493.2 ns** | 2.9× |

**2.0–2.9×**, matching the 2–2.5× predicted from the tokeniser numbers, with allocation identical to

the byte. On the desktop JIT the two are at parity (97.2 µs against 97.8 µs for a page).

`Validation` runs the same assertions over both readers' output on every host, and on the desktop

also compares the two object graphs field by field through reflection. Both report `validation ok`

including on .NET Native, so the pointer parsers agree with the netstandard2.0 System.Text.Json ones

across nested objects, vectors, abstract dispatch, escapes and unknown fields.

Not yet done: `updateFile` and `file` are routed through `ClientResultHandler` on the JSON path so

the app can dedupe them, and the pointer path parses them inline instead. Matching that needs the

interface to take a `TdJsonReader`, which belongs with wiring this into the app.

/// <summary>

/// The whole parse, both generated readers, same payloads and same objects out. This is the

/// number the tokeniser work is ultimately for.

/// </summary>

private static unsafe void Parse(Harness harness)

var native = Marshal.AllocHGlobal(length + 1);

Marshal.Copy(bytes, 0, native, length);

((byte*)native)[length] = 0; // the terminator TdJsonReader scans to

var ptr = (byte*)native;

_native[payload.Name] = (IntPtr)ptr;

}

// A second pass rather than interleaved, so the report keeps each reader's rows

// together.

foreach (var payload in Corpus.Load())

{

var ptr = (byte*)_native[payload.Name];

var length = payload.Length;

harness.Measure("FromPtr", payload.Name,

() => ClientJson.FromPtr(ptr, length, BenchmarkResultHandler.Instance));

private static readonly Dictionary<string, IntPtr> _native = new();