Avoid some over-inlined routines. Reduces code size of TensorFlow binaries

considerably.  Shrinks text size of example_trainer binary by ~1.5%.
Change: 115578002

1 files changed, 3 insertions, 67 deletions

diff --git a/tensorflow/core/framework/unique_tensor_references.h b/tensorflow/core/framework/unique_tensor_references.h
index 2e08a9825f..f587348d9b 100644
--- a/tensorflow/core/framework/unique_tensor_references.h
+++ b/tensorflow/core/framework/unique_tensor_references.h
@@ -35,78 +35,14 @@ class UniqueTensorReferences {
  public:
   UniqueTensorReferences() : frozen_(false), referenced_tensors_set_(nullptr) {}
 
-  ~UniqueTensorReferences() {
-    if (!frozen_) {
-      // The references were not retrieved so discard them to avoid
-      // leaking memory.
-      TensorReferenceVector refs;
-      FreezeAndReturnReferences(&refs);
-      for (auto& tensor : refs) {
-        tensor.Unref();
-      }
-    }
-    delete referenced_tensors_set_;
-  }
+  ~UniqueTensorReferences();
 
   // Adds a reference to tensor if its buffer is not already referenced.
-  void Add(const Tensor& tensor) {
-    DCHECK(!frozen_);
-    // Do nothing if the tensor has a null buffer.
-    if (tensor.IsInitialized()) {
-      if (referenced_tensors_set_ != nullptr) {
-        // There are enough tensors that we are using a hash set to
-        // de-duplicate.
-        const TensorReference tensor_ref(tensor);
-        if (!referenced_tensors_set_->insert(tensor_ref).second) {
-          // The tensor was a duplicate, so discard the reference.
-          tensor_ref.Unref();
-        }
-      } else {
-        for (size_t i = 0; i < referenced_tensors_vector_.size(); ++i) {
-          if (referenced_tensors_vector_[i].SharesBufferWith(tensor)) {
-            // tensor is a duplicate, so nothing to do.
-            return;
-          }
-        }
-        referenced_tensors_vector_.push_back(TensorReference(tensor));
-        if (kInVector == referenced_tensors_vector_.size()) {
-          // There are too many tensors to keep using the N^2 algorithm
-          // so start de-duplicating using a set.
-          // Transfer the refs from the vector to the set.
-          DCHECK(referenced_tensors_set_ == nullptr);
-          referenced_tensors_set_ = new ReferencedTensorsSet;
-          referenced_tensors_set_->reserve(kInVector);
-          referenced_tensors_set_->insert(referenced_tensors_vector_.begin(),
-                                          referenced_tensors_vector_.end());
-          DCHECK_EQ(kInVector, referenced_tensors_set_->size());
-          referenced_tensors_vector_.clear();
-        }
-      }
-    }
-  }
+  void Add(const Tensor& tensor);
 
   // No more references may be added after this is called. The unique
   // references are returning in out_vector.
-  void FreezeAndReturnReferences(TensorReferenceVector* out_vector) {
-    // Prevent any further additions.
-    frozen_ = true;
-    if (referenced_tensors_set_ != nullptr) {
-      DCHECK(referenced_tensors_vector_.empty());
-      out_vector->reserve(referenced_tensors_set_->size());
-      for (const auto& ref : *referenced_tensors_set_) {
-        out_vector->push_back(ref);
-      }
-      referenced_tensors_set_->clear();
-      delete referenced_tensors_set_;
-      referenced_tensors_set_ = nullptr;
-    } else {
-      out_vector->reserve(referenced_tensors_vector_.size());
-      for (const auto& ref : referenced_tensors_vector_) {
-        out_vector->push_back(ref);
-      }
-      referenced_tensors_vector_.clear();
-    }
-  }
+  void FreezeAndReturnReferences(TensorReferenceVector* out_vector);
 
  private:
   // Up to kInVector elements are stored in reference_tensors_vector_