Parallel Processing in Windows

​

Usage scenarios

• Converting multi-page documents with a large number of pages. It generally means processing books, long reports, etc. In this case, you can recognize pages of the document in parallel, then perform synthesis in the main process and export in parallel again. You can also, when using a pool of Engines, process several multi-page documents simultaneously, but the memory consumption can be huge and even lead to “out of memory” errors.
• Converting a large number of one-page documents. This is the case when you process invoices, contracts, letters, etc. Parallel processing is easiest for this situation, as one-page documents do not depend on each other and do not require large amounts of memory at once.
• Processing a large number of images and searching them for a necessary information or working with recognition results in some other way. You might not need to convert most of them into an editable format, so the speed of synthesis and export is not an issue. The operation which will be performed in multiple processes is iterating through layout blocks and accessing the recognition results for text blocks.

​

Recommendations and restrictions

• For parallel processing of multi-page documents, we recommend using FRDocument. It is the most easy-to-code multiprocessing way because you do not have to implement any additional interfaces.
  Opening, preprocessing, analysis, and recognition are performed in parallel; document synthesis is performed sequentially in the main process and then export to PDF (except TextOnly mode), and PPTX formats is performed in parallel.
• To process many one-page documents which are received from some source (such as a scanner), we recommend BatchProcessor.
  The advantage of this method is that it can be used when you do not know in advance the number of documents they can be of different types and must be processed directly they arrive. The disadvantage is that it requires more implementation effort: you have to implement interfaces for a file adapter and a custom source of images.
  All processing stages are performed in parallel because in the case of one-page documents the page and document synthesis are performed for each page separately.

• To perform full processing of many one-page documents in parallel, you can use a pool of Engines loaded out-of-process by means of COM. This method is the most efficient in speed and automatically eliminates all difficulties related to multi-threading: all operations with the ABBYY FineReader Engine objects are serialized by means of COM. But it has some limitations:
• due to the use of COM, you need to register FREngine.dll;
• if your code is written in C++, working with COM requires more routine coding than, for example, in C#;
• in this case, the processing is going on in another process, so you cannot open images from memory, and iterating the recognition results takes more time because each request has to be passed into another process and back;
• and finally, loading several instances of Engine means more memory consumption, especially, as in this case, all processing stages are performed in parallel, and several simultaneous synthesis operations can go on at the same time, using up still more memory.
• To catch and handle the events that happened during the parallel processing, you can use the IParallelProcessingCallback interface. This interface can be very useful for managing problematic situations. For example, when the timeout error happens, the IParallelProcessingCallback interface provides several solutions to the problem depending on the user preferences. For more information, see IParallelProcessingCallback::OnWaitIntervalExceeded.

​

Speed testing results

​

Processing with FRDocument object

1. Set the value of the MultiProcessingMode property of the MultiProcessingParams subobject of the Engine object. Parallel processing is used if this property is set to MPM_Parallel or MPM_Auto, and the number of pages in the document and the number of available CPU cores are both greater than one.
2. Tune the number of processes to be run using the RecognitionProcessesCount property and specify the values of other properties, if necessary.

• AddImageFile, AddImageFileFromMemory, AddImageFileFromStream, AddImageFileWithPassword, AddImageFileWithPasswordCallback
• Preprocess, PreprocessPages
• Analyze, AnalyzePages
• Recognize, RecognizePages
• Process, ProcessPages
• Export, ExportPages, ExportToMemory — for export to PDF (except TextOnly mode) and PPTX formats only

// Create the document
FREngine.IFRDocument document = engine.CreateFRDocument();
// Add pages to the document
for( int index = 0; index < filesNumber; index++ ) {
    string imagePath = filePaths[index];
    document.AddImageFile( imagePath, null, null );
}
// Set up multiprocessing parameters
engine.MultiProcessingParams.MultiProcessingMode = FREngine.MultiProcessingModeEnum.MPM_Parallel;
engine.MultiProcessingParams.RecognitionProcessesCount = coresNumber;
// Create and set up document processing parameters
FREngine.IDocumentProcessingParams documentProcessingParams = engine.CreateDocumentProcessingParams();
...
// Process document
document.Process( documentProcessingParams );
// Synthesize and export document as usual, work with the results, etc.
...

​

Processing using Batch Processor

1. Implement the IImageSource and IFileAdapter interfaces, which provide access to the image source and files in it.
2. [optional] Implement the IAsyncProcessingCallback interface to manage the processing. The methods of this interface allow you to handle errors and/or cancel the processing.
3. [optional] Set up multiprocessing using the MultiProcessingParams subobject of the Engine object. Please note that there is no need to set the MultiProcessingMode property, because parallel processing is used by default if you work with Batch Processor. Tune the number of processes to be run using the RecognitionProcessesCount property and specify the values of other properties, if necessary.
4. Call the CreateBatchProcessor method of the Engine object, to receive the BatchProcessor object.
5. Call the Start method of this object to initialize the processor and invoke asynchronous recognition processes. You can specify the source of images, pass the references to the IAsyncProcessingCallback interface and parameters objects in the call to this method.
6. Call the GetNextProcessedPage method in a loop until the method returns 0, which means that there are no more images in the source and all the processed images have been returned to the user.

// Create Batch Processor
FREngine.IBatchProcessor batchProcessor = engine.CreateBatchProcessor();
// Set up multiprocessing parameters
engine.MultiProcessingParams.RecognitionProcessesCount = coresNumber;
// Initialize the processor
FREngine.IImageSource imageSource = new CImageSource; // the class is implemented by the user
batchProcessor.Start( imageSource, null, null, null );
// Start processing
while( true ) {
 FREngine.IFRPage page = batchProcessor.GetNextProcessedPage();
 if( page == null ) {
  break; // there are no more pages, end of the work
 }
 // do something with the page
 page.Synthesize( null );
 page.Export("D:\\sample.pdf", FREngine.FileExportFormatEnum.FEF_PDF, null);
}

​

Processing using a pool of Engines

// For each thread create a separate OutprocLoader object and load and instance of Engine
IEngineLoader engineLoader = new FREngine.OutprocLoader();
IEngine engine = engineLoader.InitializeEngine( customerProjectId, LicensePath, LicensePassword, "", "", false );
// We have obtained Engine in a separate process
try {
 ...
} finally {
 engineLoader.ExplicitlyUnload(); // We can unload it when it is no longer needed
 engineLoader = null;
 GC.Collect();
 GC.WaitForPendingFinalizers();
}

• Account permissions can be set up using the DCOM Config utility (either type DCOMCNFG in the command line, or select Control Panel > Administrative Tools > Component Services). In the console tree, locate the Component Services > Computers > My Computer > DCOM Config folder, right-click ABBYY FineReader Engine 12.5 Loader (Local Server), and click Properties. A dialog box will open. Click the Security tab. Under Launch Permissions, click Customize, and then click Edit to specify the accounts that can launch the application.

"mmc comexp.msc /32"

• To register FREngine.dll when installing your application on an end-user computer, use the regsvr32 utility. If you are on a 64-bit operating system, the 64-bit version of regsvr32 will run by default. Use the following command line:

regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FREngine.dll>"

• Implementing Engine as an out-of-process server specify sequential mode of document processing by setting MultiProcessingMode property of MultiProcessingParams object to MPM_Sequential.

​

See also