Artigo Técnico

Parsing XLSX paralelo no Delphi: gargalo do memory manager

Um loader em Delphi que analisa um pacote XLSX de oito planilhas em oito worker threads pode mostrar um gráfico de CPU que mal passa de um núcleo, e varrer a contagem de threads de dois a oito deixa o cronômetro quase onde estava. Com duas threads a carga pode até sair mais lenta do que um loop serial simples. O código de parsing não toma nenhum lock próprio e as planilhas não compartilham dados, então a espera acontece em um lugar que o código-fonte nunca menciona: dentro do memory manager, que cada uma dessas workers aciona para cada nome de elemento, valor de atributo e célula

A contagem de threads é o botão em que todo mundo pensa primeiro. Para código limitado por alocação, ela quase não muda nada. O que move a curva é o número de alocações de heap que cada célula custa

Como o HotXLS divide o Open em três fases

O HotXLS analisa as planilhas de um pacote XLSX com várias planilhas em worker threads por padrão. TXLSXWorkbook.ParallelParse começa em True, e ParallelParseThreads começa em 0, o que significa uma worker por processador lógico que o sistema operacional reportar, nunca mais workers do que planilhas a analisar. Só uma das três fases do Open roda nessas workers. A fase A é serial: ela lê o workbook part, as shared strings e os estilos, cria todas as planilhas com nome e visibilidade, e analisa o arquivo de relationships de cada planilha para que os alvos de hyperlinks e tabelas já estejam resolvidos. Quando uma worker começa, toda tabela de consulta de que ela precisa está completa e é somente leitura

A fase B entrega cada planilha a uma worker. As workers reivindicam índices de planilha de um contador compartilhado com um incremento interlocked, então uma pasta de trabalho com uma planilha grande e sete pequenas se equilibra sem um escalonador: quem termina uma planilha pequena simplesmente pega o próximo índice. O contêiner ZIP é a parte que não pode ser compartilhada de forma ingênua, porque um stream deflate carrega estado de um bloco para o outro e duas threads não podem avançar o mesmo descompressor. Cada worker portanto abre o seu próprio descompressor sobre a sua própria entrada de planilha e despeja o XML direto no seu próprio reader. O handle de arquivo é o único recurso compartilhado, e o lock em volta dele cobre um único seek-and-read de bytes compactados por vez. Descompressão e parsing rodam em paralelo, e o XML de nenhuma planilha fica inteiramente inflado na memória. Quando o parsing termina, a worker lê a sua entrada até o fim para que as checagens de tamanho e CRC do ZIP ainda rodem

A fase C volta a uma única thread para as partes que penduram em cada planilha: comentários e threaded comments, drawings e charts, tabelas e configurações de impressora. Na maioria das pastas de trabalho isso é pequeno perto do XML de células

Diagrama da carga XLSX em três fases do HotXLS no Delphi: configuração serial de planilhas e relationships, parsing de planilhas em paralelo equilibrado entre um pool de workers em que cada worker descomprime e analisa a sua própria entrada de planilha, e depois leituras serializadas de comentários, drawings, charts e tabelas
Só a fase do meio roda nas workers; cada worker descomprime e analisa a sua própria entrada de planilha, e só as leituras brutas do arquivo compartilhado revezam

Os erros voltam na thread chamadora. Quando uma planilha levanta exceção durante o parsing, o pool para de distribuir índices novos, espera as workers que ainda estão rodando e então relança a partir do Open a exceção da planilha de menor número que falhou, para que o relato siga a ordem das planilhas e quem chamou nunca precise lidar com uma exceção escapando de uma worker thread. Com RecoveryMode em True, a planilha que falha no parsing é simplesmente pulada, um aviso cai em Diagnostics e as planilhas restantes carregam normalmente. Definir ParallelParse como False roda o mesmo parser sobre as planilhas uma a uma e produz resultados idênticos

var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    // Os dois valores são os padrões; escrevê-los explícitos mantém a
    // escolha visível na revisão de código
    Book.ParallelParse := True;
    Book.ParallelParseThreads := 0;  // 0 = uma worker por CPU lógico, limitado ao número de planilhas
    Book.RecoveryMode := False;      // planilha que falha no parsing levanta exceção no Open
    if Book.Open('quarterly-ledger.xlsx') <> 1 then
      raise Exception.Create('open failed');
    // todas as planilhas estão totalmente carregadas aqui; leia células como de costume
  finally
    Book.Free;
  end;
end;

Por que threads extras deixam um parser denso em alocações mais lento?

O parsing de planilhas é feito em grande parte de alocações pequenas, e o memory manager padrão do Delphi faz as threads revezarem nelas. Um leitor de XML ingênuo produz uma string para cada nome de elemento, outra para cada nome e valor de atributo, um Variant para a célula e uma string para o texto dela. O memory manager padrão guarda blocos pequenos em pools agrupados por tamanho e protege cada pool com um lock. Uma thread que encontra o lock ocupado recua e dorme antes de tentar de novo. Quando oito workers pedem ao mesmo tempo o mesmo punhado de tamanhos minúsculos, elas ficam colidindo nos mesmos pools, e threads que pareciam independentes no código acabam rodando uma depois da outra

Isso explica os dois sintomas da abertura. O tempo de CPU fica perto do tempo de relógio porque thread dormindo não queima CPU, e o varredura de threads fica plana porque são os locks dos pools, não os núcleos, que ditam o ritmo. Duas threads podem perder feio para uma: cada alocação agora paga a ida e volta de um lock entre núcleos, enquanto o loop serial nunca contende

Diagrama de worker threads do Delphi na fila dos locks compartilhados de blocos pequenos do memory manager durante o parsing paralelo de XLSX, com caixas de evidência mostrando varredura de threads plana, churn de alocações escalando ao contrário e tempo de CPU próximo do tempo de relógio
Toda alocação pequena passa pela contabilidade compartilhada do memory manager, então workers que pareciam independentes no código passam boa parte do tempo esperando umas pelas outras

Um tipo de string fica fora disso no Windows. A WideString é uma COM BSTR, alocada pelo alocador de strings OLE do sistema em vez do memory manager do Delphi, então o tráfego de WideString nunca entra na fila dos pools do Delphi. O HotXLS guarda o texto de células como WideString, o que importa mais para o carregamento paralelo do que nunca importou para o caminho serial

Medindo a contenção nas suas próprias pastas de trabalho

Dois números dizem se uma carga é limitada por alocação: como o tempo de relógio muda quando a contagem de workers sobe, e quanto de CPU o processo consumiu no mesmo intervalo. Se o tempo de CPU dividido pelo tempo de relógio fica perto de 1.0 com oito workers nominalmente ocupadas, elas estão na fila em vez de analisar. A varredura abaixo abre o mesmo arquivo com uma a oito workers e imprime os dois números. É um harness de medição para o seu próprio projeto de teste; só os membros de TXLSXWorkbook vêm do HotXLS

uses
  Winapi.Windows, System.SysUtils, System.Math, System.Diagnostics;

// Seu próprio helper: tempo de CPU de usuário + kernel deste processo, em milissegundos
function ProcessCpuMs: Int64;
var
  Created, Exited, Kernel, User: TFileTime;
begin
  GetProcessTimes(GetCurrentProcess, Created, Exited, Kernel, User);
  Result := (Int64(Kernel) + Int64(User)) div 10000;  // ticks de 100 ns para ms
end;

procedure SweepThreads(const FileName: string);
var
  N: Integer;
  Book: TXLSXWorkbook;
  SW: TStopwatch;
  Cpu0, Cpu: Int64;
begin
  for N := 1 to 8 do
  begin
    Book := TXLSXWorkbook.Create;
    try
      Book.ParallelParseThreads := N;  // 1 roda o loop serial simples
      Cpu0 := ProcessCpuMs;
      SW := TStopwatch.StartNew;
      if Book.Open(FileName) <> 1 then
        raise Exception.CreateFmt('open failed: %s', [FileName]);
      SW.Stop;
      Cpu := ProcessCpuMs - Cpu0;
      Writeln(Format('%d workers: %d ms wall, CPU/wall %.2f',
        [N, SW.ElapsedMilliseconds, Cpu / Max(Int64(1), SW.ElapsedMilliseconds)]));
    finally
      Book.Free;
    end;
  end;
end;

Rode a varredura várias vezes e guarde a melhor marca de cada contagem de workers, porque a primeira rodada também paga um cache de disco frio. Uma curva de tempo de relógio plana com CPU/wall perto de 1 significa que o memory manager é o teto. Se o tempo de relógio segue caindo enquanto o CPU/wall sobe em direção à contagem de workers, o arquivo é limitado pelo parsing e as workers extras estão justificadas

Uma curva plana leva à próxima pergunta: quais alocações são as culpadas? Um wrapper de memory manager que conta chamadas por tamanho responde isso em poucos minutos, sem profiler. A versão abaixo só conta o GetMem e deixa FreeMem e ReallocMem apontando para o manager original, o que basta para ver de onde vem o tráfego

// Diagnóstico que você adiciona ao seu próprio harness de teste; não faz parte do HotXLS
var
  OldMM, NewMM: TMemoryManagerEx;
  AllocCount, TinyCount: Int64;

function CountingGetMem(Size: NativeInt): Pointer;
begin
  AtomicIncrement(AllocCount);
  if Size <= 32 then
    AtomicIncrement(TinyCount);  // o churn de blocos pequenos que vale vigiar
  Result := OldMM.GetMem(Size);
end;

procedure InstallCounter;
begin
  GetMemoryManager(OldMM);
  NewMM := OldMM;
  NewMM.GetMem := CountingGetMem;
  SetMemoryManager(NewMM);
end;

procedure RemoveCounter;
begin
  SetMemoryManager(OldMM);
end;

Instale o contador logo antes do Open, remova-o logo depois e divida o AllocCount pelo número de células do arquivo. Esse número por célula é o que se acompanha de build para build, e a fatia de blocos de 32 bytes ou menos mostra se strings curtas dominam. Confira antes de escrever um pool de objetos de célula: cada objeto de célula é uma alocação, e as strings de vida curta criadas enquanto a célula é analisada podem ultrapassá-lo várias vezes

Onde as alocações se escondem no XML de planilha

Uma célula como <c r="B7" s="3" t="s"><v>42</v></c> parece minúscula no disco. Um leitor direto ainda a transforma em uma sequência de strings novas: os nomes de elemento c e v, três nomes de atributo, três valores de atributo e o conteúdo de texto. Converter cada token UTF-8 pela RTL adiciona um UnicodeString intermediário antes de a WideString final existir. Nenhuma dessas strings sobrevive à célula, e cada uma delas é uma viagem pelo memory manager

O leitor de XML do HotXLS ataca as duas maiores fontes. Os nomes de elemento no XML de planilha vêm de um vocabulário muito pequeno (row, c, v, f, is), então o leitor mantém um cache curto dos nomes que já viu, compara os bytes brutos de cada nome novo contra esse cache e devolve a string em cache em caso de match. As cópias em cache são deliberadamente AnsiString. AnsiString tem contagem de referências, então entregar uma instância em cache custa um incremento de contador e nenhuma alocação. Um cache de nomes em WideString não compraria nada: WideString não tem contagem de referências, e toda atribuição faz uma nova alocação no sistema

Nomes de atributo, valores de atributo e texto de célula seguem o outro caminho. O leitor decodifica UTF-8 direto do buffer de varredura em duas passadas: a primeira conta unidades de código UTF-16, a segunda preenche uma WideString alocada uma única vez com exatamente aquele comprimento. É uma alocação por token, e ela cai no alocador de strings do sistema em vez dos pools do Delphi. Referências de caractere como &#x41; e as entidades predefinidas são resolvidas pelo scanner antes de a decodificação começar, então o decodificador só vê UTF-8 simples. Para sequências de bytes que não são UTF-8 válido, o decodificador copia os bytes problemáticos um a um, onde a conversão da RTL descartaria ou substituiria, então um arquivo danificado ainda produz ASCII legível em volta do ponto ruim. Entrada válida decodifica para o mesmo texto dos dois jeitos

As duas manobras se transferem para o seu próprio código de parsing em Delphi. Cachear strings só economiza alocações quando o tipo de string tem contagem de referências, e decodificar direto para o tipo de destino elimina a temporária que as funções de conversão convenientes da RTL criam a cada chamada

Quais pastas de trabalho ganham, e quais configurações escolher

O parsing paralelo funciona na granularidade de planilha, então o formato da pasta de trabalho decide a maior parte do resultado. Várias planilhas de tamanho comparável são o melhor caso, inclusive os arquivos que você obtém ao duplicar uma planilha modelo por região ou por mês. Uma pasta de trabalho que é uma planilha gigante única analisa em uma worker, diga o que disser a ParallelParseThreads; para esse formato o streaming direct reader encaixa melhor, porque nunca constrói a pasta de trabalho inteira na memória. O tempo gasto com comentários, charts e drawings fica na fase C serial. Um arquivo com zero ou uma planilha a analisar pula o pool e roda o loop serial simples

Quando só algumas planilhas interessam, liste os nomes delas em SelectedSheets antes de chamar o Open. As outras planilhas ainda são criadas com nome e visibilidade, mas sem células, as workers passam por elas, e a LoadSheet preenche uma delas depois, se o usuário abrir

Diagrama da redução de alocações do HotXLS ao cachear nomes de elemento e decodificar UTF-8 diretamente, ao lado dos formatos de pasta de trabalho em que o parsing paralelo ainda não ajuda: uma planilha gigante, partes satélites serializadas e arquivos pequenos
Menos alocações por célula é o que faz workers extras valerem a pena, enquanto pastas de trabalho de planilha única e as partes satélites serializadas mantêm os seus limites

Deixe o ParallelParse ligado em ferramentas de desktop e jobs em lote que abrem uma pasta de trabalho por vez. Esse padrão é o mais seguro: os resultados batem com o caminho serial, e uma propriedade desliga tudo se uma pergunta sobre threading surgir. Um servidor que já abre várias pastas de trabalho concorrentemente é outro caso. Toda thread de requisição também está alocando, então cada worker de parsing extra adiciona mais um contender para os mesmos pools do memory manager; defina ParallelParseThreads como 2 ali, e suba só depois de a varredura acima, rodada naquele servidor sob a carga normal dele, mostrar as workers extras se pagando. Menos alocações por célula sobem o teto sem removê-lo. Objetos de célula e o crescimento dos contêineres ainda passam pelos pools do Delphi, e é por isso que o ganho de oito workers fica bem abaixo de oito vezes. Para o resto do toolkit de load e save, da reutilização de estilos a callbacks de linhas em massa, veja o guia de desempenho com pastas de trabalho grandes no Delphi

O pool de workers, as chaves ParallelParse e ParallelParseThreads e o leitor de XML enxuto em alocações vêm todos no HotXLS Delphi Excel Component, que lê e escreve XLS, XLSX e ODS diretamente de código Delphi e C++Builder sem Excel instalado na máquina