}

tensorflow::Status RecordStatusIfError(absl::Status status) {
  if (status.ok()) {
    return absl::OkStatus();
  }

  tf_dialect_to_executor_dialect_status->GetCell(kExportFailed)->IncrementBy(1);
  VLOG(1) << "Failed to export from TF Dialect to TF Executor Dialect. "
          << status;

  constexpr char bridge_subcomponent[] =
      "TFXLA_TF_FUNCTIONAL_TO_EXECUTOR_EXPORT_v2";

    if (has_tpu_partitioned_call) break;
  }

  std::string has_tpu_partitioned_call_str =
      has_tpu_partitioned_call ? "true" : "false";
  has_tpu_partitioned_call_streamz->GetCell(has_tpu_partitioned_call_str)
      ->IncrementBy(1);
}

}  // namespace

std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
CreateInferenceMetricsPass() {
  return std::make_unique<InferenceMetricsPass>();

  if (status.ok()) {
    return absl::OkStatus();
  }

  VLOG(1) << "Failed to export from TF Dialect to TF Executor Dialect. "
          << status;
  tf_dialect_to_executor_dialect_status->GetCell(kExportFailed)->IncrementBy(1);

  constexpr char bridge_subcomponent[] =
      "TFXLA_TF_FUNCTIONAL_TO_EXECUTOR_EXPORT_v1";
  constexpr char kBridgeComponent[] = "TFXLABridge";

  tsl::OkOrSetErrorCounterPayload(

    load_attempt_count->GetCell(export_dir, status_str)->IncrementBy(1);
  };
  if (status.ok()) {
    log_and_count(kLoadAttemptSuccess);
    metrics::SavedModelReadPath().Set(export_dir);
  } else {
    log_and_count(kLoadAttemptFail);
  }
  load_latency->GetCell(export_dir)
      ->IncrementBy(GetLatencyMicroseconds(start_microseconds));
  return status;

 *
 * @author Gregory Kick
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
abstract class RegularImmutableTable<R, C, V> extends ImmutableTable<R, C, V> {
  RegularImmutableTable() {}

  abstract Cell<R, C, V> getCell(int iterationIndex);

  @Override
  final ImmutableSet<Cell<R, C, V>> createCellSet() {
    return isEmpty() ? ImmutableSet.<Cell<R, C, V>>of() : new CellSet();
  }

  @WeakOuter

      metadata, client, arg_core_mapping, per_core_arg_shapes, use_tuple_args,
      compilation_result);
  if (comp_status.ok()) {
    phase2_bridge_compilation_status->GetCell(kOldBridgeNoMlirSuccess)
        ->IncrementBy(1);
  } else {
    phase2_bridge_compilation_status->GetCell(kOldBridgeNoMlirFailure)
        ->IncrementBy(1);
  }

  return comp_status;
}

absl::Status CompileMLIRTFFunction(

    LOG_FIRST_N(INFO, 1) << "Skipping Graph Decomposition Pass, decomposition"
                            " library was not found";
    return absl::OkStatus();
  }

  tf_core_op_expansion_graph_counter->GetCell()->IncrementBy(1);

  LOG_FIRST_N(INFO, 1) << "Run Graph Decomposition Passes";

  TF_RETURN_IF_ERROR(DecomposeGraph(module));

  LOG_FIRST_N(INFO, 1) << "Finish Graph Decomposition Passes";

                    host != null && host.length() == 0 ) {
            spec = "//" + spec;
            limit += 2;
        }
        super.parseURL( u, spec, start, limit );
        path = u.getPath();
        ref = u.getRef();
        if (ref != null) {
            path += '#' + ref;
        }
        port = u.getPort();
        if( port == -1 ) {
            port = getDefaultPort();
        }

            spec = "//" + spec;
            limit += 2;
        }
        super.parseURL(u, spec, start, limit);
        path = u.getPath();
        ref = u.getRef();
        if ( ref != null ) {
            path += '#' + ref;
        }
        port = u.getPort();
        if ( port == -1 ) {
            port = getDefaultPort();
        }

  auto op_name = op->getName();
  auto name_string = op_name.getStringRef().str();
  auto op_legality = OperationLegalityString(op, target);

  mlir_failed_legalization_count->GetCell(name_string, op_legality)
      ->IncrementBy(1);
}

mlir::LogicalResult ApplyPatterns(Operation *op, RewritePatternSet &patterns,
                                  bool legalize_chlo) {
  ConversionTarget target =