overlapping-outputs-timeline.png...

overlapping-outputs-input-comparison.png...

                @Inject
                abstract InputChanges getInputChanges()

                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    println "processing \${input.name}"
                    def output = outputs.file(input.name + ".green")
                    output.text = input.text + ".green"
                }
            }
        """

      float_graph->tensors()->Get(op->outputs[0])->quantization();
  auto output_quant_params =
      subgraph->tensors[op->outputs[0]]->quantization.get();
  ASSERT_THAT(*float_output_quant_params->min(), SizeIs(1));
  ASSERT_THAT(*float_output_quant_params->max(), SizeIs(1));
  ASSERT_THAT(output_quant_params->scale, SizeIs(1));

  // Make sure the input min/maxes are propagated to outputs.

      )

      inputs = {'input_vocabs': input_vocabs_placeholder}
      outputs = {
          'lookup': lookup_tensor,
          'output': output_tensor,
      }

      self._save_tf1_model(
          sess,
          output_path,
          signature_def_key,
          tags,
          inputs=inputs,
          outputs=outputs,
          init_op=lookup_ops.tables_initializer(),

                         const std::vector<IOSpec>& outputs) {
    const OpDef& signature = fdef.signature();
    ASSERT_EQ(outputs.size(), signature.output_arg_size());
    for (int i = 0; i < outputs.size(); ++i) {
      const OpDef::ArgDef& arg = signature.output_arg(i);
      const IOSpec& out = outputs[i];
      if (out.second != DT_INVALID) {
        ASSERT_EQ(arg.type(), out.second)

  shard_output_types.reserve(outputs.size());
  full_output_types.reserve(outputs.size());
  for (const auto& output : outputs) {
    Type shard_type;
    if (failed(GetShardShapedType(original_op, num_cores_per_replica,
                                  output.getType(), shard_type)))
      return mlir::failure();
    shard_output_types.push_back(shard_type);
    full_output_types.push_back(output.getType());

[[sec:task_inputs_outputs]]
== Task inputs and outputs

In the most common case, a task takes some inputs and generates some outputs.
We can consider the process of Java compilation as an example of a task.
The Java source files act as inputs of the task, while the generated class files, i.e. the result of the compilation, are the outputs of the task.

.Example task inputs and outputs
image::taskInputsOutputs.png[]

	var (
		gp01    = regInfo{inputs: []regMask{}, outputs: gponly}
		gp11    = regInfo{inputs: []regMask{gp}, outputs: gponly}
		gp11sp  = regInfo{inputs: []regMask{gpsp}, outputs: gponly}
		gp21    = regInfo{inputs: []regMask{gp, gp}, outputs: gponly}
		gp21sp  = regInfo{inputs: []regMask{gpsp, gp}, outputs: gponly}
		gp21tmp = regInfo{inputs: []regMask{gp &^ tmp, gp &^ tmp}, outputs: []regMask{gp &^ tmp}, clobbers: tmp}

//  noutputs - number of elements in `outputs` array
//  outputs - array of TF_Outputs that specify the outputs of the function.
//            If `noutputs` is zero (the function returns no outputs), `outputs`
//            can be null. `outputs` can contain the same tensor more than once.
//  output_names - The names of the function's outputs. `output_names` array