* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*   http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied.  See the License for the

* specific language governing permissions and limitations

* under the License.

*/

* Responsible for creating and initializing processing threads. This instance manages the lifecycle

* of the CPE components. It exposes API for plugging in components programmatically instead of

* declaratively. Running in its own thread, this components creates seperate Processing Pipelines

* for Analysis Engines and Cas Consumers, launches configured CollectionReader and attaches all of

* those components to form a pipeline from source to sink. The Collection Reader feeds Processing

* Threads containing Analysis Engines, and Analysis Engines feed results of analysis to Cas

* Consumers.

*

*

*

*/

  private static final int MAX_WAIT_ON_QUEUE = 400;

  private static final int CAS_PROCESSED_MSG = 1000;

  private static final String SINGLE_THREADED_MODE = "single-threaded";

  public CPECasPool casPool;

  // Used internally for synchronization

  public final Object lockForPause = new Object(); 

  // CollectionReader to be used by this CPM

  private BaseCollectionReader collectionReader = null;

  // Flag indicating if the CPM should pause

  // Accesses to this flag (read and write) must

  //   be done while holding the "lockForPause" lock

  //   via synch

  //  @GuardedBy(lockForPause)

  protected boolean pause = false;

  // Flag indicating if this CPM is running or not

  // Marked volatile because it is set and read on different threads without synchronization

  protected volatile boolean isRunning = false;

  // Flag indicating if this CPM has been stopped

  // Marked volatile because it is set and read on different threads without synchronization

  protected volatile boolean stopped = false;

  // Flag indicating if this CPM has been killed

  // Marked volatile because it is set and read on different threads without synchronization

  protected volatile boolean killed = false;

  // Flag indicating if this CPM should be paused on exception

  private boolean pauseOnException = false;

  // List of all annotators

  private LinkedList annotatorList = new LinkedList();

  private LinkedList annotatorDeployList = new LinkedList();

  // List of CasConsumers

  private LinkedList consumerList = new LinkedList();

  private LinkedList consumerDeployList = new LinkedList();

  // Number of entities this CPM must process.

  private long numToProcess = -1;

  private int poolSize = 0;

  // ProcessTrace aggregating CPMs performance stats

  private ProcessTrace procTr = null;

  // private EntityProcessStatusImpl enProcSt = null;

  // used to during recovery stage after CPM failure or forced shutdown

  // private ProcessTrace restoredProcTr = null;

  // Map for storing runtime statistics. used for reporting

  private Map stats = new HashMap();

  // List of all callback listeners

  private ArrayList statusCbL = new ArrayList();

  // Number of entities to fetch for every getNext()

  private int readerFetchSize = 1;

  // Size of the work queue. This queue is shared among processing units with deployed annotators.

  // The ArtifactProducer deposits entities into this queue, while ProcessingUnits dequeue them.

  private int inputQueueSize = 1;

  // Size of the output queue. This queue is shared with deployed casconsumers.

  private int outputQueueSize = 1;

  // Number of concurrent processing units (pipelines)

  private int concurrentThreadCount = 1;

  private Hashtable analysisEngines = new Hashtable();

  private Hashtable consumers = new Hashtable();

  private CasProcessor[] casprocessorList;

  // Component responsible for asynchronous read from the CollectionReader. It places Cas'es into

  // work Queue

  private ArtifactProducer producer = null;

  // Factory responsible for instantiating CPE components from CPE descriptor

  private CPEFactory cpeFactory = null;

  // An array holding instances of components responsible for analysis

  protected ProcessingUnit[] processingUnits = null;

  // Instantiate a Processing Unit containing CasConsumers. There may be many Analysis Processing

  // Units

  // but there is one CasConsumer Processing Unit ( at least for now).

  private ProcessingUnit casConsumerPU = null;

  // Queue where result of analysis goes to be consumed by Consumers

  protected BoundedWorkQueue outputQueue = null;

  // Queue were Cas'es meant for analysis are deposited by ArtifactProducer

  protected BoundedWorkQueue workQueue = null;

  private CheckpointData checkpointData = null;

  private boolean mixedCasProcessorTypeSupport = false;

  private Properties mPerformanceTuningSettings = UIMAFramework

          .getDefaultPerformanceTuningProperties();

  private DebugControlThread dbgCtrlThread = null;

  private ProcessControllerAdapter pca = null;

  private int activeProcessingUnits = 1;

  private boolean hardKill = false;

  private Hashtable skippedDocs = new Hashtable();

  private Capability[] definedCapabilities = null;

  private boolean needsTCas = true;

  private long crFetchTime = 0;

  private int readerState = 0;

  private boolean dropCasOnExceptionPolicy = false;

  private boolean singleThreadedCPE = false;

  private NonThreadedProcessingUnit nonThreadedProcessingUnit = null;

  private NonThreadedProcessingUnit nonThreadedCasConsumerProcessingUnit = null;

  private LinkedList initial_cp_list = new LinkedList(); // this list is used to hold Cas

  // Processors

  // It contains both AEs and CCs.

  private boolean casProcessorsDeployed = false;

  private boolean consumerThreadStarted = false;

  private boolean readerThreadStarted = false;

  private int[] processingThreadsState = null;

  /**

   * Initializes Collection Processing Engine. Assigns this thread and all processing threads

   * created by this component to a common Thread Group.

   *

   * @param aThreadGroup -

   *          contains all CPM related threads

   * @param aCpeFactory -

   *          CPE factory object responsible for parsing cpe descriptor and creating components

   * @param aProcTr -

   *          instance of the ProcessTrace where the CPM accumulates stats

   * @param aCheckpointData -

   *          checkpoint object facillitating restart from the last known point

   */

  public CPMEngine(CPMThreadGroup aThreadGroup, CPEFactory aCpeFactory, ProcessTrace aProcTr,

          CheckpointData aCheckpointData) throws Exception {

    super(aThreadGroup, "CPMEngine Thread");

    cpeFactory = aCpeFactory;

    // Accumulate trace info in provided ProcessTrace instance

    procTr = aProcTr;

    // Determine in which mode to start the engine: single or multi-threaded

    if (cpeFactory.getCPEConfig() != null

            && cpeFactory.getCPEConfig().getDeployment().equalsIgnoreCase(SINGLE_THREADED_MODE)) {

      if (UIMAFramework.getLogger().isLoggable(Level.CONFIG)) {

        UIMAFramework.getLogger(this.getClass()).logrb(Level.CONFIG, this.getClass().getName(),

                "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,

                "UIMA_CPM_single_threaded_mode__CONFIG",

                new Object[] { Thread.currentThread().getName() });

      }

      singleThreadedCPE = true;

    } else {

      if (UIMAFramework.getLogger().isLoggable(Level.CONFIG)) {

        UIMAFramework.getLogger(this.getClass()).logrb(Level.CONFIG, this.getClass().getName(),

                "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,

                "UIMA_CPM_multi_threaded_mode__CONFIG",

                new Object[] { Thread.currentThread().getName() });