address comments on commit cf346df

tensorflow/compiler/jit/xla_compilation_cache.cc

@@ -55,7 +55,7 @@ constexpr int64 XlaCompilationCache::kDefaultCompilationThreshold;
 
 XlaCompilationCache::XlaCompilationCache(xla::LocalClient* client,
                                          DeviceType device_type)
-    : client_(client), device_type_(std::move(device_type)), async_compilation_() {}
+    : client_(client), device_type_(std::move(device_type)) {}
 
 XlaCompilationCache::~XlaCompilationCache() {
   // Ensure any use of our programs have completed by waiting for all stream
@@ -387,32 +387,33 @@ Status XlaCompilationCache::CompileAsynchronous(
   entry->compile_state = CompileState::kCompiling; // Still under caller's lock.
   {
     mutex_lock lock(async_compilation_.async_compilation_mu_);
-    async_compilation_.nrof_ongoing_compilations++;
+    async_compilation_.num_ongoing_compilations++;
   }
   // Don't move the above code into the thread function!!!
 
   // Passing options by value into the lamba increases the refcount on
   // options.device_allocator, keeping it alive for the duration of the
   // compilation.
   // Passing args by value as well. Doing this here only when an asynchronous
-  // compilation is performed, as copying many argS incurs an overhead.
+  // compilation is performed, as copying many args incurs an overhead.
   async_compilation_.compiler_threads.Schedule([=] {
-      Entry tmp;
+      Entry local_entry;
       VLOG(2) << "Starting asynchronous compilation of cluster "
               << function_name << '.';
-      (void)CompileStrict(&tmp, options, args, function_name, compile_fn);
+      (void)CompileStrict(&local_entry, options, args, function_name,
+                          compile_fn);
       VLOG(2) << "Finished asynchronous compililation of cluster "
               << function_name << '.';
       {
         mutex_lock lock(async_compilation_.async_compilation_mu_);
-        async_compilation_.nrof_ongoing_compilations--;
+        async_compilation_.num_ongoing_compilations--;
       }
       { // Populate original entry with compilation result.
         mutex_lock entry_lock(entry->mu);
-        entry->compilation_result = tmp.compilation_result;
-        entry->compile_state = tmp.compile_state;
-        entry->compilation_status = tmp.compilation_status;
-        entry->executable = std::move(tmp.executable);
+        entry->compilation_result = local_entry.compilation_result;
+        entry->compile_state = local_entry.compile_state;
+        entry->compilation_status = local_entry.compilation_status;
+        entry->executable = std::move(local_entry.executable);
       }
     }
   );
@@ -526,8 +527,8 @@ Status XlaCompilationCache::CompileImpl(
         // asynchronous compilation is enabled.
         {
           mutex_lock lock(async_compilation_.async_compilation_mu_);
-          if (async_compilation_.nrof_ongoing_compilations >=
-                async_compilation_.kMaxNrofOngoingCompilations) {
+          if (async_compilation_.num_ongoing_compilations >=
+                async_compilation_.kMaxNumOngoingCompilations) {
             VLOG(2) << "Not asynchronously compiling cluster " << function_name
                     << " because of too many ongoing compilations.";
             return false;

tensorflow/compiler/jit/xla_compilation_cache.h

@@ -222,21 +222,20 @@ class XlaCompilationCache : public ResourceBase {
     mutex async_compilation_mu_;
 
     // Number of threads for asynchronous compilations.
-    static constexpr int64 kNrofCompilerThreads = 10;
+    static constexpr int64 kNumCompilerThreads = 10;
 
     // Maximum number of ongoing compilations.
-    static constexpr int64 kMaxNrofOngoingCompilations = kNrofCompilerThreads;
+    static constexpr int64 kMaxNumOngoingCompilations = kNumCompilerThreads;
 
     // Pool of threads for asynchronous compilations.
     thread::ThreadPool compiler_threads;
 
     // Number of ongoing compilations.
-    int64 nrof_ongoing_compilations GUARDED_BY(async_compilation_mu_) = 0;
+    int64 num_ongoing_compilations GUARDED_BY(async_compilation_mu_) = 0;
 
     AsyncCompilation()
       : compiler_threads(tensorflow::Env::Default(), "aync_compiler_threads",
-                         kNrofCompilerThreads) {}
-    ~AsyncCompilation() {}
+                         kNumCompilerThreads) {}
 
   } async_compilation_;
 

tensorflow/compiler/jit/xla_platform_info.h

@@ -74,7 +74,7 @@ class XlaPlatformInfo {
   // If the op associated with this XlaPlatformInfo is placed on an XLA device
   // then device_allocator_ is the xla::Backend's memory allocator.  If the op
   // is placed on a regular CPU or GPU device then device_allocator_ is null.
-  // The allocator is of unknowm provenance; keep it in a shared pointer to
+  // The allocator is of unknown provenance; keep it in a shared pointer to
   // set an artificial refcount of one.
   std::shared_ptr<se::DeviceMemoryAllocator> device_allocator_;