private boolean collect(
     FlowGraph graph,
     List<Tuple2<InputDescription, ExternalIoDescriptionProcessor>> inputs,
     List<Tuple2<OutputDescription, ExternalIoDescriptionProcessor>> outputs) {
   assert graph != null;
   assert inputs != null;
   assert outputs != null;
   boolean valid = true;
   Repository externals = environment.getExternals();
   for (FlowIn<?> port : graph.getFlowInputs()) {
     InputDescription desc = port.getDescription();
     ExternalIoDescriptionProcessor processor = externals.findProcessor(desc);
     if (processor != null) {
       inputs.add(Tuples.of(desc, processor));
     } else {
       environment.error("{0}を処理するプロセッサが見つかりませんでした。", desc.getClass().getName());
       valid = false;
     }
   }
   for (FlowOut<?> port : graph.getFlowOutputs()) {
     OutputDescription desc = port.getDescription();
     ExternalIoDescriptionProcessor processor = externals.findProcessor(desc);
     if (processor != null) {
       outputs.add(Tuples.of(desc, processor));
     } else {
       valid = false;
     }
   }
   return valid;
 }
 /**
  * 指定のスロットに対するエピローグ用のレデューサーを生成する。
  *
  * @param moduleId モジュール識別子
  * @param slots 対象のスロット一覧
  * @return 生成したクラス
  * @throws IOException 出力に失敗した場合
  * @throws IllegalArgumentException 引数に{@code null}が指定された場合
  */
 public CompiledType emit(String moduleId, List<ResolvedSlot> slots) throws IOException {
   LOG.debug("\"{}\"エピローグ用のレデューサーを生成します", moduleId);
   Engine engine = new Engine(environment, moduleId, slots);
   CompilationUnit source = engine.generate();
   environment.emit(source);
   Name packageName = source.getPackageDeclaration().getName();
   SimpleName simpleName = source.getTypeDeclarations().get(0).getName();
   Name name = environment.getModelFactory().newQualifiedName(packageName, simpleName);
   LOG.debug("エピローグ用レデューサーには{}が利用されます", name);
   return new CompiledType(name);
 }
 /**
  * 指定のモデルに対する値を表すクラスを生成し、生成したクラスの完全限定名を返す。
  *
  * @param model 対象のモデル
  * @return 生成したクラスの完全限定名
  * @throws IOException クラスの生成に失敗した場合
  * @throws IllegalArgumentException 引数に{@code null}が指定された場合
  */
 public Name emit(ShuffleModel model) throws IOException {
   Precondition.checkMustNotBeNull(model, "model"); // $NON-NLS-1$
   LOG.debug("{}に対するシャッフル値を生成します", model.getStageBlock());
   Engine engine = new Engine(environment, model);
   CompilationUnit source = engine.generate();
   environment.emit(source);
   Name packageName = source.getPackageDeclaration().getName();
   SimpleName simpleName = source.getTypeDeclarations().get(0).getName();
   Name name = environment.getModelFactory().newQualifiedName(packageName, simpleName);
   LOG.debug("{}のシャッフル値には{}が利用されます", model.getStageBlock(), name);
   return name;
 }
 public Engine(FlowCompilingEnvironment environment, ShuffleModel model) {
   assert environment != null;
   assert model != null;
   this.model = model;
   this.factory = environment.getModelFactory();
   Name packageName = environment.getStagePackageName(model.getStageBlock().getStageNumber());
   this.importer =
       new ImportBuilder(
           factory,
           factory.newPackageDeclaration(packageName),
           ImportBuilder.Strategy.TOP_LEVEL);
 }
 Engine(FlowCompilingEnvironment envinronment, String moduleId, List<ResolvedSlot> slots) {
   assert envinronment != null;
   assert moduleId != null;
   assert slots != null;
   this.slots = slots;
   this.environment = envinronment;
   this.factory = envinronment.getModelFactory();
   this.importer =
       new ImportBuilder(
           factory,
           factory.newPackageDeclaration(envinronment.getEpiloguePackageName(moduleId)),
           Strategy.TOP_LEVEL);
 }
 /**
  * 指定のモデルに対する値を表すクラスを生成し、生成したクラスの完全限定名を返す。
  *
  * @param model 対象のモデル
  * @return 生成したクラスの完全限定名
  * @throws IOException クラスの生成に失敗した場合
  * @throws IllegalArgumentException 引数に{@code null}が指定された場合
  */
 public Name emit(ShuffleModel model) throws IOException {
   Precondition.checkMustNotBeNull(model, "model"); // $NON-NLS-1$
   LOG.debug("start generating shuffle value class: {}", model.getStageBlock()); // $NON-NLS-1$
   Engine engine = new Engine(environment, model);
   CompilationUnit source = engine.generate();
   environment.emit(source);
   Name packageName = source.getPackageDeclaration().getName();
   SimpleName simpleName = source.getTypeDeclarations().get(0).getName();
   Name name = environment.getModelFactory().newQualifiedName(packageName, simpleName);
   LOG.debug(
       "finish generating shuffle value class: {} ({})",
       model.getStageBlock(),
       name); //$NON-NLS-1$
   return name;
 }
Example #7
0
 Engine(FlowCompilingEnvironment environment, StageModel model) {
   assert environment != null;
   assert model != null;
   this.reduceUnits = model.getReduceUnits();
   this.shuffle = model.getShuffleModel();
   this.factory = environment.getModelFactory();
   Name packageName = environment.getStagePackageName(model.getStageBlock().getStageNumber());
   this.importer =
       new ImportBuilder(
           factory,
           factory.newPackageDeclaration(packageName),
           ImportBuilder.Strategy.TOP_LEVEL);
   this.names = new NameGenerator(factory);
   this.context = names.create("context");
   this.shuffleNames = Maps.create();
   this.rendezvousNames = Maps.create();
 }
Example #8
0
  /**
   * 指定のステージ内のCombinerに対するクラスを生成し、生成したクラスの完全限定名を返す。
   *
   * @param model 対象のステージ
   * @return 生成したクラスの完全限定名、不要の場合は{@code null}
   * @throws IOException クラスの生成に失敗した場合
   * @throws IllegalArgumentException 引数に{@code null}が指定された場合
   */
  public CompiledType emit(StageModel model) throws IOException {
    Precondition.checkMustNotBeNull(model, "model"); // $NON-NLS-1$
    if (canCombine(model) == false) {
      LOG.debug("{}に対してコンバイナークラスは不要です", model);
      return null;
    }
    LOG.debug("{}に対するコンバイナークラスを生成します", model);
    Engine engine = new Engine(environment, model);
    CompilationUnit source = engine.generate();
    environment.emit(source);
    Name packageName = source.getPackageDeclaration().getName();
    SimpleName simpleName = source.getTypeDeclarations().get(0).getName();

    QualifiedName name = environment.getModelFactory().newQualifiedName(packageName, simpleName);

    LOG.debug("{}のコンバイン処理には{}が利用されます", model, name);
    return new CompiledType(name);
  }