"saved to checkpoint.");
    return "";
  }

  auto assigned_value_operand = assign_var_op.getOperand(1);
  auto const_op =
      llvm::dyn_cast<mlir::TF::ConstOp>(assigned_value_operand.getDefiningOp());
  if (!const_op) {
    assign_var_op->emitRemark(
        "Operand idx 1 is not a tf.ConstOp. The initializing tensor is not "
        "saved to checkpoint.");
    return "";
  }

|kubelet/dockershim | Feb 3, 2017 | [[CRI] Implement Dockershim Checkpoint](https://github.com/kubernetes/kubernetes/pull/39903)
|devicemanager| Sep 6, 2017 | [Deviceplugin checkpoint](https://github.com/kubernetes/kubernetes/pull/51744)
| kubelet/pod | Nov 22, 2017 | [Initial basic bootstrap-checkpoint support](https://github.com/kubernetes/kubernetes/pull/50984)

package errors

import "fmt"

// ErrCorruptCheckpoint error is reported when checksum does not match
var ErrCorruptCheckpoint = fmt.Errorf("checkpoint is corrupted")

// ErrCheckpointNotFound is reported when checkpoint is not found for a given key

      bundle_reader->Lookup(kObjectGraphProtoKey, &object_graph_tensor),
      "SavedModel checkpoint does not contain object graph.");
  if (object_graph_tensor.dtype() != DT_STRING ||
      object_graph_tensor.dims() != 0 ||
      object_graph_tensor.NumElements() != 1) {
    return absl::Status(
        absl::StatusCode::kFailedPrecondition,
        "SavedModel checkpoint object graph was not the correct type.");
  }

// Name of the TensorFlow Operation to be fetched to save the variables to
// checkpoint. This save op follows the SavedModel's load semantics, so it
// should return the file prefix of the checkpoint as a string tensor.
inline constexpr StringRef kTfQuantSaveOpName = "tf_quant__save_op";

// Name the file prefix string tensor. The tensor is used to identify the prefix
// to the checkpoint where the variables are saved / loaded. This may be present

limitations under the License.
*/

package testing

import "k8s.io/kubernetes/pkg/kubelet/checkpointmanager"

var _ checkpointmanager.Checkpoint = &MockCheckpoint{}

// MockCheckpoint struct is used for mocking checkpoint values in testing
type MockCheckpoint struct {
	Content string
}

// MarshalCheckpoint returns fake content
func (mc *MockCheckpoint) MarshalCheckpoint() ([]byte, error) {

 * <p>
 * This works by watching a daemon registry in a background thread, recording each state change.
 * As the state changes, it is tested against the next checkpoint. If the state of the checkpoint matches,
 * then the process repeats with the next checkpoint (until all checkpoints are passed).
 *
 * If there is no state change detected in a specified interval, an assertion error will be thrown.
 *

#include "tensorflow/c/eager/abstract_context.h"
#include "tensorflow/c/eager/abstract_tensor_handle.h"

namespace tensorflow {
namespace ops {

// Restores tensors from a V2 checkpoint.
Status RestoreV2(AbstractContext* ctx, AbstractTensorHandle* const prefix,
                 AbstractTensorHandle* const tensor_names,
                 AbstractTensorHandle* const shape_and_slices,

  // Reads and returns a checkpoint key associated with a variable.
  //
  // The variable is identified by the index in the object graph node list.
  //
  // RestoreV2 is the operation that will ultimately be responsible for reading
  // and restoring the variable(s)' values.  Variable values are indexed in the
  // checkpoint files by "checkpoint keys".  These keys along with dtype and

// returns whether a checkpoint is possible: whether the pDst bytes written to
// dst so far won't need changing as we see more source bytes.
type mapFunc func(*context) bool

// A spanFunc takes a context set to the current rune and returns whether this
// rune would be altered when written to the output. It may advance the context
// to the next rune. It returns whether a checkpoint is possible.
type spanFunc func(*context) bool