Vai al contenuto principale
In sostanza, esistono tre modi in cui il multiprocessing è concepito per essere utilizzato con ABBYY FineReader Engine: Da un lato, è possibile utilizzare un singolo oggetto Engine, impostando la proprietà MultiProcessingParams dell’oggetto Engine sui valori appropriati. ABBYY FineReader Engine supporta due diversi oggetti che consentono il multiprocessing da una singola istanza di Engine: l’oggetto FRDocument (vedere Elaborazione con l’oggetto FRDocument) e l’oggetto BatchProcessor (vedere Elaborazione tramite Batch Processor). Dall’altro lato, è possibile caricare più istanze di Engine come server out-of-process tramite COM (utilizzando l’oggetto OutprocLoader) e utilizzare ciascuna istanza nel proprio processo. Vedere Elaborazione tramite un pool di Engine.
Si tenga presente che l’elaborazione parallela richiede più RAM rispetto all’elaborazione sequenziale. La raccomandazione generale per una workstation è di 350 MB * (numero di core) + 450 MB di RAM; per l’elaborazione di documenti in arabo o in lingue CJK, la raccomandazione è di 850 MB * (numero di core) + 750 MB di RAM.

​
Scenari d’uso

Daremo per scontato che si stia elaborando un gran numero di documenti. È tuttavia necessario tenere in considerazione i risultati che si desidera ottenere e scegliere il metodo più adatto per implementare il proprio compito. Gli scenari da considerare sono:
  • Conversione di documenti multipagina con un elevato numero di pagine. Questo scenario riguarda generalmente l’elaborazione di libri, report lunghi e simili. In questo caso, è possibile riconoscere le pagine del documento in parallelo, eseguire la sintesi nel processo principale ed effettuare nuovamente l’esportazione in parallelo. Utilizzando un pool di Engine, è inoltre possibile elaborare simultaneamente più documenti multipagina, ma il consumo di memoria può essere elevato e portare persino a errori di tipo “out of memory”.
  • Conversione di un gran numero di documenti di una sola pagina. Questo è il caso in cui si elaborano fatture, contratti, lettere e simili. L’elaborazione parallela è la soluzione più semplice per questa situazione, poiché i documenti di una sola pagina sono indipendenti l’uno dall’altro e non richiedono grandi quantità di memoria contemporaneamente.
  • Elaborazione di un gran numero di immagini per ricercare informazioni specifiche o per lavorare in altro modo con i risultati del riconoscimento. Nella maggior parte dei casi potrebbe non essere necessario convertirle in un formato modificabile, pertanto la velocità di sintesi ed esportazione non rappresenta un problema. L’operazione che verrà eseguita in più processi consiste nell’iterare tra i layout block e nell’accedere ai risultati del riconoscimento per i text block.
Se si desidera utilizzare l’elaborazione parallela per l’esportazione, tenere presente che questa funzionalità è supportata solo per l’esportazione in PDF (ad eccezione della modalità TextOnly) e nei formati PPTX.

​
Raccomandazioni e restrizioni

  • Per l’elaborazione parallela di documenti multipagina, si consiglia di utilizzare FRDocument. È il metodo di elaborazione parallela più semplice da implementare, poiché non è necessario implementare interfacce aggiuntive.
    Apertura, pre-elaborazione, analisi e riconoscimento vengono eseguiti in parallelo; la sintesi del documento viene eseguita in sequenza nel processo principale, dopodiché l’esportazione in PDF (ad eccezione della modalità TextOnly) e nei formati PPTX viene eseguita in parallelo.
  • Per elaborare numerosi documenti di una sola pagina ricevuti da una sorgente (ad esempio uno scanner), si consiglia di utilizzare BatchProcessor.
    Il vantaggio di questo metodo è che può essere utilizzato quando non si conosce in anticipo il numero di documenti, i quali possono essere di tipo diverso e devono essere elaborati non appena arrivano. Lo svantaggio è che richiede un maggiore sforzo implementativo: è necessario implementare le interfacce per un adattatore di file e una sorgente di immagini personalizzata.
    Tutte le fasi di elaborazione vengono eseguite in parallelo poiché, nel caso di documenti di una sola pagina, la sintesi della pagina e del documento viene eseguita separatamente per ciascuna pagina.
L’esportazione parallela non è supportata negli scenari con Batch Processor.
  • Per eseguire l’elaborazione completa di numerosi documenti di una sola pagina in parallelo, è possibile utilizzare un pool di Engine caricati out-of-process tramite COM. Questo metodo è il più efficiente in termini di velocità ed elimina automaticamente tutte le difficoltà legate al multi-threading: tutte le operazioni con gli oggetti di ABBYY FineReader Engine vengono serializzate tramite COM. Tuttavia, presenta alcune limitazioni:
  • a causa dell’utilizzo di COM, è necessario registrare FREngine.dll;
  • se il codice è scritto in C++, lavorare con COM richiede una maggiore quantità di codice di routine rispetto, ad esempio, a C#;
  • in questo caso, l’elaborazione avviene in un altro processo, pertanto non è possibile aprire immagini dalla memoria e l’iterazione dei risultati di riconoscimento richiede più tempo, poiché ogni richiesta deve essere trasmessa a un altro processo e restituita;
  • infine, il caricamento di più istanze di Engine comporta un maggiore consumo di memoria; in particolare, poiché tutte le fasi di elaborazione vengono eseguite in parallelo, più operazioni di sintesi simultanee possono svolgersi contemporaneamente, aumentando ulteriormente il consumo di memoria.
  • Per intercettare e gestire gli eventi che si verificano durante l’elaborazione parallela, è possibile utilizzare l’interfaccia IParallelProcessingCallback. Questa interfaccia può essere molto utile per gestire situazioni problematiche. Ad esempio, quando si verifica un errore di timeout, l’interfaccia IParallelProcessingCallback offre diverse soluzioni al problema in base alle preferenze dell’utente. Per ulteriori informazioni, vedere IParallelProcessingCallback::OnWaitIntervalExceeded.
Gli eventi che si verificano durante l’elaborazione parallela di una pagina vengono convertiti in eventi dell’intero documento.

​
Risultati dei test di velocità

Nella tabella seguente sono presentati i risultati dei test di prestazioni.
<br />Documenti di una paginaUn documento multipaginaRicerca nei risultati senza esportazione
Elaborazione sequenziale605187
Elaborazione con FRDocument4111757
Elaborazione con FRDocument (con PageFlushingPolicy = PFP_KeepInMemory)5514182
Elaborazione tramite Batch Processor99115294
Elaborazione tramite un pool di Engine16510102
Il processore della macchina di test è Intel® Core™ i5-4440 (3,10 GHz, 4 core fisici), 8 GB di RAM; il numero di processi eseguiti simultaneamente è 4. Le prestazioni sono state testate su 300 immagini in lingua inglese, con le impostazioni del profilo predefinito DocumentArchiving_Speed. I valori nella tabella rappresentano le pagine elaborate al minuto. Negli scenari “documenti di una pagina” e “un documento multipagina”, i documenti vengono esportati in formato PDF.

​
Elaborazione con l’oggetto FRDocument

Il numero di processi da eseguire viene rilevato automaticamente in base al numero di core CPU fisici o logici disponibili, al numero di core CPU liberi disponibili nella licenza e al numero di pagine nel documento. Per attivare la modalità di multiprocessing, procedere come segue:
  1. Impostare il valore della proprietà MultiProcessingMode del sottooggetto MultiProcessingParams dell’oggetto Engine. Il multiprocessing viene utilizzato se questa proprietà è impostata su MPM_Parallel o MPM_Auto e se il numero di pagine nel documento e il numero di core CPU disponibili sono entrambi maggiori di uno.
  2. Regolare il numero di processi da eseguire tramite la proprietà RecognitionProcessesCount e specificare i valori delle altre proprietà, se necessario.
Dopo aver configurato le impostazioni di multiprocessing, è possibile utilizzare la procedura standard di utilizzo di FRDocument. ABBYY FineReader Engine avvierà automaticamente diversi processi di riconoscimento quando viene chiamato uno dei seguenti metodi dell’oggetto FRDocument: Per ogni pagina del documento viene creata una nuova attività di elaborazione, che viene assegnata a uno dei processi di riconoscimento. Al termine di un’attività, il processo di riconoscimento riceve quella successiva. Il ciclo continua fino al completamento di tutte le attività. 
// Crea il documento
FREngine.IFRDocument document = engine.CreateFRDocument();
// Aggiunge le pagine al documento
for( int index = 0; index < filesNumber; index++ ) {
    string imagePath = filePaths[index];
    document.AddImageFile( imagePath, null, null );
}
// Configura i parametri di multiprocessing
engine.MultiProcessingParams.MultiProcessingMode = FREngine.MultiProcessingModeEnum.MPM_Parallel;
engine.MultiProcessingParams.RecognitionProcessesCount = coresNumber;
// Crea e configura i parametri di elaborazione del documento
FREngine.IDocumentProcessingParams documentProcessingParams = engine.CreateDocumentProcessingParams();
...
// Elabora il documento
document.Process( documentProcessingParams );
// Sintetizza ed esporta il documento come di consueto, lavora con i risultati, ecc.
...
Il pacchetto di distribuzione di ABBYY FineReader Engine include lo strumento demo MultiProcessingRecognition, che illustra il miglioramento delle prestazioni in termini di velocità ottenuto utilizzando il riconoscimento con multiprocessing tramite l’oggetto FRDocument e contiene un’implementazione utilizzabile come punto di partenza per sviluppare la propria applicazione.

​
Elaborazione con Batch Processor

Quando il Batch Processor viene inizializzato, vengono avviati e configurati processi di riconoscimento asincroni. Il processore preleva quindi i file immagine da una sorgente di immagini personalizzata. Per ogni pagina del file immagine viene creata una nuova attività di elaborazione, che viene assegnata a uno dei processi di riconoscimento. Se tutte le attività relative a un file sono state inviate per l’elaborazione ma non tutti i processi di riconoscimento sono occupati, il file immagine successivo dalla coda della sorgente viene prelevato e inviato per l’elaborazione. Questo ciclo continua finché la prima pagina immagine non è stata convertita e restituita all’utente. Le pagine vengono restituite all’utente nell’ordine in cui sono state prelevate dalla sorgente di immagini. Per organizzare il multiprocessing con il Batch Processor, procedere come segue:
  1. Implementare le interfacce IImageSource e IFileAdapter, che forniscono l’accesso alla sorgente di immagini e ai file in essa contenuti.
  2. [facoltativo] Implementare l’interfaccia IAsyncProcessingCallback per gestire l’elaborazione. I metodi di questa interfaccia consentono di gestire gli errori e/o annullare l’elaborazione.
  3. [facoltativo] Configurare il multiprocessing tramite il sottooggetto MultiProcessingParams dell’oggetto Engine. Si noti che non è necessario impostare la proprietà MultiProcessingMode, poiché l’elaborazione parallela viene utilizzata per impostazione predefinita quando si lavora con il Batch Processor. Regolare il numero di processi da eseguire tramite la proprietà RecognitionProcessesCount e specificare i valori delle altre proprietà, se necessario.
  4. Chiamare il metodo CreateBatchProcessor dell’oggetto Engine per ottenere l’oggetto BatchProcessor.
  5. Chiamare il metodo Start di questo oggetto per inizializzare il processore e avviare i processi di riconoscimento asincroni. Nella chiamata a questo metodo è possibile specificare la sorgente di immagini e passare i riferimenti all’interfaccia IAsyncProcessingCallback e agli oggetti parametro.
  6. Chiamare il metodo GetNextProcessedPage in un ciclo finché il metodo non restituisce 0, il che indica che non vi sono altre immagini nella sorgente e che tutte le immagini elaborate sono state restituite all’utente.
La pagina restituita dal metodo GetNextProcessedPage rimane valida fino alla chiamata successiva dello stesso metodo. Pertanto, se si desidera salvare la pagina, è necessario farlo tramite i metodi dell’oggetto FRPage oppure aggiungerla a un documento esistente tramite il metodo IFRDocument::AddPage PRIMA della chiamata successiva al metodo GetNextProcessedPage.
// Crea il Batch Processor
FREngine.IBatchProcessor batchProcessor = engine.CreateBatchProcessor();
// Imposta i parametri di multiprocessing
engine.MultiProcessingParams.RecognitionProcessesCount = coresNumber;
// Inizializza il processore
FREngine.IImageSource imageSource = new CImageSource; // la classe è implementata dall'utente
batchProcessor.Start( imageSource, null, null, null );
// Avvia l'elaborazione
while( true ) {
 FREngine.IFRPage page = batchProcessor.GetNextProcessedPage();
 if( page == null ) {
  break; // non ci sono altre pagine, fine del lavoro
 }
 // esegui un'operazione con la pagina
 page.Synthesize( null );
 page.Export("D:\\sample.pdf", FREngine.FileExportFormatEnum.FEF_PDF, null);
}
Il pacchetto di distribuzione di ABBYY FineReader Engine include il sample BatchProcessing, che mostra come utilizzare il Batch Processor, e lo strumento demo BatchProcessingRecognition, che illustra il miglioramento in termini di velocità ottenuto utilizzando il riconoscimento con multiprocessing tramite il Batch Processor.

​
Elaborazione tramite un pool di Engine

In questo scenario di multiprocessing, si utilizzano più istanze di Engine caricate out-of-process. All’interno di ogni thread di lavoro, la procedura può essere quasi identica a quella per l’elaborazione con un singolo thread. È tuttavia consigliabile implementare una sorgente di immagini personalizzata che distribuisca le immagini tra i thread, utilizzando un oggetto di sincronizzazione per garantire che ogni immagine venga elaborata una e una sola volta. Per caricare l’oggetto Engine out-of-process, utilizzare l’oggetto OutprocLoader, che implementa l’interfaccia IEngineLoader. Quando lo si utilizza con account speciali, potrebbero essere necessarie autorizzazioni per eseguire OutprocLoader con tali account. 
// Per ogni thread creare un oggetto OutprocLoader separato e caricare un'istanza di Engine
IEngineLoader engineLoader = new FREngine.OutprocLoader();
IEngine engine = engineLoader.InitializeEngine( customerProjectId, LicensePath, LicensePassword, "", "", false );
// Abbiamo ottenuto Engine in un processo separato
try {
 ...
} finally {
 engineLoader.ExplicitlyUnload(); // È possibile scaricarlo quando non è più necessario
 engineLoader = null;
 GC.Collect();
 GC.WaitForPendingFinalizers();
}
Inoltre, è possibile gestire la priorità di un host process e verificarne lo stato di esecuzione tramite l’interfaccia IHostProcessControl.
  • Le autorizzazioni degli account possono essere configurate tramite l’utilità DCOM Config (digitare DCOMCNFG nella riga di comando oppure selezionare Pannello di controllo > Strumenti di amministrazione > Servizi componenti). Nell’albero della console, individuare la cartella Servizi componenti > Computer > Risorse del computer > Configurazione DCOM, fare clic con il pulsante destro del mouse su ABBYY FineReader Engine 12.5 Loader (Server locale) e fare clic su Proprietà. Si aprirà una finestra di dialogo. Fare clic sulla scheda Sicurezza. In Autorizzazioni di avvio, fare clic su Personalizza, quindi su Modifica per specificare gli account autorizzati ad avviare l’applicazione.
Si noti che su un sistema operativo a 64 bit l’applicazione DCOM registrata è disponibile nella console MMC a 32 bit, che può essere avviata tramite la seguente riga di comando:
"mmc comexp.msc /32"
  • Per registrare FREngine.dll durante l’installazione dell’applicazione su un computer dell’utente finale, utilizzare l’utilità regsvr32. Su un sistema operativo a 64 bit, verrà eseguita per impostazione predefinita la versione a 64 bit di regsvr32. Utilizzare la riga di comando seguente:
regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FREngine.dll>"
  • Implementando Engine come server out-of-process, specificare la modalità sequenziale di elaborazione dei documenti impostando la proprietà MultiProcessingMode dell’oggetto MultiProcessingParams su MPM_Sequential.
Il pacchetto di distribuzione di ABBYY FineReader Engine include il sample EnginesPool, che mostra il miglioramento delle prestazioni ottenuto utilizzando un pool di Engine e fornisce un’implementazione pronta all’uso, che può costituire il punto di partenza per la propria applicazione. Consultare il codice sorgente di questo sample per informazioni dettagliate sull’implementazione di una sorgente di immagini personalizzata, sulla gestione delle eccezioni e sul controllo dell’utilizzo dei core CPU.

​
Vedere anche

FRDocument BatchProcessor MultiProcessingParams Iterating Document Pages Modi diversi per caricare l’oggetto Engine Utilizzo di ABBYY FineReader Engine in applicazioni server multi-thread