Revert "Print more information about threading by default"

This reverts commit 0373e6b.

Author: Roman Dubtsov

tensorflow/core/common_runtime/direct_session.cc

@@ -92,7 +92,7 @@ Status NewThreadPoolFromThreadPoolOptions(
   const string& name = thread_pool_options.global_name();
   if (name.empty()) {
     // Session-local threadpool.
-    VLOG(0) << "Direct session inter op parallelism threads for pool "
+    VLOG(1) << "Direct session inter op parallelism threads for pool "
             << pool_number << ": " << num_threads;
     *pool = new thread::ThreadPool(
         options.env, ThreadOptions(), strings::StrCat("Compute", pool_number),
@@ -253,23 +253,19 @@ DirectSession::DirectSession(const SessionOptions& options,
       operation_timeout_in_ms_(options_.config.operation_timeout_in_ms()) {
   const int thread_pool_size =
       options_.config.session_inter_op_thread_pool_size();
-  LOG(INFO) << "thread_pool_size=" << thread_pool_size << "\n";
   if (thread_pool_size > 0) {
     for (int i = 0; i < thread_pool_size; ++i) {
       thread::ThreadPool* pool = nullptr;
       bool owned = false;
-      LOG(INFO) << "creating thread pool #" << i << "\n";
       init_error_.Update(NewThreadPoolFromThreadPoolOptions(
           options_, options_.config.session_inter_op_thread_pool(i), i, &pool,
           &owned));
       thread_pools_.emplace_back(pool, owned);
     }
   } else if (options_.config.use_per_session_threads()) {
-    LOG(INFO) << "using per-session thread pools\n";
     thread_pools_.emplace_back(NewThreadPoolFromSessionOptions(options_),
                                true /* owned */);
   } else {
-    LOG(INFO) << "using global thread pools\n";
     thread_pools_.emplace_back(GlobalThreadPool(options), false /* owned */);
     // Run locally if environment value of TF_NUM_INTEROP_THREADS is negative
     // and config.inter_op_parallelism_threads is unspecified or negative.
@@ -279,7 +275,6 @@ DirectSession::DirectSession(const SessionOptions& options,
          env_num_threads < 0)) {
       run_in_caller_thread_ = true;
     }
-    LOG(INFO) << "run_in_caller_thread_=" << run_in_caller_thread_ << "\n";
   }
   // The default value of sync_on_finish will be flipped soon and this
   // environment variable will be removed as well.
@@ -590,14 +585,14 @@ Status DirectSession::RunInternal(int64 step_id, const RunOptions& run_options,
     if (executors_and_keys->items.size() > 1) {
       pool = thread_pools_[0].first;
     } else {
-      VLOG(0) << "Executing Session::Run() synchronously!";
+      VLOG(1) << "Executing Session::Run() synchronously!";
     }
   }
 
   std::unique_ptr<RunHandler> handler;
   if (ShouldUseRunHandlerPool(run_options) &&
       run_options.experimental().use_run_handler_pool()) {
-    VLOG(0) << "Using RunHandler to scheduler inter-op closures.";
+    VLOG(1) << "Using RunHandler to scheduler inter-op closures.";
     handler = GetOrCreateRunHandlerPool(options_)->Get();
   }
   auto* handler_ptr = handler.get();

tensorflow/core/common_runtime/process_util.cc

@@ -125,7 +125,7 @@ int32 NumInterOpThreadsFromSessionOptions(const SessionOptions& options) {
 thread::ThreadPool* NewThreadPoolFromSessionOptions(
     const SessionOptions& options) {
   const int32 num_threads = NumInterOpThreadsFromSessionOptions(options);
-  LOG(INFO) << "Direct session inter op parallelism threads: " << num_threads;
+  VLOG(1) << "Direct session inter op parallelism threads: " << num_threads;
   return new thread::ThreadPool(
       options.env, ThreadOptions(), "Compute", num_threads,
       !options.config.experimental().disable_thread_spinning(),

tensorflow/core/platform/posix/env.cc

@@ -22,7 +22,6 @@ limitations under the License.
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
-#include <sys/syscall.h>
 #include <time.h>
 #include <unistd.h>
 
@@ -53,12 +52,7 @@ class StdThread : public Thread {
   // thread_options is ignored.
   StdThread(const ThreadOptions& thread_options, const string& name,
             std::function<void()> fn)
-      : thread_([fn, name](){
-              LOG(INFO)
-              << " LWP " << (int)syscall(__NR_gettid)
-              << " has name " << name << "\n";
-              fn();
-              }) {
+      : thread_(fn) {
     mutex_lock l(name_mutex);
     GetThreadNameRegistry().emplace(thread_.get_id(), name);
   }