Method Initialize

tensorflow/lite/delegates/gpu/cl/api.cc:545–588

        graph_(std::move(graph)) {}

  Status Initialize() {
    // Select precision based on given options.
    CalculationsPrecision precision = CalculationsPrecision::F32;
    if (options_.allow_precision_loss) {
      precision = options_.priority == InferencePriority::MAX_PRECISION
                      ? CalculationsPrecision::F32_F16
                      : CalculationsPrecision::F16;
    }

    // Increase precision if not supported.
    if (!environment_->IsSupported(precision)) {
      precision = CalculationsPrecision::F32_F16;
      if (!environment_->IsSupported(precision)) {
        precision = CalculationsPrecision::F32;
      }
    }

    context_ = absl::make_unique<InferenceContext>();
    InferenceContext::CreateInferenceInfo create_info;
    create_info.precision = precision;
    create_info.storage_type = GetOptimalStorageType(environment_->device());
    create_info.hints.Add(ModelHints::kReduceKernelsCount);
    // TODO(sorokin) temporary hack to speed up init time in some cases.
    // TODO(sorokin): move this check to the place where hint is applied.
    if ((precision == CalculationsPrecision::F16 ||
         precision == CalculationsPrecision::F32_F16) &&
        create_info.storage_type == TensorStorageType::TEXTURE_ARRAY &&
        environment_->device().IsAdreno6xxOrHigher()) {
      create_info.hints.Add(ModelHints::kFastTuning);
    }
    RETURN_IF_ERROR(
        context_->InitFromGraph(create_info, *graph_, environment_));

    if (env_options_.IsGlAware()) {
      gl_interop_fabric_ = absl::make_unique<GlInteropFabric>(
          env_options_.egl_display, environment_);
    }
    tie_factory_ = absl::make_unique<TensorTieFactory>(
        environment_, context_.get(), gl_interop_fabric_.get());

    inputs_ = LinkTensors(graph_->inputs());
    outputs_ = LinkTensors(graph_->outputs());
    return OkStatus();
  }

  std::vector<TensorObjectDef> inputs() const override {
    return GetExternalDefinitions(inputs_);