> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Procesamiento en paralelo en Windows
> Ejecute el procesamiento en paralelo de ABBYY FineReader Engine en Windows con MultiProcessingParams, BatchProcessor o un grupo de instancias de OutprocLoader cargadas como servidores fuera del proceso.
Básicamente, hay tres formas de usar el multiprocesamiento con ABBYY FineReader Engine:
Por un lado, puede usar un objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface) y establecer la propiedad [MultiProcessingParams](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/properties#multiprocessingparams) del objeto Engine con los valores adecuados.
ABBYY FineReader Engine admite dos objetos distintos que proporcionan multiprocesamiento desde una única instancia de Engine. Se trata del objeto [FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument) (consulte [Procesamiento con el objeto FRDocument](/es/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing/parallel-processing-in-windows#frdocument)) y del objeto [BatchProcessor](/es/fine-reader/engine/api-reference/batch-processor/batchprocessor) (consulte [Procesamiento con Batch Processor](/es/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing/parallel-processing-in-windows#batchprocessor)).
Por otro lado, puede cargar varias instancias de Engine como servidores fuera del proceso mediante COM (usando el objeto [OutprocLoader](/es/fine-reader/engine/api-reference/engine-loaders/outprocloader)) y usar cada instancia en su propio proceso. Consulte [Procesamiento mediante un grupo de Engines](/es/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing/parallel-processing-in-windows#outprocloader).
Tenga en cuenta que el procesamiento en paralelo requiere más RAM que el procesamiento secuencial. La recomendación general para una estación de trabajo es 350 MB \* (número de núcleos) + 450 MB de RAM y, si procesa documentos en árabe o en [idiomas CJK](/es/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk), 850 MB \* (número de núcleos) + 750 MB de RAM.
## Escenarios de uso
Daremos por sentado que está procesando muchos documentos. Pero también debemos tener en cuenta los resultados que necesita obtener y elegir la mejor forma de implementar su tarea. Los distintos escenarios que se deben considerar son:
* Convertir documentos multipágina con una gran cantidad de páginas. Por lo general, esto significa procesar libros, informes extensos, etc. En este caso, puede reconocer las páginas del documento en paralelo, luego realizar la síntesis en el proceso principal y volver a exportar en paralelo. También puede, al usar un grupo de Engines, procesar varios documentos multipágina simultáneamente, pero el consumo de memoria puede ser enorme e incluso provocar errores de "memoria insuficiente".
* Convertir una gran cantidad de documentos de una sola página. Este es el caso cuando procesa facturas, contratos, cartas, etc. El procesamiento en paralelo es lo más sencillo en esta situación, ya que los documentos de una sola página no dependen unos de otros y no requieren grandes cantidades de memoria al mismo tiempo.
* Procesar una gran cantidad de imágenes y buscar en ellas la información necesaria, o trabajar con los resultados del reconocimiento de alguna otra forma. Es posible que no necesite convertir la mayoría a un formato editable, por lo que la velocidad de la síntesis y la exportación no supone un problema. La operación que se realizará en varios procesos consiste en iterar por los bloques del layout y acceder a los resultados de reconocimiento de los bloques de texto.
Si quiere utilizar el procesamiento en paralelo para la exportación, tenga en cuenta que esta función solo es compatible con la exportación a los formatos PDF (excepto el modo TextOnly) y PPTX.
## Recomendaciones y restricciones
* Para el procesamiento en paralelo de documentos de varias páginas, recomendamos usar FRDocument. Es la forma más fácil de implementar el multiprocesamiento, ya que no tiene que implementar interfaces adicionales.
La apertura, el preprocesamiento, el análisis y el reconocimiento se realizan en paralelo; la síntesis del documento se realiza de forma secuencial en el proceso principal y, a continuación, la exportación a PDF (excepto en el modo TextOnly) y a formatos PPTX se realiza en paralelo.
* Para procesar muchos documentos de una sola página que se reciben desde alguna fuente (como un escáner), recomendamos BatchProcessor.
La ventaja de este método es que puede utilizarse cuando no se conoce de antemano el número de documentos; estos pueden ser de distintos tipos y deben procesarse directamente a medida que llegan. La desventaja es que requiere más esfuerzo de implementación: tiene que implementar interfaces para un adaptador de archivos y una fuente de imágenes personalizada.
Todas las etapas del procesamiento se realizan en paralelo porque, en el caso de los documentos de una sola página, la síntesis de la página y del documento se realiza por separado para cada página.
La exportación en paralelo no es compatible en escenarios con BatchProcessor.
* Para realizar el procesamiento completo en paralelo de muchos documentos de una sola página, puede usar un grupo de Engines cargados fuera del proceso mediante COM. Este método es el más eficiente en términos de velocidad y elimina automáticamente todas las dificultades relacionadas con el multihilo: todas las operaciones con los objetos de ABBYY FineReader Engine se serializan mediante COM. Pero tiene algunas limitaciones:
* debido al uso de COM, necesita registrar FREngine.dll;
* si su código está escrito en C++, trabajar con COM requiere más código repetitivo que, por ejemplo, en C#;
* en este caso, el procesamiento se realiza en otro proceso, por lo que no puede abrir imágenes desde la memoria, y recorrer los resultados del reconocimiento lleva más tiempo porque cada solicitud tiene que enviarse a otro proceso y volver;
* y, por último, cargar varias instancias de Engine implica un mayor consumo de memoria, especialmente porque, en este caso, todas las etapas de procesamiento se realizan en paralelo y pueden ejecutarse varias operaciones de síntesis simultáneamente, lo que consume aún más memoria.
* Para capturar y controlar los eventos que se producen durante el procesamiento en paralelo, puede usar la interfaz [IParallelProcessingCallback](/es/fine-reader/engine/api-reference/supplementary-objects-and-methods/iparallelprocessingcallback). Esta interfaz puede ser muy útil para gestionar situaciones problemáticas. Por ejemplo, cuando se produce un error de tiempo de espera, la interfaz [IParallelProcessingCallback](/es/fine-reader/engine/api-reference/supplementary-objects-and-methods/iparallelprocessingcallback) ofrece varias soluciones al problema según las preferencias del usuario. Para obtener más información, consulte [IParallelProcessingCallback::OnWaitIntervalExceeded](/es/fine-reader/engine/api-reference/supplementary-objects-and-methods/iparallelprocessingcallback/onwaitintervalexceeded-method).
Los eventos que se producen durante el procesamiento en paralelo de una página se convierten en eventos del documento completo.
## Resultados de las pruebas de velocidad
En la tabla siguiente se presentan los resultados de las pruebas de rendimiento.
| | Documentos de una página | Un documento de varias páginas | Búsqueda en los resultados sin exportarlos |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------ | ------------------------------ | ------------------------------------------ |
| Procesamiento secuencial | 60 | 51 | 87 |
| Procesamiento con FRDocument | 41 | 117 | 57 |
| Procesamiento con FRDocument (con [PageFlushingPolicy](/es/fine-reader/engine/api-reference/document-related-objects/frdocument#pageflushingpolicy) = PFP\_KeepInMemory) | 55 | 141 | 82 |
| Procesamiento con Batch Processor | 99 | 115 | 294 |
| Procesamiento mediante un grupo de Engines | 165 | 10 | 102 |
La máquina de prueba tiene un procesador Intel® Core™ i5-4440 (3.10 GHz, 4 núcleos físicos), 8 GB de RAM y el número de procesos que se ejecutan simultáneamente es 4. El rendimiento se probó en 300 imágenes en inglés, con la configuración del perfil predefinido [DocumentArchiving\_Speed](/es/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles#documentarchiving_speed). Los valores de la tabla indican las páginas procesadas por minuto. En los escenarios "documentos de una página" y "un documento de varias páginas", los documentos se exportan a formato PDF.
## Procesamiento con el objeto FRDocument
El número de procesos que se van a ejecutar se detecta automáticamente en función del número de núcleos físicos o lógicos de CPU disponibles, del número de núcleos de CPU libres permitidos por la licencia y del número de páginas del documento. Para activar el modo de multiprocesamiento, haga lo siguiente:
1. Establezca el valor de la propiedad MultiProcessingMode del subobjeto [MultiProcessingParams](/es/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) del objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/properties#multiprocessingparams). El procesamiento en paralelo se utiliza si esta propiedad está establecida en MPM\_Parallel o MPM\_Auto, y si tanto el número de páginas del documento como el número de núcleos de CPU disponibles son mayores que uno.
2. Ajuste el número de procesos que se ejecutarán mediante la propiedad RecognitionProcessesCount y, si es necesario, especifique los valores de otras propiedades.
Después de configurar los parámetros de multiprocesamiento, puede utilizar el procedimiento estándar para trabajar con [FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument). ABBYY FineReader Engine iniciará automáticamente varios procesos de reconocimiento cuando llame a uno de los siguientes métodos del objeto FRDocument:
* [AddImageFile](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefile-method), [AddImageFileFromMemory](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilefrommemory-method), [AddImageFileFromStream](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilefromstream-method), [AddImageFileWithPassword](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpassword-method), [AddImageFileWithPasswordCallback](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpasswordcallback-method)
* [Preprocess](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/preprocess-method), [PreprocessPages](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/preprocesspages-method)
* [Analyze](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/analyze-method), [AnalyzePages](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/analyzepages-method)
* [Recognize](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method), [RecognizePages](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/recognizepages-method)
* [Process](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method), [ProcessPages](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/processpages-method)
* [Export](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method), [ExportPages](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/exportpages-method), [ExportToMemory](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/exporttomemory-method) — solo para exportar a PDF (excepto en modo TextOnly) y a formatos PPTX
Para cada página del documento, se crea una nueva tarea de procesamiento y esta tarea se asigna a uno de los procesos de reconocimiento. Cuando un proceso de reconocimiento completa la tarea, recibe la siguiente tarea de procesamiento. Esto continúa hasta que se procesan todas las tareas.
```csharp theme={null}
// Crear el documento
FREngine.IFRDocument document = engine.CreateFRDocument();
// Agregar páginas al documento
for( int index = 0; index < filesNumber; index++ ) {
string imagePath = filePaths[index];
document.AddImageFile( imagePath, null, null );
}
// Configurar los parámetros de multiprocesamiento
engine.MultiProcessingParams.MultiProcessingMode = FREngine.MultiProcessingModeEnum.MPM_Parallel;
engine.MultiProcessingParams.RecognitionProcessesCount = coresNumber;
// Crear y configurar los parámetros de procesamiento del documento
FREngine.IDocumentProcessingParams documentProcessingParams = engine.CreateDocumentProcessingParams();
...
// Procesar el documento
document.Process( documentProcessingParams );
// Sintetizar y exportar el documento como de costumbre, trabajar con los resultados, etc.
...
```
El paquete de distribución de ABBYY FineReader Engine incluye la herramienta de demostración [MultiProcessingRecognition](/es/fine-reader/engine/guided-tour/samples#multiprocessingrecognition), que muestra la mejora de velocidad al utilizar el reconocimiento con multiprocesamiento con el objeto FRDocument y contiene una implementación que puede usar para empezar a desarrollar su propia aplicación.
## Procesamiento con Batch Processor
Cuando se inicializa Batch Processor, se invocan y configuran procesos de reconocimiento asíncronos. A continuación, el procesador toma archivos de imagen de una fuente de imágenes personalizada. Para cada página del archivo de imagen, se crea una nueva tarea de procesamiento, que se asigna a uno de los procesos de reconocimiento. Si todas las tareas de un archivo ya se han enviado a procesamiento, pero no todos los procesos de reconocimiento están ocupados, se toma el siguiente archivo de imagen de la cola de imágenes del origen y se envía a procesamiento. Esto continúa hasta que la primera página de imagen se haya convertido y devuelto al usuario. Las páginas se devuelven al usuario en el orden en que se tomaron del origen de imágenes.
Para organizar el multiprocesamiento con Batch Processor, haga lo siguiente:
1. Implemente las interfaces [IImageSource](/es/fine-reader/engine/api-reference/batch-processor/iimagesource) e [IFileAdapter](/es/fine-reader/engine/api-reference/batch-processor/ifileadapter), que proporcionan acceso al origen de imágenes y a los archivos que contiene.
2. \[opcional] Implemente la interfaz [IAsyncProcessingCallback](/es/fine-reader/engine/api-reference/batch-processor/iasyncprocessingcallback) para controlar el procesamiento. Los métodos de esta interfaz le permiten gestionar errores y/o cancelar el procesamiento.
3. \[opcional] Configure el multiprocesamiento mediante el subobjeto [MultiProcessingParams](/es/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) del objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/properties#multiprocessingparams). Tenga en cuenta que no es necesario establecer la propiedad MultiProcessingMode, porque el procesamiento en paralelo se usa de forma predeterminada si trabaja con Batch Processor. Ajuste el número de procesos que se ejecutarán mediante la propiedad RecognitionProcessesCount y especifique los valores de otras propiedades, si es necesario.
4. Llame al método [CreateBatchProcessor](/es/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) del objeto Engine para obtener el objeto BatchProcessor.
5. Llame al método [Start](/es/fine-reader/engine/api-reference/batch-processor/batchprocessor/start-method) de este objeto para inicializar el procesador e invocar procesos de reconocimiento asíncronos. Puede especificar el origen de las imágenes y pasar las referencias a la interfaz IAsyncProcessingCallback y a los objetos de parámetros en la llamada a este método.
6. Llame al método GetNextProcessedPage en un bucle hasta que el método devuelva 0, lo que significa que no quedan más imágenes en el origen y que todas las imágenes procesadas ya se han devuelto al usuario.
La página devuelta por el método GetNextProcessedPage existe hasta la siguiente llamada a este método. Por lo tanto, si desea guardar esta página, debe hacerlo mediante los métodos del objeto [FRPage](/es/fine-reader/engine/api-reference/document-related-objects/frpage) o agregarla a un documento existente mediante el método [IFRDocument::AddPage](/es/fine-reader/engine/api-reference/document-related-objects/frdocument/addpage-method) ANTES de la siguiente llamada al método GetNextProcessedPage.
```csharp theme={null}
// Crear Batch Processor
FREngine.IBatchProcessor batchProcessor = engine.CreateBatchProcessor();
// Configurar parámetros de multiprocesamiento
engine.MultiProcessingParams.RecognitionProcessesCount = coresNumber;
// Inicializar el procesador
FREngine.IImageSource imageSource = new CImageSource; // la clase la implementa el usuario
batchProcessor.Start( imageSource, null, null, null );
// Iniciar el procesamiento
while( true ) {
FREngine.IFRPage page = batchProcessor.GetNextProcessedPage();
if( page == null ) {
break; // no hay más páginas, fin del trabajo
}
// hacer algo con la página
page.Synthesize( null );
page.Export("D:\\sample.pdf", FREngine.FileExportFormatEnum.FEF_PDF, null);
}
```
El paquete de distribución de ABBYY FineReader Engine incluye el ejemplo [BatchProcessing](/es/fine-reader/engine/guided-tour/samples#batchprocessing), que muestra cómo usar Batch Processor, y la herramienta de demostración [BatchProcessingRecognition](/es/fine-reader/engine/guided-tour/samples#batchprocessingrecognition), que muestra la mejora de velocidad al usar reconocimiento multiproceso con Batch Processor.
## Procesamiento con un grupo de Engines
En este escenario de multiprocesamiento, se usan varias instancias de Engine cargadas fuera del proceso. Dentro de cada hilo de trabajo, el procedimiento puede ser prácticamente el mismo que para el procesamiento en un solo hilo. Sin embargo, se recomienda implementar un origen de imágenes personalizado que distribuya las imágenes entre los hilos, utilizando algún tipo de objeto de sincronización para garantizar que cada imagen se procese exactamente una vez.
Para cargar el objeto [Engine](/es/fine-reader/engine/api-reference/engine-object-iengine-interface) fuera del proceso, use el objeto [OutprocLoader](/es/fine-reader/engine/api-reference/engine-loaders/outprocloader), que implementa la interfaz [IEngineLoader](/es/fine-reader/engine/api-reference/engine-loaders/iengineloader). Al usarlo con cuentas especiales, es posible que se requieran permisos para ejecutar OutprocLoader con dichas cuentas.
```csharp theme={null}
// Para cada hilo, cree un objeto OutprocLoader independiente y cargue una instancia de Engine
IEngineLoader engineLoader = new FREngine.OutprocLoader();
IEngine engine = engineLoader.InitializeEngine( customerProjectId, LicensePath, LicensePassword, "", "", false );
// Hemos obtenido Engine en un proceso independiente
try {
...
} finally {
engineLoader.ExplicitlyUnload(); // Podemos descargarlo cuando ya no sea necesario
engineLoader = null;
GC.Collect();
GC.WaitForPendingFinalizers();
}
```
Además, puede administrar la prioridad del proceso anfitrión y controlar si sigue activo mediante la interfaz [IHostProcessControl](/es/fine-reader/engine/api-reference/engine-loaders/ihostprocesscontrol).
* Los permisos de las cuentas se pueden configurar con la utilidad DCOM Config (ya sea escribiendo DCOMCNFG en la línea de comandos o seleccionando Control Panel > Administrative Tools > Component Services). En el árbol de la consola, ubique la carpeta Component Services > Computers > My Computer > DCOM Config, haga clic con el botón derecho en ABBYY FineReader Engine 12.5 Loader (Local Server) y haga clic en Properties. Se abrirá un cuadro de diálogo. Haga clic en la pestaña Security. En Launch Permissions, haga clic en Customize y, a continuación, haga clic en Edit para especificar las cuentas que pueden iniciar la aplicación.
Tenga en cuenta que, en un sistema operativo de 64 bits, la aplicación DCOM registrada está disponible en la consola MMC de 32 bits, que puede ejecutarse mediante la siguiente línea de comandos:
```
"mmc comexp.msc /32"
```
* Para registrar `FREngine.dll` al instalar la aplicación en un equipo del usuario final, utilice la utilidad `regsvr32`. Si usa un sistema operativo de 64 bits, se ejecutará de forma predeterminada la versión de 64 bits de `regsvr32`. Use la siguiente línea de comandos:
```csharp theme={null}
regsvr32 /s /n /i:"" ""
```
* Al implementar Engine como un servidor fuera del proceso, especifique el modo secuencial de procesamiento de documentos estableciendo la propiedad MultiProcessingMode del objeto [MultiProcessingParams](/es/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) en MPM\_Sequential.
El paquete de distribución de ABBYY FineReader Engine incluye el ejemplo [EnginesPool](/es/fine-reader/engine/guided-tour/samples#enginespool), que muestra el incremento de velocidad al usar un grupo de Engines y proporciona una implementación lista para usar que puede servir como punto de partida para su propia aplicación. Consulte el código fuente de este ejemplo para obtener más información sobre cómo implementar una fuente de imágenes personalizada, gestionar excepciones y controlar el uso de los núcleos de CPU.
## Consulte también
[FRDocument](/es/fine-reader/engine/api-reference/document-related-objects/frdocument)
[BatchProcessor](/es/fine-reader/engine/api-reference/batch-processor/batchprocessor)
[MultiProcessingParams](/es/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams)
[Recorrer las páginas del documento](/es/fine-reader/engine/guided-tour/advanced-techniques/iterating-document-pages)
[Diferentes formas de cargar el objeto Engine](/es/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine)
[Uso de ABBYY FineReader Engine en aplicaciones de servidor multihilo](/es/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/using-in-server-applications)