DelphiCrossSocket的字符串操作性能瓶颈

[hezihang12]

Delphi Cross Socket中大量使用了string操作，尤其时在http协议处理上。string操作与匿名方法类似，包含IInterface的生命周期管理和堆内存申请和释放。如果大量并发请求，字符串处理也会消耗大量CPU。
建议所有字符处理改用TStringbuilder或者建立TStringBuilder池

[hezihang12]

{ RawByteStringBuilder + 池
TRawByteStringBuilder: 增长式字节缓冲, 内联 1KB → 池 32KB → 堆翻倍。
TRbsPool: 线程本地空闲链表 + 全局备用 (无锁同线程)。
AcquirePoolBuffer: 把当前内容零拷贝导出为 TSrBuffer (直接用于发送)。 }
unit sr.util.rbs;
{$IFDEF FPC}
{$MODE DELPHI}
{$H+}
{$ENDIF}

interface

uses
SysUtils, Classes, Math,
sr.io.bufferpool;

const
RBS_INLINE_SIZE = 1024;
RBS_POOL_SIZE = POOL_BUF_SIZE; { 32768 }
RBS_WARMUP_COUNT = 128; { 线程预热数量 (全局参数, 便于修改) }
RBS_GROWTH_COUNT = 128; { 池不足时一次性增长数量 }

type
TRbsMemFlag = (rbfInline, rbfPool, rbfHeap);

{ 增长式字节缓冲 builder }
TRawByteStringBuilder = class
private
FData: PByte;
FLen: Integer;
FCap: Integer;
FFlag: TRbsMemFlag;
FPoolBuf: TSrBuffer; { rbfPool: 持有的池 buffer }
FThreadId: TThreadID; { 归属线程 }
FNext: TRawByteStringBuilder; { 穿空闲链表 }
FInlineBuf: array[0..RBS_INLINE_SIZE - 1] of Byte;
procedure SetInline;
procedure UpgradeToPool;
procedure UpgradeToHeap(ANeeded: Integer);
procedure Grow(ANeeded: Integer);
public
constructor Create;
destructor Destroy; override;
procedure Clear; { len=0, 保留内存 }
procedure Append(ABuf: Pointer; ALen: Integer); { 追加字节 }
procedure AppendByte(b: Byte); { 追加单字节 }
procedure AppendStr(const s: RawByteString); { 追加 RawByteString }
procedure AppendStrS(const s: string); { 追加 string (自动转) }
procedure AppendChar(c: AnsiChar); { 追加单字符 }
procedure AppendCRLF; { 追加 \r\n }
procedure AppendLF; { 追加 \n }
procedure AppendRepeat(c: AnsiChar; n: Integer); { 追加重复字符 }
{ --- 数字格式化 (零临时串) --- }
procedure AppendInt(n: Int64); { 追加整数 }
procedure AppendUInt(n: UInt64); { 追加无符号整数 }
procedure AppendHex(n: UInt64; ALowerCase: Boolean = True); { 追加十六进制 (无 IntToHex) }
procedure AppendHexByte(b: Byte); { 追加 2 位十六进制字节 }
procedure AppendDouble(v: Double; ADecimals: Integer = 2); { 追加浮点 (无 FloatToStr) }
procedure AppendBool(v: Boolean); { 追加 true/false }
{ --- 时间格式化 (零临时串) --- }
procedure AppendDate; { yyyy-mm-dd }
procedure AppendTime; { hh:nn:ss }
procedure AppendDateTime; { yyyy-mm-dd hh:nn:ss }
procedure AppendMillis; { .zzz 毫秒 }
{ --- 字符串处理 --- }
procedure AppendEscJ(const s: string); { JSON 转义追加 }
procedure AppendEscHtml(const s: string); { HTML 转义追加 }
procedure AppendPadLeft(const s: string; ALen: Integer; APad: AnsiChar = ' '); { 左填充 }
procedure AppendPadRight(const s: string; ALen: Integer; APad: AnsiChar = ' '); { 右填充 }
procedure AppendQuoted(const s: string; AQuote: AnsiChar = '"'); { 带引号追加 }
{ --- 内存管理 --- }
procedure EnsureCap(AExtra: Integer); { 确保剩余空间 }
procedure TrimToFront(ANewLen: Integer); { 前端截断: 保留 [0..ANewLen) }
function ToRawByteString: RawByteString; { 兜底导出 (1 次 copy) }
function DataPtr: Pointer; { 零拷贝数据指针 }
function BufLen: Integer;
function Remaining: Integer;
{ --- 查询类 (不改 buffer) --- }
{ Pos: 在 [AStart..FLen) 中查找 ASub, 返回 1-based 索引, 0=未找到 (兼容 RTL Pos 语义) }
function Pos(const ASub: RawByteString; AStart: Integer = 1): Integer;
{ PosByte: 查找单字节, 返回 1-based, 0=未找到 }
function PosByte(b: Byte; AStart: Integer = 1): Integer;
{ StartsWith/EndsWith: 前缀/后缀匹配 (区分大小写) }
function StartsWith(const ASub: RawByteString): Boolean;
function EndsWith(const ASub: RawByteString): Boolean;
{ Equals: 全等比较 (区分大小写)。与另一 RawByteString 比较 }
function Equals(const ASub: RawByteString): Boolean;
{ Match: glob 通配匹配 ('*' 任意序列, '?' 单字符), 全串匹配 }
function Match(const APattern: RawByteString): Boolean;
{ --- 子串提取 (返回新 RawByteString, 拷贝; 读取冷路径) ---
索引全部 1-based, 与 RTL Copy/LeftStr/RightStr 一致。
Copy(AStart, ALen): 从 AStart 起 ALen 字节 (越界自动截断)
Mid(AStart, AEnd): [AStart..AEnd] 闭区间
Left(AN): 前 AN 字节; Right(AN): 后 AN 字节 (AN 超长返回全串, 负数当 0) }
function Copy(AStart, ALen: Integer): RawByteString;
function Mid(AStart, AEnd: Integer): RawByteString;
function Left(AN: Integer): RawByteString;
function Right(AN: Integer): RawByteString;
{ --- 修改类 (原地操作 buffer, 更新 FLen) ---
Delete(AStart, ALen): 删除从 AStart (1-based) 起 ALen 字节
Insert(AStart, ABuf, ALen): 在 AStart (1-based) 前插入 ALen 字节
InsertStr(AStart, s): 在 AStart 前插入 RawByteString
LowerCase/UpperCase: 原地 ASCII 大小写转换
Reverse: 原地字节反转
Trim/TrimLeft/TrimRight: 去除空白 (空格/TAB/CR/LF)
Replace(ASub, ANew): 全部替换 ASub→ANew (返回替换次数; 不允许空 ASub) }
procedure Delete(AStart, ALen: Integer);
procedure Insert(AStart: Integer; ABuf: Pointer; ALen: Integer);
procedure InsertStr(AStart: Integer; const s: RawByteString);
procedure LowerCase;
procedure UpperCase;
procedure Reverse;
procedure Trim;
procedure TrimLeft;
procedure TrimRight;
function Replace(const ASub, ANew: RawByteString): Integer;
{ --- 转换类 (解析整个 buffer 为标量) ---
ToInt64: 解析整数 (支持前导 +-, 失败返回 0 + AOk=False)
ToDouble: 解析浮点 (支持 +-Inf/NaN/科学计数法, 失败返回 0 + AOk=False)
ToBoolean: "true"/"1" → True, 其余 False (大小写不敏感) }
function ToInt64(out AOk: Boolean): Int64;
function ToDouble(out AOk: Boolean): Double;
function ToBoolean: Boolean;
{ 预先切换到 buffer pool 内存 (32KB)。写入数据时直接写入池 buffer,
后续 AcquirePoolBuffer 零拷贝导出 (无需内联→池拷贝)。
用于"构建发送数据包"场景: 先 EnsurePool, 再写入帧/协议数据, 再 AcquirePoolBuffer 发送。 }
procedure EnsurePool;
property Capacity: Integer read FCap;
property Next: TRawByteStringBuilder read FNext write FNext;
property ThreadId: TThreadID read FThreadId write FThreadId;
property PoolBuf: TSrBuffer read FPoolBuf;
{ 零拷贝导出: 把当前内容导出为 TSrBuffer (引用计数=1)。
必须先 EnsurePool (否则内联模式需 1 次拷贝)。
调用后 builder 自动 Clear。 }
function AcquirePoolBuffer: TSrBuffer;
end;

{ TRbsPool: builder 对象池 }
function RbsAcquire: TRawByteStringBuilder;
procedure RbsRelease(b: TRawByteStringBuilder);

{ 预热: 在 worker 线程启动时调用, 预分配几个 builder 到线程本地链表 }
procedure RbsWarmUp(ACount: Integer = 4);

implementation

const
{ 数字字符表 (查表替代 Ord('0')+n mod 10, 零加法) }
DigitChars: array[0..9] of Byte = ($30,$31,$32,$33,$34,$35,$36,$37,$38,$39);
{ 十六进制单字节表 (const 全局) }
HexLower: array[0..15] of Byte = ($30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$61,$62,$63,$64,$65,$66);
HexUpper: array[0..15] of Byte = ($30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$41,$42,$43,$44,$45,$46);
{ 十六进制双字节表: HexByteLower[b] = (高4位hex, 低4位hex), 一次查表得 2 字节 }
HexByteLower: array[0..255, 0..1] of Byte = (
($30,$30),($30,$31),($30,$32),($30,$33),($30,$34),($30,$35),($30,$36),($30,$37),
($30,$38),($30,$39),($30,$61),($30,$62),($30,$63),($30,$64),($30,$65),($30,$66),
($31,$30),($31,$31),($31,$32),($31,$33),($31,$34),($31,$35),($31,$36),($31,$37),
($31,$38),($31,$39),($31,$61),($31,$62),($31,$63),($31,$64),($31,$65),($31,$66),
($32,$30),($32,$31),($32,$32),($32,$33),($32,$34),($32,$35),($32,$36),($32,$37),
($32,$38),($32,$39),($32,$61),($32,$62),($32,$63),($32,$64),($32,$65),($32,$66),
($33,$30),($33,$31),($33,$32),($33,$33),($33,$34),($33,$35),($33,$36),($33,$37),
($33,$38),($33,$39),($33,$61),($33,$62),($33,$63),($33,$64),($33,$65),($33,$66),
($34,$30),($34,$31),($34,$32),($34,$33),($34,$34),($34,$35),($34,$36),($34,$37),
($34,$38),($34,$39),($34,$61),($34,$62),($34,$63),($34,$64),($34,$65),($34,$66),
($35,$30),($35,$31),($35,$32),($35,$33),($35,$34),($35,$35),($35,$36),($35,$37),
($35,$38),($35,$39),($35,$61),($35,$62),($35,$63),($35,$64),($35,$65),($35,$66),
($36,$30),($36,$31),($36,$32),($36,$33),($36,$34),($36,$35),($36,$36),($36,$37),
($36,$38),($36,$39),($36,$61),($36,$62),($36,$63),($36,$64),($36,$65),($36,$66),
($37,$30),($37,$31),($37,$32),($37,$33),($37,$34),($37,$35),($37,$36),($37,$37),
($37,$38),($37,$39),($37,$61),($37,$62),($37,$63),($37,$64),($37,$65),($37,$66),
($38,$30),($38,$31),($38,$32),($38,$33),($38,$34),($38,$35),($38,$36),($38,$37),
($38,$38),($38,$39),($38,$61),($38,$62),($38,$63),($38,$64),($38,$65),($38,$66),
($39,$30),($39,$31),($39,$32),($39,$33),($39,$34),($39,$35),($39,$36),($39,$37),
($39,$38),($39,$39),($39,$61),($39,$62),($39,$63),($39,$64),($39,$65),($39,$66),
($61,$30),($61,$31),($61,$32),($61,$33),($61,$34),($61,$35),($61,$36),($61,$37),
($61,$38),($61,$39),($61,$61),($61,$62),($61,$63),($61,$64),($61,$65),($61,$66),
($62,$30),($62,$31),($62,$32),($62,$33),($62,$34),($62,$35),($62,$36),($62,$37),
($62,$38),($62,$39),($62,$61),($62,$62),($62,$63),($62,$64),($62,$65),($62,$66),
($63,$30),($63,$31),($63,$32),($63,$33),($63,$34),($63,$35),($63,$36),($63,$37),
($63,$38),($63,$39),($63,$61),($63,$62),($63,$63),($63,$64),($63,$65),($63,$66),
($64,$30),($64,$31),($64,$32),($64,$33),($64,$34),($64,$35),($64,$36),($64,$37),
($64,$38),($64,$39),($64,$61),($64,$62),($64,$63),($64,$64),($64,$65),($64,$66),
($65,$30),($65,$31),($65,$32),($65,$33),($65,$34),($65,$35),($65,$36),($65,$37),
($65,$38),($65,$39),($65,$61),($65,$62),($65,$63),($65,$64),($65,$65),($65,$66),
($66,$30),($66,$31),($66,$32),($66,$33),($66,$34),($66,$35),($66,$36),($66,$37),
($66,$38),($66,$39),($66,$61),($66,$62),($66,$63),($66,$64),($66,$65),($66,$66));
HexByteUpper: array[0..255, 0..1] of Byte = (
($30,$30),($30,$31),($30,$32),($30,$33),($30,$34),($30,$35),($30,$36),($30,$37),
($30,$38),($30,$39),($30,$41),($30,$42),($30,$43),($30,$44),($30,$45),($30,$46),
($31,$30),($31,$31),($31,$32),($31,$33),($31,$34),($31,$35),($31,$36),($31,$37),
($31,$38),($31,$39),($31,$41),($31,$42),($31,$43),($31,$44),($31,$45),($31,$46),
($32,$30),($32,$31),($32,$32),($32,$33),($32,$34),($32,$35),($32,$36),($32,$37),
($32,$38),($32,$39),($32,$41),($32,$42),($32,$43),($32,$44),($32,$45),($32,$46),
($33,$30),($33,$31),($33,$32),($33,$33),($33,$34),($33,$35),($33,$36),($33,$37),
($33,$38),($33,$39),($33,$41),($33,$42),($33,$43),($33,$44),($33,$45),($33,$46),
($34,$30),($34,$31),($34,$32),($34,$33),($34,$34),($34,$35),($34,$36),($34,$37),
($34,$38),($34,$39),($34,$41),($34,$42),($34,$43),($34,$44),($34,$45),($34,$46),
($35,$30),($35,$31),($35,$32),($35,$33),($35,$34),($35,$35),($35,$36),($35,$37),
($35,$38),($35,$39),($35,$41),($35,$42),($35,$43),($35,$44),($35,$45),($35,$46),
($36,$30),($36,$31),($36,$32),($36,$33),($36,$34),($36,$35),($36,$36),($36,$37),
($36,$38),($36,$39),($36,$41),($36,$42),($36,$43),($36,$44),($36,$45),($36,$46),
($37,$30),($37,$31),($37,$32),($37,$33),($37,$34),($37,$35),($37,$36),($37,$37),
($37,$38),($37,$39),($37,$41),($37,$42),($37,$43),($37,$44),($37,$45),($37,$46),
($38,$30),($38,$31),($38,$32),($38,$33),($38,$34),($38,$35),($38,$36),($38,$37),
($38,$38),($38,$39),($38,$41),($38,$42),($38,$43),($38,$44),($38,$45),($38,$46),
($39,$30),($39,$31),($39,$32),($39,$33),($39,$34),($39,$35),($39,$36),($39,$37),
($39,$38),($39,$39),($39,$41),($39,$42),($39,$43),($39,$44),($39,$45),($39,$46),
($41,$30),($41,$31),($41,$32),($41,$33),($41,$34),($41,$35),($41,$36),($41,$37),
($41,$38),($41,$39),($41,$41),($41,$42),($41,$43),($41,$44),($41,$45),($41,$46),
($42,$30),($42,$31),($42,$32),($42,$33),($42,$34),($42,$35),($42,$36),($42,$37),
($42,$38),($42,$39),($42,$41),($42,$42),($42,$43),($42,$44),($42,$45),($42,$46),
($43,$30),($43,$31),($43,$32),($43,$33),($43,$34),($43,$35),($43,$36),($43,$37),
($43,$38),($43,$39),($43,$41),($43,$42),($43,$43),($43,$44),($43,$45),($43,$46),
($44,$30),($44,$31),($44,$32),($44,$33),($44,$34),($44,$35),($44,$36),($44,$37),
($44,$38),($44,$39),($44,$41),($44,$42),($44,$43),($44,$44),($44,$45),($44,$46),
($45,$30),($45,$31),($45,$32),($45,$33),($45,$34),($45,$35),($45,$36),($45,$37),
($45,$38),($45,$39),($45,$41),($45,$42),($45,$43),($45,$44),($45,$45),($45,$46),
($46,$30),($46,$31),($46,$32),($46,$33),($46,$34),($46,$35),($46,$36),($46,$37),
($46,$38),($46,$39),($46,$41),($46,$42),($46,$43),($46,$44),($46,$45),($46,$46));

{ ==================== TRawByteStringBuilder ==================== }

constructor TRawByteStringBuilder.Create;
begin
inherited;
SetInline;
FThreadId := FastThreadId;
end;

destructor TRawByteStringBuilder.Destroy;
begin
case FFlag of
rbfPool: if FPoolBuf <> nil then FPoolBuf._Release;
rbfHeap: FreeMem(FData);
end;
inherited;
end;

procedure TRawByteStringBuilder.SetInline;
begin
FData := @FInlineBuf[0];
FLen := 0;
FCap := RBS_INLINE_SIZE;
FFlag := rbfInline;
FPoolBuf := nil;
end;

procedure TRawByteStringBuilder.UpgradeToPool;
var
buf: TSrBuffer;
begin
buf := TSrBufferPool.Instance.Acquire; { Ref=1 }
if FLen > 0 then
Move(FData^, buf.DataPtr^, FLen);
{ 释放旧内存 }
case FFlag of
rbfPool: if FPoolBuf <> nil then FPoolBuf._Release;
rbfHeap: FreeMem(FData);
end;
FData := buf.DataPtr;
FCap := RBS_POOL_SIZE;
FFlag := rbfPool;
FPoolBuf := buf;
end;

procedure TRawByteStringBuilder.EnsurePool;
begin
if FFlag = rbfPool then Exit; { 已经是 pool 模式 }
UpgradeToPool; { 内联 → 池; 堆 → 池 (会先释放堆内存) }
end;

procedure TRawByteStringBuilder.UpgradeToHeap(ANeeded: Integer);
var
newData: PByte;
newCap: Integer;
begin
newCap := FCap * 2;
while newCap < ANeeded do newCap := newCap * 2;
GetMem(newData, newCap);
if FLen > 0 then
Move(FData^, newData^, FLen);
{ 释放旧内存 }
case FFlag of
rbfPool: if FPoolBuf <> nil then FPoolBuf._Release; { 归还 32KB 到池 }
rbfHeap: FreeMem(FData);
{ rbfInline: 不释放 (内联, 随对象) }
end;
FData := newData;
FCap := newCap;
FFlag := rbfHeap;
FPoolBuf := nil;
end;

procedure TRawByteStringBuilder.Grow(ANeeded: Integer);
begin
if FFlag = rbfInline then
UpgradeToPool;
if (ANeeded > FCap) and (FFlag = rbfPool) then
UpgradeToHeap(ANeeded)
else if (ANeeded > FCap) and (FFlag = rbfHeap) then
UpgradeToHeap(ANeeded);
end;

procedure TRawByteStringBuilder.EnsureCap(AExtra: Integer);
begin
if FLen + AExtra > FCap then
Grow(FLen + AExtra);
end;

procedure TRawByteStringBuilder.TrimToFront(ANewLen: Integer);
begin
{ 前端截断: 调用方已用 Move 把 [ANewLen..FLen) 移到 [0..ANewLen), 这里只更新 FLen }
if ANewLen < 0 then ANewLen := 0;
if ANewLen > FLen then ANewLen := FLen;
FLen := ANewLen;
end;

procedure TRawByteStringBuilder.Clear;
begin
FLen := 0;
{ 堆模式且远大于内联 → 释放堆, 降级回内联省内存 }
if (FFlag = rbfHeap) and (FCap > RBS_POOL_SIZE * 2) then
begin
FreeMem(FData); { 释放堆内存 }
SetInline;
end;
end;

procedure TRawByteStringBuilder.Append(ABuf: Pointer; ALen: Integer);
begin
if ALen <= 0 then Exit;
EnsureCap(ALen);
Move(ABuf^, (FData + FLen)^, ALen);
Inc(FLen, ALen);
end;

procedure TRawByteStringBuilder.AppendByte(b: Byte);
begin
EnsureCap(1);
(FData + FLen)^ := b;
Inc(FLen);
end;

procedure TRawByteStringBuilder.AppendChar(c: AnsiChar);
begin
AppendByte(Byte(c));
end;

procedure TRawByteStringBuilder.AppendStr(const s: RawByteString);
begin
if s <> '' then
Append(@s[1], Length(s));
end;

procedure TRawByteStringBuilder.AppendCRLF;
begin
AppendByte($0D);
AppendByte($0A);
end;

procedure TRawByteStringBuilder.AppendLF;
begin
AppendByte($0A);
end;

procedure TRawByteStringBuilder.AppendRepeat(c: AnsiChar; n: Integer);
begin
if n <= 0 then Exit;
EnsureCap(n);
FillChar((FData + FLen)^, n, Byte(c));
Inc(FLen, n);
end;

procedure TRawByteStringBuilder.AppendStrS(const s: string);
var hdr: array[0..3] of Byte;
i: Integer; b: Byte;
begin
{ 追加 string: 按字节遍历 (兼容 ASCII 路径, UTF-8 直接透传) }
if s = '' then Exit;
EnsureCap(Length(s));
for i := 1 to Length(s) do
begin
b := Byte(s[i]);
(FData + FLen)^ := b;
Inc(FLen);
end;
end;

procedure TRawByteStringBuilder.AppendInt(n: Int64);
var
buf: array[0..23] of AnsiChar;
i, len: Integer;
neg: Boolean;
begin
if n = 0 then begin AppendByte(Ord('0')); Exit; end;
neg := n < 0;
if neg then n := -n;
len := 0;
while n > 0 do
begin
buf[len] := AnsiChar(DigitChars[n mod 10]);
Inc(len);
n := n div 10;
end;
EnsureCap(len + Ord(neg));
if neg then begin (FData + FLen)^ := Ord('-'); Inc(FLen); end;
for i := len - 1 downto 0 do
begin
(FData + FLen)^ := Ord(buf[i]);
Inc(FLen);
end;
end;

procedure TRawByteStringBuilder.AppendUInt(n: UInt64);
var
buf: array[0..23] of AnsiChar;
i, len: Integer;
begin
if n = 0 then begin AppendByte(Ord('0')); Exit; end;
len := 0;
while n > 0 do
begin
buf[len] := AnsiChar(DigitChars[n mod 10]);
Inc(len);
n := n div 10;
end;
EnsureCap(len);
for i := len - 1 downto 0 do
begin
(FData + FLen)^ := Ord(buf[i]);
Inc(FLen);
end;
end;

procedure TRawByteStringBuilder.AppendHex(n: UInt64; ALowerCase: Boolean);
var
buf: array[0..15] of Byte; { 最多 16 个十六进制数字 }
len, i: Integer;
pb: PByte;
begin
if n = 0 then begin AppendByte($30); Exit; end;
{ 用 256 元素双字节查表: 每次处理 1 字节 → 2 个 hex 字符 }
len := 0;
while n > 0 do
begin
if ALowerCase then
begin
buf[len] := HexByteLower[Byte(n), 0];
buf[len + 1] := HexByteLower[Byte(n), 1];
end
else
begin
buf[len] := HexByteUpper[Byte(n), 0];
buf[len + 1] := HexByteUpper[Byte(n), 1];
end;
Inc(len, 2);
n := n shr 8;
end;
{ 去掉前导零 (最后一组的高位可能为 '0') }
while (len > 1) and (buf[len - 1] = $30) do
Dec(len);
{ 反序输出 }
EnsureCap(len);
for i := len - 1 downto 0 do
begin
(FData + FLen)^ := buf[i];
Inc(FLen);
end;
end;

procedure TRawByteStringBuilder.AppendHexByte(b: Byte);
begin
{ 一次查表写入 2 字节, 零分支 }
EnsureCap(2);
(FData + FLen)^ := HexByteLower[b, 0];
(FData + FLen + 1)^ := HexByteLower[b, 1];
Inc(FLen, 2);
end;

procedure TRawByteStringBuilder.AppendDouble(v: Double; ADecimals: Integer);
var
intPart: Int64;
fracPart: Int64;
multiplier: Int64;
i: Integer;
begin
if IsNaN(v) then begin AppendStrS('NaN'); Exit; end;
if IsInfinite(v) then
begin
if v < 0 then AppendChar('-');
AppendStrS('Inf');
Exit;
end;
if v < 0 then begin AppendChar('-'); v := -v; end;
{ 限制小数位数 0..9 }
if ADecimals < 0 then ADecimals := 0;
if ADecimals > 9 then ADecimals := 9;
intPart := Trunc(v);
AppendInt(intPart);
if ADecimals > 0 then
begin
AppendChar('.');
multiplier := 1;
for i := 1 to ADecimals do multiplier := multiplier * 10;
fracPart := Trunc((v - intPart) * multiplier);
{ 补前导零: 如 0.05 → fracPart=5, 需要 "05" }
if fracPart = 0 then
AppendRepeat('0', ADecimals)
else
begin
{ 检查前导零 }
i := ADecimals - 1;
multiplier := multiplier div 10;
while (i > 0) and (fracPart < multiplier) do
begin
AppendChar('0');
multiplier := multiplier div 10;
Dec(i);
end;
AppendInt(fracPart);
end;
end;
end;

procedure TRawByteStringBuilder.AppendBool(v: Boolean);
begin
if v then AppendStrS('true') else AppendStrS('false');
end;

procedure TRawByteStringBuilder.AppendDate;
var
Y, M, D: Word;
begin
DecodeDate(Now, Y, M, D);
AppendInt(Y); AppendChar('-');
if M < 10 then AppendChar('0');
AppendInt(M); AppendChar('-');
if D < 10 then AppendChar('0');
AppendInt(D);
end;

procedure TRawByteStringBuilder.AppendTime;
var
H, Mn, S, MS: Word;
begin
DecodeTime(Now, H, Mn, S, MS);
if H < 10 then AppendChar('0');
AppendInt(H); AppendChar(':');
if Mn < 10 then AppendChar('0');
AppendInt(Mn); AppendChar(':');
if S < 10 then AppendChar('0');
AppendInt(S);
end;

procedure TRawByteStringBuilder.AppendDateTime;
begin
AppendDate;
AppendChar(' ');
AppendTime;
end;

procedure TRawByteStringBuilder.AppendMillis;
var
H, Mn, S, MS: Word;
begin
DecodeTime(Now, H, Mn, S, MS);
AppendChar('.');
if MS < 100 then AppendChar('0');
if MS < 10 then AppendChar('0');
AppendInt(MS);
end;

procedure TRawByteStringBuilder.AppendEscHtml(const s: string);
var
i: Integer; c: Byte;
begin
EnsureCap(Length(s) * 6);
for i := 1 to Length(s) do
begin
c := Byte(s[i]);
case c of
Ord('<'): AppendStrS('<');
Ord('>'): AppendStrS('>');
Ord('&'): AppendStrS('&');
Ord('"'): AppendStrS('"');
else
AppendByte(c);
end;
end;
end;

procedure TRawByteStringBuilder.AppendPadLeft(const s: string; ALen: Integer; APad: AnsiChar);
var
padCount: Integer;
begin
padCount := ALen - Length(s);
if padCount > 0 then AppendRepeat(APad, padCount);
AppendStrS(s);
end;

procedure TRawByteStringBuilder.AppendPadRight(const s: string; ALen: Integer; APad: AnsiChar);
var
padCount: Integer;
begin
AppendStrS(s);
padCount := ALen - Length(s);
if padCount > 0 then AppendRepeat(APad, padCount);
end;

procedure TRawByteStringBuilder.AppendQuoted(const s: string; AQuote: AnsiChar);
begin
AppendChar(AQuote);
AppendStrS(s);
AppendChar(AQuote);
end;

procedure TRawByteStringBuilder.AppendEscJ(const s: string);
var
i: Integer;
c: Byte;
begin
{ JSON 转义: " → ", \ → \, \n → \n, \r → \r, \t → \t, <32 → \uXXXX }
EnsureCap(Length(s) * 6); { 最坏情况: 每字符 6 字节 (\uXXXX) }
for i := 1 to Length(s) do
begin
c := Byte(s[i]);
case c of
Ord('"'): begin AppendByte(Ord('')); AppendByte(Ord('"')); end;
Ord(''): begin AppendByte(Ord('')); AppendByte(Ord('')); end;
$0A: begin AppendByte(Ord('')); AppendByte(Ord('n')); end;
$0D: begin AppendByte(Ord('')); AppendByte(Ord('r')); end;
$09: begin AppendByte(Ord('')); AppendByte(Ord('t')); end;
else
if c < 32 then
begin
AppendByte(Ord(''));
AppendByte(Ord('u'));
AppendByte(Ord('0'));
AppendByte(Ord('0'));
AppendByte(Ord('0') + (c shr 4));
AppendByte(Ord('0') + (c and $0F));
end
else
AppendByte(c);
end;
end;
end;

function TRawByteStringBuilder.ToRawByteString: RawByteString;
begin
SetLength(Result, FLen);
if FLen > 0 then
Move(FData^, Result[1], FLen);
end;

function TRawByteStringBuilder.DataPtr: Pointer;
begin
Result := FData;
end;

function TRawByteStringBuilder.BufLen: Integer;
begin
Result := FLen;
end;

function TRawByteStringBuilder.Remaining: Integer;
begin
Result := FCap - FLen;
end;

{ ==================== 查询类 ==================== }

{ 内部: 比较两段内存是否相等 (逐字节, 不走 libc) }
function RbsMemEqual(p1, p2: PByte; n: Integer): Boolean;
begin
Result := False;
if n <= 0 then Exit(True);
while n > 0 do
begin
if p1^ <> p2^ then Exit;
Inc(p1); Inc(p2); Dec(n);
end;
Result := True;
end;

function TRawByteStringBuilder.Pos(const ASub: RawByteString; AStart: Integer): Integer;
var
subLen, i, limit: Integer; firstByte: Byte; p, sp: PByte;
begin
Result := 0;
subLen := Length(ASub);
if subLen = 0 then Exit;
if (AStart < 1) then AStart := 1;
{ 子串长于 buffer 或起点越界 }
if (subLen > FLen) or (AStart - 1 + subLen > FLen) then Exit;
firstByte := Byte(ASub[1]);
sp := @asub[1];
limit := FLen - subLen; { 0-based 最大起点 }
p := FData + (AStart - 1);
for i := (AStart - 1) to limit do
begin
if (p^ = firstByte) and RbsMemEqual(p, sp, subLen) then
Exit(i + 1); { 1-based }
Inc(p);
end;
end;

function TRawByteStringBuilder.PosByte(b: Byte; AStart: Integer): Integer;
var
i: Integer; p: PByte;
begin
Result := 0;
if AStart < 1 then AStart := 1;
if AStart - 1 > FLen - 1 then Exit;
p := FData + (AStart - 1);
for i := AStart - 1 to FLen - 1 do
begin
if p^ = b then Exit(i + 1);
Inc(p);
end;
end;

function TRawByteStringBuilder.StartsWith(const ASub: RawByteString): Boolean;
var
subLen: Integer;
begin
subLen := Length(ASub);
if subLen = 0 then Exit(True);
if subLen > FLen then Exit(False);
Result := RbsMemEqual(FData, @asub[1], subLen);
end;

function TRawByteStringBuilder.EndsWith(const ASub: RawByteString): Boolean;
var
subLen: Integer;
begin
subLen := Length(ASub);
if subLen = 0 then Exit(True);
if subLen > FLen then Exit(False);
Result := RbsMemEqual(FData + (FLen - subLen), @asub[1], subLen);
end;

function TRawByteStringBuilder.Equals(const ASub: RawByteString): Boolean;
var
subLen: Integer;
begin
subLen := Length(ASub);
if subLen <> FLen then Exit(False);
if subLen = 0 then Exit(True);
Result := RbsMemEqual(FData, @asub[1], subLen);
end;

function TRawByteStringBuilder.Match(const APattern: RawByteString): Boolean;
{ glob 通配: '' = 任意序列, '?' = 单字符. 整串匹配.
回溯实现, O(nm) 最坏但实际很快 }
var
pn, sn, pi, si, star, match: Integer; p, s: PByte;
begin
pn := Length(APattern); sn := FLen;
if pn = 0 then Exit(sn = 0);
p := @apattern[1]; s := FData;
pi := 0; si := 0; star := -1; match := 0;
while si < sn do
begin
if (pi < pn) and ((p[pi] = Ord('?')) or (p[pi] = s[si])) then
begin
Inc(pi); Inc(si);
end
else if (pi < pn) and (p[pi] = Ord('')) then
begin
star := pi; match := si; Inc(pi);
end
else if star >= 0 then
begin
pi := star + 1; Inc(match); si := match;
end
else
Exit(False);
end;
{ 消耗 pattern 尾部多余的 '' }
while (pi < pn) and (p[pi] = Ord('*')) do Inc(pi);
Result := (pi = pn);
end;

{ ==================== 子串提取 ==================== }

function TRawByteStringBuilder.Copy(AStart, ALen: Integer): RawByteString;
var
start0, n: Integer;
begin
Result := '';
start0 := AStart - 1; { 转 0-based }
if start0 < 0 then start0 := 0;
if start0 >= FLen then Exit;
n := FLen - start0;
if ALen < n then n := ALen;
if n <= 0 then Exit;
SetLength(Result, n);
Move((FData + start0)^, Result[1], n);
end;

function TRawByteStringBuilder.Mid(AStart, AEnd: Integer): RawByteString;
var
start0, end0, n: Integer;
begin
Result := '';
{ AStart, AEnd 都是 1-based 闭区间 }
start0 := AStart - 1;
if start0 < 0 then start0 := 0;
end0 := AEnd;
if end0 > FLen then end0 := FLen; { 0-based 含义下 end0 即末尾(不含) }
{ 闭区间 [AStart..AEnd] → 字节数 = end0 - start0 }
if end0 <= start0 then Exit;
n := end0 - start0;
SetLength(Result, n);
Move((FData + start0)^, Result[1], n);
end;

function TRawByteStringBuilder.Left(AN: Integer): RawByteString;
var
n: Integer;
begin
Result := '';
if AN <= 0 then Exit;
n := AN;
if n > FLen then n := FLen;
SetLength(Result, n);
if n > 0 then Move(FData^, Result[1], n);
end;

function TRawByteStringBuilder.Right(AN: Integer): RawByteString;
var
n: Integer;
begin
Result := '';
if AN <= 0 then Exit;
n := AN;
if n > FLen then n := FLen;
SetLength(Result, n);
if n > 0 then Move((FData + (FLen - n))^, Result[1], n);
end;

{ ==================== 修改类 ==================== }

procedure TRawByteStringBuilder.Delete(AStart, ALen: Integer);
var
start0, n, tailLen: Integer;
begin
if ALen <= 0 then Exit;
start0 := AStart - 1;
if start0 < 0 then start0 := 0;
if start0 >= FLen then Exit;
n := FLen - start0;
if ALen < n then n := ALen;
tailLen := FLen - start0 - n;
if tailLen > 0 then
Move((FData + start0 + n)^, (FData + start0)^, tailLen);
Dec(FLen, n);
end;

procedure TRawByteStringBuilder.Insert(AStart: Integer; ABuf: Pointer; ALen: Integer);
var
start0, tailLen: Integer;
begin
if ALen <= 0 then Exit;
start0 := AStart - 1;
if start0 < 0 then start0 := 0;
if start0 > FLen then start0 := FLen;
EnsureCap(ALen);
{ 后移 [start0..FLen) 共 tailLen 字节到 [start0+ALen..) }
tailLen := FLen - start0;
if tailLen > 0 then
Move((FData + start0)^, (FData + start0 + ALen)^, tailLen);
if ABuf <> nil then
Move(ABuf^, (FData + start0)^, ALen);
Inc(FLen, ALen);
end;

procedure TRawByteStringBuilder.InsertStr(AStart: Integer; const s: RawByteString);
begin
if s <> '' then Insert(AStart, @s[1], Length(s));
end;

procedure TRawByteStringBuilder.LowerCase;
var
i: Integer; p: PByte; c: Byte;
begin
p := FData;
for i := 0 to FLen - 1 do
begin
c := p^;
if (c >= $41) and (c <= $5A) then p^ := c + $20; { 'A'..'Z' → 'a'..'z' }
Inc(p);
end;
end;

procedure TRawByteStringBuilder.UpperCase;
var
i: Integer; p: PByte; c: Byte;
begin
p := FData;
for i := 0 to FLen - 1 do
begin
c := p^;
if (c >= $61) and (c <= $7A) then p^ := c - $20; { 'a'..'z' → 'A'..'Z' }
Inc(p);
end;
end;

procedure TRawByteStringBuilder.Reverse;
var
i, j: Integer; t: Byte;
begin
if FLen < 2 then Exit;
i := 0; j := FLen - 1;
while i < j do
begin
t := (FData + i)^; (FData + i)^ := (FData + j)^; (FData + j)^ := t;
Inc(i); Dec(j);
end;
end;

procedure TRawByteStringBuilder.TrimLeft;
var
p: PByte; n: Integer; c: Byte;
begin
p := FData; n := 0;
while n < FLen do
begin
c := p^;
if (c <> $20) and (c <> $09) and (c <> $0A) and (c <> $0D) then Break;
Inc(p); Inc(n);
end;
if n > 0 then
begin
Delete(1, n);
end;
end;

procedure TRawByteStringBuilder.TrimRight;
var
n: Integer; c: Byte;
begin
n := FLen;
while n > 0 do
begin
c := (FData + n - 1)^;
if (c <> $20) and (c <> $09) and (c <> $0A) and (c <> $0D) then Break;
Dec(n);
end;
if n < FLen then FLen := n; { 只缩不扩, 直接改 FLen }
end;

procedure TRawByteStringBuilder.Trim;
begin
TrimRight;
TrimLeft;
end;

function TRawByteStringBuilder.Replace(const ASub, ANew: RawByteString): Integer;
{ 全部替换 ASub→ANew. 原地策略: 当 ANew 长度 <= ASub 长度时直接覆盖;
否则用一个临时 builder 构造结果再回填 (避免 O(n²) 反复 Move)。
返回替换次数。ASub 为空返回 0 (避免死循环) }
var
subLen, newLen, lastPos0, hit0: Integer;
tmp: TRawByteStringBuilder; src, dst: PByte;
begin
Result := 0;
subLen := Length(ASub);
if subLen = 0 then Exit;
newLen := Length(ANew);
if subLen > FLen then Exit;
{ 相同长度 → 原地覆盖 }
if newLen = subLen then
begin
src := @anew[1];
lastPos0 := 0;
while True do
begin
hit0 := Pos(ASub, lastPos0 + 1);
if hit0 = 0 then Break;
dst := FData + hit0 - 1;
Move(src^, dst^, subLen);
lastPos0 := hit0 - 1 + subLen;
Inc(Result);
end;
Exit;
end;
{ 长度不同 → 用临时 builder 拼接 }
tmp := RbsAcquire;
try
lastPos0 := 0;
{ 循环: 找到每个 ASub, 把未匹配前缀 + ANew 追加到 tmp }
while True do
begin
hit0 := Pos(ASub, lastPos0 + 1);
if hit0 = 0 then Break;
{ 复制 [lastPos0..hit0-1) 未匹配部分 }
if hit0 - 1 > lastPos0 then
tmp.Append(FData + lastPos0, hit0 - 1 - lastPos0);
if newLen > 0 then tmp.Append(@anew[1], newLen);
lastPos0 := hit0 - 1 + subLen;
Inc(Result);
end;
{ 复制尾部未匹配部分 }
if FLen > lastPos0 then
tmp.Append(FData + lastPos0, FLen - lastPos0);
{ 回填到当前 builder }
FLen := 0;
if tmp.FLen > 0 then
begin
EnsureCap(tmp.FLen);
Move(tmp.FData^, FData^, tmp.FLen);
FLen := tmp.FLen;
end;
finally
RbsRelease(tmp);
end;
end;

{ ==================== 转换类 ==================== }

function TRawByteStringBuilder.ToInt64(out AOk: Boolean): Int64;
var
i: Integer; p: PByte; neg, hasDig: Boolean; v: Int64; c: Byte;
begin
AOk := False; Result := 0;
if FLen = 0 then Exit;
p := FData; i := 0;
{ 跳过前导空白 }
while (i < FLen) do
begin
c := p^;
if (c <> $20) and (c <> $09) and (c <> $0A) and (c <> $0D) then Break;
Inc(p); Inc(i);
end;
if i >= FLen then Exit;
neg := False;
if p^ = Ord('-') then begin neg := True; Inc(p); Inc(i); end
else if p^ = Ord('+') then begin Inc(p); Inc(i); end;
if i >= FLen then Exit; { 只有符号 }
v := 0; hasDig := False;
while i < FLen do
begin
c := p^;
if (c < $30) or (c > $39) then Break; { 非数字停止 }
v := v * 10 + (c - $30); hasDig := True;
Inc(p); Inc(i);
end;
if not hasDig then Exit; { 无数字 → 解析失败 }
if neg then Result := -v else Result := v;
AOk := True;
end;

function TRawByteStringBuilder.ToDouble(out AOk: Boolean): Double;
var
i, digCount: Integer; p: PByte; neg, expNeg, hasDig: Boolean;
v, frac, fracScale: Double; c: Byte; expv: Integer;
begin
AOk := False; Result := 0;
if FLen = 0 then Exit;
p := FData; i := 0;
while (i < FLen) do
begin
c := p^;
if (c <> $20) and (c <> $09) and (c <> $0A) and (c <> $0D) then Break;
Inc(p); Inc(i);
end;
if i >= FLen then Exit;
neg := False;
if p^ = Ord('-') then begin neg := True; Inc(p); Inc(i); end
else if p^ = Ord('+') then begin Inc(p); Inc(i); end;
{ 整数部分 }
v := 0; hasDig := False;
while i < FLen do
begin
c := p^;
if (c < $30) or (c > $39) then Break;
v := v * 10 + (c - $30); hasDig := True;
Inc(p); Inc(i);
end;
{ 小数部分 }
if (i < FLen) and (p^ = Ord('.')) then
begin
Inc(p); Inc(i);
frac := 0; fracScale := 1;
while i < FLen do
begin
c := p^;
if (c < $30) or (c > $39) then Break;
frac := frac * 10 + (c - $30); fracScale := fracScale * 10; hasDig := True;
Inc(p); Inc(i);
end;
v := v + frac / fracScale;
end;
if not hasDig then Exit;
{ 指数部分 e/E[+-]ddd (用独立 expNeg 变量, 不污染数值符号 neg) }
if (i < FLen) and ((p^ = Ord('e')) or (p^ = Ord('E'))) then
begin
Inc(p); Inc(i); expv := 0; digCount := 0; expNeg := False;
if i < FLen then
begin
if p^ = Ord('-') then begin expNeg := True; Inc(p); Inc(i); end
else if p^ = Ord('+') then begin Inc(p); Inc(i); end;
end;
while i < FLen do
begin
c := p^;
if (c < $30) or (c > $39) then Break;
expv := expv * 10 + (c - $30); Inc(digCount);
Inc(p); Inc(i);
end;
if digCount = 0 then Exit; { 有 e 但无数字 → 非法 }
if expNeg then expv := -expv;
if expv <> 0 then v := v * IntPower(10, expv);
end;
if neg then Result := -v else Result := v;
AOk := True;
end;

function TRawByteStringBuilder.ToBoolean: Boolean;
{ "true"/"1" (大小写不敏感) → True; 其余 False }
var
p: PByte; i: Integer; c: Byte;
begin
Result := False;
if FLen = 1 then
begin
c := FData^;
if (c = Ord('1')) then Exit(True);
if (c = Ord('0')) then Exit(False);
end;
if FLen <> 4 then Exit;
p := FData;
{ 'true' = $74 $72 $75 $65 }
for i := 0 to 3 do
begin
c := p^;
{ 小写化比较 }
if (c >= $41) and (c <= $5A) then Inc(c, $20);
case i of
0: if c <> $74 then Exit; { t }
1: if c <> $72 then Exit; { r }
2: if c <> $75 then Exit; { u }
3: if c <> $65 then Exit; { e }
end;
Inc(p);
end;
Result := True;
end;

function TRawByteStringBuilder.AcquirePoolBuffer: TSrBuffer;
begin
{ 零拷贝导出为 TSrBuffer (供直接 WSASend 发送) }
if (FFlag = rbfPool) and (FPoolBuf <> nil) then
begin
{ 当前内容就在池 buffer 里 → 转移 builder 的所有权给调用方 (不 AddRef)。
builder 的 Acquire 时 Ref=1 就是这份所有权; 直接转移, builder 回到内联。 }
FPoolBuf.Len := FLen;
Result := FPoolBuf;
{ 不 AddRef: Acquire 时的 Ref=1 转移给调用方 (Result.RefCount 已经是 1) }
FPoolBuf := nil; { 断开 builder 与 pool buffer 的关联, 防止 destructor 再 Release }
SetInline; { builder 回到内联模式 }
end
else
begin
{ 内联或堆 → 拷贝到新池 buffer (Acquire 时 Ref=1) }
Result := TSrBufferPool.Instance.Acquire;
if FLen > 0 then
Move(FData^, Result.DataPtr^, FLen);
Result.Len := FLen;
Clear;
end;
end;

{ ==================== TRbsPool ==================== }

threadvar
RbsFreeList: TRawByteStringBuilder;
RbsFreeCount: Integer;

var
RbsGlobalLock: TRTLCriticalSection;
RbsGlobalFree: TRawByteStringBuilder;

function RbsAcquire: TRawByteStringBuilder;
var
i, moved: Integer;
b: TRawByteStringBuilder;
begin
{ 1. 线程本地空闲链表 (无锁) }
if RbsFreeList <> nil then
begin
Result := RbsFreeList;
RbsFreeList := Result.FNext;
Dec(RbsFreeCount);
Result.Clear;
end
else
begin
{ 2. 全局备用链表: 批量搬到本地 (减少锁竞争) }
Result := nil;
EnterCriticalSection(RbsGlobalLock);
try
moved := 0;
while (RbsGlobalFree <> nil) and (moved < RBS_GROWTH_COUNT) do
begin
b := RbsGlobalFree;
RbsGlobalFree := b.FNext;
if Result = nil then
begin
Result := b;
Result.Clear;
Result.FThreadId := FastThreadId; { 更新为当前线程 }
end
else
begin
b.Clear;
b.FThreadId := FastThreadId; { 更新为当前线程 }
b.FNext := RbsFreeList;
RbsFreeList := b;
Inc(RbsFreeCount);
end;
Inc(moved);
end;
finally
LeaveCriticalSection(RbsGlobalLock);
end;

if Result = nil then
begin
  { 3. 全局也空: 在当前线程批量创建 RBS_GROWTH_COUNT 个 }
  Result := TRawByteStringBuilder.Create;
  Result.FThreadId := FastThreadId;
  Result.Clear;
  for i := 1 to RBS_GROWTH_COUNT - 1 do
  begin
    b := TRawByteStringBuilder.Create;
    b.FThreadId := FastThreadId;
    b.Clear;
    b.FNext := RbsFreeList;
    RbsFreeList := b;
    Inc(RbsFreeCount);
  end;
end;

end;
end;

procedure RbsRelease(b: TRawByteStringBuilder);
var
prevTid: TThreadID;
begin
b.Clear;
prevTid := b.FThreadId;
b.FThreadId := FastThreadId;
if FastThreadId = prevTid then
begin
{ 同线程: 永远放回线程本地链表 (无锁, 无上限)
本地链表是最热的缓存, 不应该还到全局增加锁竞争。 }
b.FNext := RbsFreeList;
RbsFreeList := b;
Inc(RbsFreeCount);
end
else
begin
{ 跨线程: 放全局备用链表 }
EnterCriticalSection(RbsGlobalLock);
try
b.FNext := RbsGlobalFree;
RbsGlobalFree := b;
finally
LeaveCriticalSection(RbsGlobalLock);
end;
end;
end;

procedure RbsWarmUp(ACount: Integer);
var
i: Integer;
builders: array of TRawByteStringBuilder;
begin
{ 预分配 ACount 个 builder 到线程本地链表 }
SetLength(builders, ACount);
for i := 0 to ACount - 1 do
builders[i] := TRawByteStringBuilder.Create;
for i := 0 to ACount - 1 do
RbsRelease(builders[i]);
end;

var
_rbs_p: TRawByteStringBuilder;

initialization
InitCriticalSection(RbsGlobalLock);
finalization
_rbs_p := RbsGlobalFree;
while _rbs_p <> nil do
begin
RbsGlobalFree := _rbs_p.FNext;
_rbs_p.Free;
_rbs_p := RbsGlobalFree;
end;
DoneCriticalSection(RbsGlobalLock);

end.