Method Compute

tensorflow/core/kernels/string_split_op.cc:606–642

  }

  void Compute(OpKernelContext* ctx) override {
    const Tensor* input_tensor;
    OP_REQUIRES_OK(ctx, ctx->input("input", &input_tensor));
    OP_REQUIRES(ctx, TensorShapeUtils::IsVector(input_tensor->shape()),
                errors::InvalidArgument("input must be a vector, got shape: ",
                                        input_tensor->shape().DebugString()));

    const auto input_vec = input_tensor->vec<string>();
    const int64 batch_size = input_vec.dimension(0);

    const Tensor* sep_tensor;
    OP_REQUIRES_OK(ctx, ctx->input("sep", &sep_tensor));
    OP_REQUIRES(ctx, TensorShapeUtils::IsScalar(sep_tensor->shape()),
                errors::InvalidArgument("sep must be a scalar, got shape: ",
                                        sep_tensor->shape().DebugString()));
    const auto sep_vec = sep_tensor->flat<string>();
    StringPiece sep(sep_vec(0));

    uint64 start = 0;
    uint64 end = 0;

    if (element_cost_ == 0 && batch_size) {
      size_t sample_id = rand() % batch_size;
      std::vector<StringPiece> temp_for_warm_up =
          SplitV2(input_vec(sample_id), sep, maxsplit_);
      start = Env::Default()->NowNanos();
      temp_for_warm_up = SplitV2(input_vec(sample_id), sep, maxsplit_);
      end = Env::Default()->NowNanos();
      element_cost_ = end -start;
    }
    uint64 element_cost = element_cost_;
    if (element_cost * batch_size >= parallel_limit_) {
      ParallelSplitV2(ctx, input_vec, batch_size, sep);
    } else {
      SequentialSplitV2(ctx, input_vec, batch_size, sep);
    }
  }

 private:
  int maxsplit_;