<p>
The number of CPU cores and the number of threads per core for the DB instance class of the DB instance.
</p>

@param processorFeatures
The number of CPU cores and the number of threads per core for the DB instance class of the DB instance.
16935
public void setProcessorFeatures(java.util.Collection<ProcessorFeature> processorFeatures) {
        if (processorFeatures == null) {
            this.processorFeatures = null;
            return;
        }

        this.processorFeatures = new com.amazonaws.internal.SdkInternalList<ProcessorFeature>(processorFeatures);
    }
106755
protected void addConfiguredProcessorParam(final ProcessorParam param) throws NullPointerException, BuildException {
    if (param == null) {
      throw new NullPointerException("param");
    }
    if (isReference()) {
      throw noChildrenAllowed();
    }
    this.processorParams.addElement(param);
  }
1312530
func (s *CreateDBInstanceReadReplicaInput) SetProcessorFeatures(v []*ProcessorFeature) *CreateDBInstanceReadReplicaInput {
	s.ProcessorFeatures = v
	return s
}
828210
@Override
	public void init(TopologyBuilder topologyBuilder, Instances dataset, int parallelism) {
		
		// Create MODEL PIs
		this.model = new AMRRuleSetProcessor.Builder(dataset)
		.noAnomalyDetection(noAnomalyDetectionOption.isSet())
		.multivariateAnomalyProbabilityThreshold(multivariateAnomalyProbabilityThresholdOption.getValue())
		.univariateAnomalyProbabilityThreshold(univariateAnomalyProbabilityThresholdOption.getValue())
		.anomalyNumberOfInstancesThreshold(anomalyNumInstThresholdOption.getValue())
		.unorderedRules(unorderedRulesOption.isSet())
		.voteType(votingTypeOption.getChosenIndex())
		.build();

		topologyBuilder.addProcessor(model, this.ruleSetParallelismOption.getValue());
		
		// MODEL PIs streams
		Stream forwardToRootStream = topologyBuilder.createStream(this.model);
		Stream forwardToLearnerStream = topologyBuilder.createStream(this.model);
		this.modelResultStream = topologyBuilder.createStream(this.model);
		
		this.model.setDefaultRuleStream(forwardToRootStream);
		this.model.setStatisticsStream(forwardToLearnerStream);
		this.model.setResultStream(this.modelResultStream);
		
		// Create DefaultRule PI
		AMRDefaultRuleProcessor root = new AMRDefaultRuleProcessor.Builder(dataset)
				.threshold(pageHinckleyThresholdOption.getValue())
				.alpha(pageHinckleyAlphaOption.getValue())
				.changeDetection(this.DriftDetectionOption.isSet())
				.predictionFunction(predictionFunctionOption.getChosenIndex())
				.constantLearningRatioDecay(constantLearningRatioDecayOption.isSet())
				.learningRatio(learningRatioOption.getValue())
				.splitConfidence(splitConfidenceOption.getValue())
				.tieThreshold(tieThresholdOption.getValue())
				.gracePeriod(gracePeriodOption.getValue())
				.numericObserver((FIMTDDNumericAttributeClassLimitObserver) numericObserverOption.getValue())
				.build();
		
		topologyBuilder.addProcessor(root);
		
		// Default Rule PI streams
		Stream newRuleStream = topologyBuilder.createStream(root);
		this.rootResultStream = topologyBuilder.createStream(root);
		
		root.setRuleStream(newRuleStream);
		root.setResultStream(this.rootResultStream);
		
		// Create Learner PIs
		AMRLearnerProcessor learner = new AMRLearnerProcessor.Builder(dataset)
				.splitConfidence(splitConfidenceOption.getValue())
				.tieThreshold(tieThresholdOption.getValue())
				.gracePeriod(gracePeriodOption.getValue())
				.noAnomalyDetection(noAnomalyDetectionOption.isSet())
				.multivariateAnomalyProbabilityThreshold(multivariateAnomalyProbabilityThresholdOption.getValue())
				.univariateAnomalyProbabilityThreshold(univariateAnomalyProbabilityThresholdOption.getValue())
				.anomalyNumberOfInstancesThreshold(anomalyNumInstThresholdOption.getValue())
				.build();
    
		topologyBuilder.addProcessor(learner, this.learnerParallelismOption.getValue());

		Stream predicateStream = topologyBuilder.createStream(learner);
		learner.setOutputStream(predicateStream);
		
		// Connect streams
		// to MODEL
		topologyBuilder.connectInputAllStream(newRuleStream, this.model);
		topologyBuilder.connectInputAllStream(predicateStream, this.model);
		// to ROOT
		topologyBuilder.connectInputShuffleStream(forwardToRootStream, root);
		// to LEARNER
		topologyBuilder.connectInputKeyStream(forwardToLearnerStream, learner);
		topologyBuilder.connectInputAllStream(newRuleStream, learner);
	}
1291326
public void executeProcessors(JCas jcas, ProcessorManager.Priority prio) {
		if(!this.initialized) {
			Logger.printError(component, "Unable to execute Processors; initialization was not concluded successfully.");
			System.exit(-1);
		}
		
		LinkedList<GenericProcessor> myList = processors.get(prio);
		for(GenericProcessor gp : myList) {
			try {
				gp.process(jcas);
			} catch (Exception exception) {
				exception.printStackTrace();
				Logger.printError(component, "Unable to process registered Processor " + gp.getClass().getName() + ", got: " + exception.toString());
				System.exit(-1);
			}
		}
	}
640895
@SuppressWarnings("static-method")
	public void getImportedFeatures(List<Class<?>> features) {
		features.add(AtomicIntegerArithmeticExtensions.class);
		features.add(AtomicLongArithmeticExtensions.class);
		features.add(ByteArithmeticExtensions.class);
		features.add(DoubleArithmeticExtensions.class);
		features.add(FloatArithmeticExtensions.class);
		features.add(IntegerArithmeticExtensions.class);
		features.add(LongArithmeticExtensions.class);
		features.add(NumberArithmeticExtensions.class);
		features.add(PrimitiveByteArithmeticExtensions.class);
		features.add(PrimitiveDoubleArithmeticExtensions.class);
		features.add(PrimitiveFloatArithmeticExtensions.class);
		features.add(PrimitiveIntArithmeticExtensions.class);
		features.add(PrimitiveLongArithmeticExtensions.class);
		features.add(PrimitiveShortArithmeticExtensions.class);
		features.add(ShortArithmeticExtensions.class);
	}
572182
func (s *DBSnapshot) SetProcessorFeatures(v []*ProcessorFeature) *DBSnapshot {
	s.ProcessorFeatures = v
	return s
}
188336
def set_mpi_procs(self, mpi_procs):
        """"""
        QueueAdapter.set_mpi_procs(self, mpi_procs)

        num_nodes, rest_cores = self.hw.divmod_node(mpi_procs, omp_threads=1)
        if num_nodes == 0:
            self.qparams["nodes"] = 1
            self.qparams["ppn"] = mpi_procs
        else:
            if rest_cores != 0:
                # Pack cores as much as possible.
                num_nodes += 1
            self.qparams["nodes"] = num_nodes
            self.qparams["ppn"] = self.hw.cores_per_node
77176
public T withProcessor(final NiftyProcessor processor)
    {
        this.niftyProcessorFactory = new NiftyProcessorFactory() {
            @Override
            public NiftyProcessor getProcessor(TTransport transport)
            {
                return processor;
            }
        };
        return (T) this;
    }
364118
public void setFeatures(List<Feature> features) {
        this.mFeatures.clear();
        if (features != null) {
            this.mFeatures.addAll(features);
        }
    }
148824
public void setProcessorOptions(String processorOptions)
	{
		StringTokenizer tok = new StringTokenizer(processorOptions, ",");
		while (tok.hasMoreTokens())
			_processorOptions.add(tok.nextToken());
	}
1185256
@Override
    public Processor newProcessor(Processor sourceProcessor) {
        LocalClustererProcessor newProcessor = new LocalClustererProcessor();
        LocalClustererProcessor originProcessor = (LocalClustererProcessor) sourceProcessor;
        if (originProcessor.getLearner() != null) {
            newProcessor.setLearner(originProcessor.getLearner().create());
        }
        newProcessor.setOutputStream(originProcessor.getOutputStream());
        return newProcessor;
    }
466154
public <A extends Annotation> void registerProcessor(final Class<A> annoClass, final FieldProcessor<A> processor) {
        ArgUtils.notNull(annoClass, "annoClass");
        ArgUtils.notNull(processor, "processor");
        
        pocessorMap.put(annoClass, processor);
        
    }
1195170
@Override
	public void postSetup(Site site) {
		if(processors != null){
			for(Processor p: processors){
				p.postSetup(site);
			}
		}
	}
18434
public static void run(DBIDs ids, Processor... procs) {
    ParallelCore core = ParallelCore.getCore();
    core.connect();
    try {
      // TODO: try different strategies anyway!
      ArrayDBIDs aids = DBIDUtil.ensureArray(ids);
      final int size = aids.size();
      int numparts = core.getParallelism();
      // TODO: are there better heuristics for choosing this?
      numparts = (size > numparts * numparts * 16) ? numparts * Math.max(1, numparts - 1) : numparts;

      final int blocksize = (size + (numparts - 1)) / numparts;
      List<Future<ArrayDBIDs>> parts = new ArrayList<>(numparts);
      for(int i = 0; i < numparts; i++) {
        final int start = i * blocksize;
        final int end = Math.min(start + blocksize, size);
        Callable<ArrayDBIDs> run = new BlockArrayRunner(aids, start, end, procs);
        parts.add(core.submit(run));
      }

      for(Future<ArrayDBIDs> fut : parts) {
        fut.get();
      }
    }
    catch(ExecutionException e) {
      throw new RuntimeException("Processor execution failed.", e);
    }
    catch(InterruptedException e) {
      throw new RuntimeException("Parallel execution interrupted.");
    }
    finally {
      core.disconnect();
    }
  }
1259310
public void addAlgorithmsToFeatures(List<ALGORITHM> algorithms) {
        ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(connection());
        for (ALGORITHM algo : algorithms) {
            sdm.addFeature(asFeature(algo));
        }
    }
711316
public void setupInstances() {
		this.piInstances = new ArrayList<ThreadsProcessingItemInstance>(this.getParallelism());
		for (int i=0; i<this.getParallelism(); i++) {
			Processor newProcessor = this.getProcessor().newProcessor(this.getProcessor());
			newProcessor.onCreate(i + 1);
			this.piInstances.add(new ThreadsProcessingItemInstance(newProcessor, this.offset + i));
		}
	}