Java JobExecutionResult.getNetRuntime方法代码示例

import org.apache.flink.api.common.JobExecutionResult; //导入方法依赖的package包/类
private void testProgram(
		LocalFlinkMiniCluster localFlinkMiniCluster,
		final int dataVolumeGb,
		final boolean useForwarder,
		final boolean isSlowSender,
		final boolean isSlowReceiver,
		final int parallelism) throws Exception {
	JobExecutionResult jer = localFlinkMiniCluster.submitJobAndWait(
		createJobGraph(
			dataVolumeGb,
			useForwarder,
			isSlowSender,
			isSlowReceiver,
			parallelism),
		false);

	long dataVolumeMbit = dataVolumeGb * 8192;
	long runtimeSecs = jer.getNetRuntime(TimeUnit.SECONDS);

	int mbitPerSecond = (int) (((double) dataVolumeMbit) / runtimeSecs);

	LOG.info(String.format("Test finished with throughput of %d MBit/s (runtime [secs]: %d, " +
		"data volume [gb/mbits]: %d/%d)", mbitPerSecond, runtimeSecs, dataVolumeGb, dataVolumeMbit));
}
 

import org.apache.flink.api.common.JobExecutionResult; //导入方法依赖的package包/类
public static void write(final JobExecutionResult res, final String path) {
	double elapsed = res.getNetRuntime(TimeUnit.NANOSECONDS);		
	long tuples = res.getAccumulatorResult("tuples");
	double latency = elapsed / tuples;
	
	PerformanceWriter.write(path, elapsed, latency);
}
 

import org.apache.flink.api.common.JobExecutionResult; //导入方法依赖的package包/类
@Override
public PipelineResult run(Pipeline pipeline) {
  logWarningIfPCollectionViewHasNonDeterministicKeyCoder(pipeline);

  MetricsEnvironment.setMetricsSupported(true);

  LOG.info("Executing pipeline using FlinkRunner.");

  FlinkPipelineExecutionEnvironment env = new FlinkPipelineExecutionEnvironment(options);

  LOG.info("Translating pipeline to Flink program.");
  env.translate(this, pipeline);

  JobExecutionResult result;
  try {
    LOG.info("Starting execution of Flink program.");
    result = env.executePipeline();
  } catch (Exception e) {
    LOG.error("Pipeline execution failed", e);
    throw new RuntimeException("Pipeline execution failed", e);
  }

  if (result instanceof DetachedEnvironment.DetachedJobExecutionResult) {
    LOG.info("Pipeline submitted in Detached mode");
    return new FlinkDetachedRunnerResult();
  } else {
    LOG.info("Execution finished in {} msecs", result.getNetRuntime());
    Map<String, Object> accumulators = result.getAllAccumulatorResults();
    if (accumulators != null && !accumulators.isEmpty()) {
      LOG.info("Final accumulator values:");
      for (Map.Entry<String, Object> entry : result.getAllAccumulatorResults().entrySet()) {
        LOG.info("{} : {}", entry.getKey(), entry.getValue());
      }
    }

    return new FlinkRunnerResult(accumulators, result.getNetRuntime());
  }
}
 

import org.apache.flink.api.common.JobExecutionResult; //导入方法依赖的package包/类
public FlinkRunnerResult run(Pipeline pipeline, int parallelism) {
	if (parallelism <= 0 && parallelism != -1) {
		throw new IllegalArgumentException("Parallelism must be positive or -1 for default");
	}
	
	LOG.info("Executing pipeline using the FlinkLocalPipelineRunner.");
	
	ExecutionEnvironment env = parallelism == -1 ?
			ExecutionEnvironment.createLocalEnvironment() :
			ExecutionEnvironment.createLocalEnvironment(parallelism);
	
	LOG.info("Translating pipeline to Flink program.");
	
	FlinkTranslator translator = new FlinkTranslator(env);
	translator.translate(pipeline);
	
	LOG.info("Starting execution of Flink program.");
	
	JobExecutionResult result;
	try {
		result = env.execute();
	}
	catch (Exception e) {
		LOG.error("Pipeline execution failed", e);
		throw new RuntimeException("Pipeline execution failed", e);
	}
	
	LOG.info("Execution finished in {} msecs", result.getNetRuntime());
	
	Map<String, Object> accumulators = result.getAllAccumulatorResults();
	if (accumulators != null && !accumulators.isEmpty()) {
		LOG.info("Final aggregator values:");
		
		for (Map.Entry<String, Object> entry : result.getAllAccumulatorResults().entrySet()) {
			LOG.info("{} : {}", entry.getKey(), entry.getValue());
		}
	}

	return new ExecutionRunnerResult(accumulators, result.getNetRuntime());
}
 

import org.apache.flink.api.common.JobExecutionResult; //导入方法依赖的package包/类
public CentralizedWeightedMatching() throws Exception {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironment();

	// Source: http://grouplens.org/datasets/movielens/
	@SuppressWarnings("serial")
	DataStream<Edge<Long, Long>> edges = env
			.readTextFile("movielens_10k_sorted.txt")
			.map(new MapFunction<String, Edge<Long, Long>>() {
				@Override
				public Edge<Long, Long> map(String s) throws Exception {
					String[] args = s.split("\t");
					long src = Long.parseLong(args[0]);
					long trg = Long.parseLong(args[1]) + 1000000;
					long val = Long.parseLong(args[2]) * 10;
					return new Edge<>(src, trg, val);
				}
			});

	GraphStream<Long, NullValue, Long> graph = new SimpleEdgeStream<>(edges, env);

	graph.getEdges()
			.flatMap(new WeightedMatchingFlatMapper()).setParallelism(1)
			.print().setParallelism(1);

	JobExecutionResult res = env.execute("Distributed Merge Tree Sandbox");
	long runtime = res.getNetRuntime();
	System.out.println("Runtime: " + runtime);
}