Un cargador en Delphi que analiza un paquete XLSX de ocho hojas con ocho hilos de trabajo puede mostrar una gráfica de CPU que apenas supera un núcleo, y barrer el número de hilos de dos a ocho deja el cronómetro casi donde estaba. Con dos hilos la carga incluso puede salir más lenta que un bucle serial simple. El código de análisis no toma ningún bloqueo propio y las hojas no comparten datos, así que la espera ocurre en un lugar que el código fuente nunca menciona: dentro del gestor de memoria, al que cada uno de esos trabajadores llama por cada nombre de elemento, valor de atributo y celda
El número de hilos es el control que todos mueven primero. Para código limitado por asignaciones casi no mueve nada. Lo que mueve la curva es el número de asignaciones de heap que cuesta cada celda
Cómo HotXLS divide Open en tres fases
HotXLS analiza por defecto las hojas de cálculo de un paquete XLSX de varias hojas en hilos de trabajo. TXLSXWorkbook.ParallelParse empieza en True y ParallelParseThreads empieza en 0, lo que significa un trabajador por procesador lógico que el sistema operativo reporte, nunca más trabajadores que hojas por analizar. Solo una de las tres fases de Open corre en esos trabajadores. La fase A es serial: lee la parte del libro, las cadenas compartidas y los estilos, crea cada hoja con su nombre y visibilidad, y analiza el archivo de relaciones de cada hoja para que los destinos de hipervínculos y tablas queden resueltos. Cuando un trabajador arranca, cada tabla de búsqueda que consulta está completa y solo se lee
La fase B le entrega cada hoja de cálculo a un trabajador. Los trabajadores reclaman índices de hoja de un contador compartido con un incremento interlocked, así que un libro con una hoja grande y siete pequeñas se balancea solo, sin planificador: quien termina una hoja pequeña simplemente toma el siguiente índice. El contenedor ZIP es la parte que no se puede compartir de forma ingenua, porque un flujo deflate carga estado de un bloque al siguiente y dos hilos no pueden avanzar el mismo descompresor. Cada trabajador abre entonces su propio descompresor sobre su propia entrada de hoja y pasa el XML directo a su propio lector. El manejador del archivo es el único recurso compartido, y el bloqueo a su alrededor cubre una sola lectura con seek de bytes comprimidos a la vez. Descompresión y análisis corren en paralelo, y el XML de ninguna hoja queda nunca completamente inflado en memoria. Al terminar el análisis, el trabajador lee su entrada hasta el final para que las verificaciones de tamaño y CRC del ZIP se ejecuten igual
La fase C vuelve a un solo hilo para las partes que cuelgan de cada hoja: comentarios y comentarios encadenados, dibujos y gráficos, tablas y configuración de impresión. En la mayoría de los libros esto es pequeño junto al XML de celdas
Los errores regresan al hilo llamador. Cuando una hoja lanza una excepción durante el análisis, el pool deja de entregar índices nuevos, espera a los trabajadores que siguen corriendo y luego relanza desde Open la excepción de la hoja con el número más bajo que falló, de modo que el reporte sigue el orden de las hojas y quien llama nunca tiene que lidiar con una excepción escapando de un hilo de trabajo. Con RecoveryMode en True, una hoja que falla al analizarse se salta, un aviso cae en Diagnostics y las hojas restantes cargan con normalidad. Poner ParallelParse en False ejecuta el mismo parser sobre las hojas una por una y produce resultados idénticos
var
Book: TXLSXWorkbook;
begin
Book := TXLSXWorkbook.Create;
try
// Ambos valores son los de fábrica; escribirlos explícitos mantiene la
// elección visible en la revisión de código
Book.ParallelParse := True;
Book.ParallelParseThreads := 0; // 0 = un trabajador por CPU lógica, con tope en el número de hojas
Book.RecoveryMode := False; // una hoja que falla al parsearse lanza la excepción desde Open
if Book.Open('quarterly-ledger.xlsx') <> 1 then
raise Exception.Create('open failed');
// aquí todas las hojas están cargadas; lea las celdas como siempre
finally
Book.Free;
end;
end;
¿Por qué los hilos extra vuelven más lento un parser denso en asignaciones?
El análisis de hojas de cálculo es en su mayoría asignaciones pequeñas, y el gestor de memoria por defecto de Delphi hace que los hilos turnen sobre ellas. Un lector XML ingenuo produce una cadena por cada nombre de elemento, otra por cada nombre y valor de atributo, un Variant para la celda y una cadena para su texto. El gestor de memoria por defecto guarda los bloques pequeños en pools agrupados por tamaño y protege cada pool con un bloqueo. Un hilo que encuentra el bloqueo tomado retrocede y duerme antes de reintentar. Cuando ocho trabajadores piden los mismos tamaños diminutos, chocan una y otra vez en los mismos pools, y los hilos que se ven independientes en el código terminan corriendo uno tras otro
Eso explica ambos síntomas del arranque. El tiempo de CPU se queda cerca del tiempo de reloj porque un hilo dormido no quema CPU, y el barrido de hilos se mantiene plano porque el ritmo lo marcan los bloqueos del pool, no los núcleos. Dos hilos pueden perder de forma descarada contra uno: cada asignación ahora paga el pasar un bloqueo de un núcleo a otro, mientras que el bucle serial nunca contiende
Un tipo de cadena queda fuera de esto en Windows. Un WideString es un BSTR de COM, asignado por el asignador de cadenas OLE del sistema y no por el gestor de memoria de Delphi, así que el tráfico de WideString nunca hace fila en los pools de Delphi. HotXLS guarda el texto de las celdas como WideString, lo que importa más para la carga paralela de lo que nunca importó para la ruta serial
Medir la contención en sus propios libros
Dos números le dicen si una carga está limitada por asignaciones: cómo cambia el tiempo de reloj cuando sube el número de trabajadores y cuánta CPU consumió el proceso en el mismo intervalo. Si el tiempo de CPU dividido por el tiempo de reloj se queda cerca de 1.0 con ocho trabajadores nominalmente ocupados, están haciendo fila en vez de analizar. El barrido de abajo abre el mismo archivo con uno a ocho trabajadores e imprime ambas cifras. Es un arnés de medición para su propio proyecto de pruebas; solo los miembros de TXLSXWorkbook vienen de HotXLS
uses
Winapi.Windows, System.SysUtils, System.Math, System.Diagnostics;
// Ayudante propio: tiempo de CPU de usuario + kernel de este proceso, en milisegundos
function ProcessCpuMs: Int64;
var
Created, Exited, Kernel, User: TFileTime;
begin
GetProcessTimes(GetCurrentProcess, Created, Exited, Kernel, User);
Result := (Int64(Kernel) + Int64(User)) div 10000; // tics de 100 ns a 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 ejecuta el bucle serial simple
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;
Ejecute el barrido varias veces y quédese con la mejor cifra por número de trabajadores, porque la primera corrida también paga una caché de disco fría. Una curva de tiempo de reloj plana con CPU/reloj cerca de 1 significa que el gestor de memoria es el techo. Si el tiempo de reloj sigue bajando mientras CPU/reloj sube hacia el número de trabajadores, el archivo está limitado por el análisis y los trabajadores extra se están ganando su lugar
Una curva plana lleva a la siguiente pregunta: ¿qué asignaciones son las responsables? Un envoltorio del gestor de memoria que cuente llamadas por tamaño responde eso en pocos minutos y sin profiler. La versión de abajo solo cuenta GetMem y deja FreeMem y ReallocMem apuntando al gestor original, que alcanza para ver de dónde viene el tráfico
// Diagnóstico que usted agrega a su propio arnés de pruebas; no es parte de HotXLS
var
OldMM, NewMM: TMemoryManagerEx;
AllocCount, TinyCount: Int64;
function CountingGetMem(Size: NativeInt): Pointer;
begin
AtomicIncrement(AllocCount);
if Size <= 32 then
AtomicIncrement(TinyCount); // la rotación de bloques pequeños que vale la pena vigilar
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 el contador justo antes de Open, quítelo justo después y divida AllocCount entre el número de celdas del archivo. Esa cifra por celda es la que se sigue de build en build, y la proporción de bloques de 32 bytes o menos muestra si dominan las cadenas cortas. Revísela antes de escribir un pool de objetos de celda: cada objeto de celda es una asignación, y las cadenas de vida corta que se crean mientras esa celda se analiza pueden superar varias veces ese número
Dónde se esconden las asignaciones en el XML de hojas de cálculo
Una celda como <c r="B7" s="3" t="s"><v>42</v></c> se ve diminuta en el disco. Un lector directo todavía la convierte en una racha de cadenas nuevas: los nombres de elemento c y v, tres nombres de atributo, tres valores de atributo y el contenido de texto. Convertir cada token UTF-8 por la RTL agrega un UnicodeString intermedio antes de que exista el WideString final. Ninguna de esas cadenas sobrevive a la celda, y cada una es un viaje por el gestor de memoria
El lector XML de HotXLS ataca las dos fuentes más grandes. Los nombres de elemento en el XML de hoja de cálculo salen de un vocabulario muy pequeño (row, c, v, f, is), así que el lector mantiene una caché corta de nombres ya vistos, compara los bytes crudos de cada nombre nuevo contra esa caché y devuelve la cadena cacheada si coincide. Las copias cacheadas son deliberadamente AnsiString. AnsiString lleva conteo de referencias, así que entregar una instancia cacheada cuesta un incremento de contador y ninguna asignación. Una caché de nombres WideString no compraría nada: WideString no tiene conteo de referencias y cada asignación hace una nueva asignación del sistema
Los nombres de atributo, los valores de atributo y el texto de las celdas toman la otra ruta. El lector decodifica UTF-8 directo desde su búfer de escaneo en dos pasadas: la primera cuenta unidades de código UTF-16, la segunda llena un WideString asignado una sola vez con exactamente esa longitud. Es una asignación por token, y cae en el asignador de cadenas del sistema en lugar de los pools de Delphi. Las referencias de caracteres como A y las entidades predefinidas las resuelve el escáner antes de que empiece la decodificación, así que el decodificador solo ve UTF-8 plano. Para secuencias de bytes que no son UTF-8 válido, el decodificador copia los bytes ofensivos uno a uno donde la conversión de la RTL los soltaría o reemplazaría, así que un archivo dañado todavía produce ASCII legible alrededor del punto malo. Una entrada válida decodifica al mismo texto de cualquier forma
Ambos movimientos se trasladan a su propio código de análisis en Delphi. Cachear cadenas solo ahorra asignaciones cuando el tipo de cadena lleva conteo de referencias, y decodificar directo al tipo de destino elimina el temporal que las funciones de conversión convenientes de la RTL crean en cada llamada
Qué libros ganan y qué ajustes elegir
El análisis paralelo trabaja a granularidad de hoja de cálculo, así que la forma del libro decide la mayor parte del resultado. Varias hojas de tamaño comparable son el mejor caso, incluidos los archivos que se obtienen al duplicar una hoja de plantilla por región o por mes. Un libro que es una sola hoja gigante se analiza en un trabajador, diga lo que diga ParallelParseThreads; para esa forma encaja mejor el lector directo en streaming, porque nunca construye el libro completo en memoria. El tiempo invertido en comentarios, gráficos y dibujos se queda en la fase C serial. Un archivo con cero o una hoja por analizar se salta el pool y ejecuta el bucle serial simple
Cuando solo importan algunas hojas, liste sus nombres en SelectedSheets antes de llamar a Open. Las demás hojas igual se crean con su nombre y visibilidad pero sin celdas, los trabajadores las pasan por alto y LoadSheet llena una después si el usuario la abre
Deje ParallelParse activado para herramientas de escritorio y trabajos por lotes que abren un libro a la vez. Ese valor por defecto es el más seguro: los resultados coinciden con la ruta serial y una propiedad lo apaga si alguna vez surge una pregunta de hilos. Un servidor que ya abre varios libros a la vez es otra historia. Cada hilo de petición también asigna, así que cada trabajador de análisis extra agrega otro contendiente para los mismos pools del gestor de memoria; ponga ParallelParseThreads en 2 ahí, y súbalo solo después de que el barrido de arriba, corrido en ese servidor bajo su carga normal, muestre que los trabajadores extra se pagan solos. Menos asignaciones por celda suben el techo sin eliminarlo. Los objetos de celda y el crecimiento de contenedores siguen pasando por los pools de Delphi, y por eso la ganancia con ocho trabajadores se queda muy por debajo de ocho veces. Para el resto del kit de carga y guardado, desde reutilización de estilos hasta callbacks de filas en lote, vea la guía de rendimiento con libros grandes en Delphi
El pool de trabajadores, los interruptores ParallelParse y ParallelParseThreads y el lector XML ligero en asignaciones se distribuyen como partes estándar del HotXLS Delphi Excel Component, que lee y escribe XLS, XLSX y ODS directo desde código Delphi y C++Builder sin Excel instalado en la máquina