Computes the number of runs

@return the number of runs
978319
public int numberOfRunsAdjustment() {
    int ans = 0;
    long nextWord = bitmap[0];
    for (int i = 0; i < bitmap.length - 1; i++) {
      final long word = nextWord;

      nextWord = bitmap[i + 1];
      ans += ((word >>> 63) & ~nextWord);
    }
    final long word = nextWord;

    if ((word & 0x8000000000000000L) != 0) {
      ans++;
    }
    return ans;
  }
27863
@Override
    public int countMissing() {
        int count = 0;
        for (int i = 0; i < size(); i++) {
            if (isMissing(i)) {
                count++;
            }
        }
        return count;
    }
921458
public long getTotalRunTime() {
		if (detail.size() > 0){
			long runTime = 0;
			for (RunTime child: detail.values()){
				runTime += child.getTotalRunTime();
			}
			return runTime;
		}else{
			return statistics.getSum();
		}
	}
1087172
def running?
      total_jobs_running = get_jobs_by_status(Executor::STATUS_NONE).size +
                           get_jobs_by_status(Executor::STATUS_RUNNING).size +
                           get_jobs_by_status(Executor::STATUS_RETRYING).size
      (total_jobs_running > 0)
    end
1003726
public SequencalJobExecuteResults runAll() {
        SequencalJobExecuteResults results = new SequencalJobExecuteResults();
        for (Job job : jobs) {
            job.setJarByClass(SequencalJobChain.class);
            try {
                boolean isSuccessful = job.waitForCompletion(true);
                results.add(new SequencalJobExecuteResult(isSuccessful, job.getJobName()));
                if (!isSuccessful) {
                    break;
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return results;
    }
805348
public function getRowCount()
    {
        $this->parseDefer();
        if(!$this->isSuccess)
        {
            throw new \RuntimeException('Result is not success!');
        }
        return count($this->statement->fetchAll());
    }
910568
protected int countTies(double[] withinDistances, int[] withinTies) {
    int wties = 0, running = 1;
    for(int i = 1; i <= withinDistances.length; ++i) {
      if(i == withinDistances.length || withinDistances[i - 1] != withinDistances[i]) {
        for(int j = i - running; j < i; j++) {
          withinTies[j] = running;
        }
        wties += running - 1;
        running = 1;
      }
      else {
        running++;
      }
    }
    return wties;
  }
1178679
@Override
	public int getNumberLeaves() {
		while (true) {
			try {
				int result = 0;
				for (Slot slot: subSlots){
					result += slot.getNumberLeaves();
				}
				return result;
			}
			catch (ConcurrentModificationException e) {
				// ignore and retry
			}
		}
	}
69446
public Map<BenchmarkMethod, Integer> getNumberOfMethodsAndRuns()
			throws PerfidixMethodCheckException {
		final Map<BenchmarkMethod, Integer> returnVal = new HashMap<BenchmarkMethod, Integer>();
		// instantiate objects, just for getting runs
		final List<BenchmarkMethod> meths = getBenchmarkMethods();
		for (final BenchmarkMethod meth : meths) {
			// TODO respect data provider
			int numberOfRuns = BenchmarkMethod.getNumberOfAnnotatedRuns(meth
					.getMethodToBench());
			if (numberOfRuns == Bench.NONE_RUN) {
				numberOfRuns = conf.getRuns();
			}
			returnVal.put(meth, numberOfRuns);
		}
		return returnVal;
	}
69990
public final long getTotalCount()
    {
        long result = 0;
        result = result + _storedItemManager.getStatistics().getTotalCount();
        result = result + _unstoredItemManager.getStatistics().getTotalCount();
        return result;
    }
775304
@Deprecated
	public int count() {
		int count = (clusteringFeature != null) ? 1 : 0;
		for (ClusteringTreeNode child : children) {
			count += child.count();
		}
		return count;
	}
961179
@InterfaceAudience.Public
    @InterfaceStability.Experimental
    public int totalCount() {
        int total = countNonService;
        for (Map.Entry<ServiceType, Integer> entry : counts.entrySet()) {
            total += entry.getValue();
        }
        return total;
    }
928242
public int numVertices() {
	if(CACHING && (cachedNumVertices != -1)) {
	    return cachedNumVertices;
	}	
	int numVertices = vertices().size();       
	if(CACHING) {
	    cachedNumVertices = numVertices;
	}
	return numVertices;
    }
409359
public java.util.List<InstanceCount> getInstanceCounts() {
        if (instanceCounts == null) {
            instanceCounts = new com.amazonaws.internal.SdkInternalList<InstanceCount>();
        }
        return instanceCounts;
    }
1080163
public int count() {
        int n = 0;
        for (ConcurrentMap<?, ?> bag : registry.values()) {
            n += bag.size();
        }
        return n;
    }
1085341
public double trace()
    {
        double t = 0;
        for (int i = 0; i < Math.min(m, n); i++)
        {
            t += A[i][i];
        }
        return t;
    }
725357
public int getNumberOfClasses()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "getNumberOfClasses");
      SibTr.exit(tc, "getNumberOfClasses", Integer.valueOf(numberOfClasses));    
    }
    return numberOfClasses;
  }