Using c10 namespace across caffe2. (pytorch#12714)

Summary:
Pull Request resolved: pytorch#12714

This is a short change to enable c10 namespace in caffe2. We did not enable
it before due to gflags global variable confusion, but it should have been
mostly cleaned now. Right now, the plan on record is that namespace caffe2 and
namespace aten will fully be supersets of namespace c10.

Most of the diff is codemod, and only two places of non-codemod is in caffe2/core/common.h, where

```
using namespace c10;
```

is added, and in Flags.h, where instead of creating aliasing variables in c10 namespace, we directly put it in the global namespace to match gflags (and same behavior if gflags is not being built with).

Reviewed By: dzhulgakov

Differential Revision: D10390486

fbshipit-source-id: 5e2df730e28e29a052f513bddc558d9f78a23b9b

Author: Yangqing Jia

aten/src/ATen/core/TensorImpl.h

@@ -594,11 +594,10 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target {
       } else {
         reset_tensor = storage_.capacity() <
                 (storage_offset_ + numel_) * storage_.itemsize() ||
-            !c10::FLAGS_caffe2_keep_on_shrink ||
+            !FLAGS_caffe2_keep_on_shrink ||
             storage_.capacity() -
                     (storage_offset_ + numel_) * storage_.itemsize() >
-                static_cast<size_t>(
-                    c10::FLAGS_caffe2_max_keep_on_shrink_memory);
+                static_cast<size_t>(FLAGS_caffe2_max_keep_on_shrink_memory);
       }
 
       if (reset_tensor && !is_init) {

binaries/caffe2_benchmark.cc

@@ -78,19 +78,19 @@ int main(int argc, char** argv) {
   benchmark(
       argc,
       argv,
-      c10::FLAGS_backend,
-      c10::FLAGS_init_net,
-      c10::FLAGS_input,
-      c10::FLAGS_input_dims,
-      c10::FLAGS_input_file,
-      c10::FLAGS_input_type,
-      c10::FLAGS_iter,
-      c10::FLAGS_net,
-      c10::FLAGS_output,
-      c10::FLAGS_output_folder,
-      c10::FLAGS_run_individual,
-      c10::FLAGS_sleep_before_run,
-      c10::FLAGS_text_output,
-      c10::FLAGS_warmup,
-      c10::FLAGS_wipe_cache);
+      FLAGS_backend,
+      FLAGS_init_net,
+      FLAGS_input,
+      FLAGS_input_dims,
+      FLAGS_input_file,
+      FLAGS_input_type,
+      FLAGS_iter,
+      FLAGS_net,
+      FLAGS_output,
+      FLAGS_output_folder,
+      FLAGS_run_individual,
+      FLAGS_sleep_before_run,
+      FLAGS_text_output,
+      FLAGS_warmup,
+      FLAGS_wipe_cache);
 }

binaries/convert_caffe_image_db.cc

@@ -37,9 +37,9 @@ int main(int argc, char** argv) {
   caffe2::GlobalInit(&argc, &argv);
 
   std::unique_ptr<DB> in_db(caffe2::db::CreateDB(
-      c10::FLAGS_input_db_type, c10::FLAGS_input_db, caffe2::db::READ));
+      FLAGS_input_db_type, FLAGS_input_db, caffe2::db::READ));
   std::unique_ptr<DB> out_db(caffe2::db::CreateDB(
-      c10::FLAGS_output_db_type, c10::FLAGS_output_db, caffe2::db::NEW));
+      FLAGS_output_db_type, FLAGS_output_db, caffe2::db::NEW));
   std::unique_ptr<Cursor> cursor(in_db->NewCursor());
   std::unique_ptr<Transaction> transaction(out_db->NewTransaction());
   int count = 0;
@@ -80,7 +80,7 @@ int main(int argc, char** argv) {
       data->set_byte_data(buffer, datum.data().size());
     }
     transaction->Put(cursor->key(), protos.SerializeAsString());
-    if (++count % c10::FLAGS_batch_size == 0) {
+    if (++count % FLAGS_batch_size == 0) {
       transaction->Commit();
       LOG(INFO) << "Converted " << count << " items so far.";
     }

binaries/convert_db.cc

@@ -33,15 +33,15 @@ int main(int argc, char** argv) {
   caffe2::GlobalInit(&argc, &argv);
 
   std::unique_ptr<DB> in_db(caffe2::db::CreateDB(
-      c10::FLAGS_input_db_type, c10::FLAGS_input_db, caffe2::db::READ));
+      FLAGS_input_db_type, FLAGS_input_db, caffe2::db::READ));
   std::unique_ptr<DB> out_db(caffe2::db::CreateDB(
-      c10::FLAGS_output_db_type, c10::FLAGS_output_db, caffe2::db::NEW));
+      FLAGS_output_db_type, FLAGS_output_db, caffe2::db::NEW));
   std::unique_ptr<Cursor> cursor(in_db->NewCursor());
   std::unique_ptr<Transaction> transaction(out_db->NewTransaction());
   int count = 0;
   for (; cursor->Valid(); cursor->Next()) {
     transaction->Put(cursor->key(), cursor->value());
-    if (++count % c10::FLAGS_batch_size == 0) {
+    if (++count % FLAGS_batch_size == 0) {
       transaction->Commit();
       LOG(INFO) << "Converted " << count << " items so far.";
     }

binaries/convert_encoded_to_raw_leveldb.cc

@@ -16,8 +16,8 @@
 
 // This script converts an image dataset to leveldb.
 //
-// c10::FLAGS_input_folder is the root folder that holds all the images, and
-// c10::FLAGS_list_file should be a list of files as well as their labels, in
+// FLAGS_input_folder is the root folder that holds all the images, and
+// FLAGS_list_file should be a list of files as well as their labels, in
 // the format as
 //   subfolder1/file1.JPEG 7
 //   ....
@@ -41,7 +41,7 @@ C10_DEFINE_bool(color, true, "If set, load images in color.");
 C10_DEFINE_int(
     scale,
     256,
-    "If c10::FLAGS_raw is set, scale all the images' shorter edge to the given "
+    "If FLAGS_raw is set, scale all the images' shorter edge to the given "
     "value.");
 C10_DEFINE_bool(warp, false, "If warp is set, warp the images to square.");
 
@@ -93,7 +93,7 @@ void ConvertToRawDataset(
   data->set_data_type(TensorProto::BYTE);
   data->add_dims(0);
   data->add_dims(0);
-  if (c10::FLAGS_color) {
+  if (FLAGS_color) {
     data->add_dims(3);
   }
   string value;
@@ -108,21 +108,20 @@ void ConvertToRawDataset(
     const string& encoded_image = input_protos.protos(0).string_data(0);
     int encoded_size = encoded_image.size();
     cv::Mat img = cv::imdecode(
-        cv::Mat(1, &encoded_size, CV_8UC1,
-        const_cast<char*>(encoded_image.data())),
-        c10::FLAGS_color ? cv::IMREAD_COLOR : cv::IMREAD_GRAYSCALE);
+        cv::Mat(
+            1, &encoded_size, CV_8UC1, const_cast<char*>(encoded_image.data())),
+        FLAGS_color ? cv::IMREAD_COLOR : cv::IMREAD_GRAYSCALE);
     cv::Mat resized_img;
     int scaled_width, scaled_height;
-    if (c10::FLAGS_warp) {
-      scaled_width = c10::FLAGS_scale;
-      scaled_height = c10::FLAGS_scale;
+    if (FLAGS_warp) {
+      scaled_width = FLAGS_scale;
+      scaled_height = FLAGS_scale;
     } else if (img.rows > img.cols) {
-      scaled_width = c10::FLAGS_scale;
-      scaled_height =
-          static_cast<float>(img.rows) * c10::FLAGS_scale / img.cols;
+      scaled_width = FLAGS_scale;
+      scaled_height = static_cast<float>(img.rows) * FLAGS_scale / img.cols;
     } else {
-      scaled_height = c10::FLAGS_scale;
-      scaled_width = static_cast<float>(img.cols) * c10::FLAGS_scale / img.rows;
+      scaled_height = FLAGS_scale;
+      scaled_width = static_cast<float>(img.cols) * FLAGS_scale / img.rows;
     }
     cv::resize(img, resized_img, cv::Size(scaled_width, scaled_height), 0, 0,
                  cv::INTER_LINEAR);
@@ -131,7 +130,7 @@ void ConvertToRawDataset(
     DCHECK(resized_img.isContinuous());
     data->set_byte_data(
         resized_img.ptr(),
-        scaled_height * scaled_width * (c10::FLAGS_color ? 3 : 1));
+        scaled_height * scaled_width * (FLAGS_color ? 3 : 1));
     output_protos.SerializeToString(&value);
     // Put in db
     batch->Put(iter->key(), value);
@@ -153,7 +152,6 @@ void ConvertToRawDataset(
 
 int main(int argc, char** argv) {
   caffe2::GlobalInit(&argc, &argv);
-  caffe2::ConvertToRawDataset(
-      c10::FLAGS_input_db_name, c10::FLAGS_output_db_name);
+  caffe2::ConvertToRawDataset(FLAGS_input_db_name, FLAGS_output_db_name);
   return 0;
 }

binaries/convert_image_to_tensor.cc

@@ -44,15 +44,15 @@ namespace caffe2 {
 cv::Mat resizeImage(cv::Mat& img) {
   cv::Mat resized_img;
   int scaled_width, scaled_height;
-  if (c10::FLAGS_warp) {
-    scaled_width = c10::FLAGS_scale;
-    scaled_height = c10::FLAGS_scale;
+  if (FLAGS_warp) {
+    scaled_width = FLAGS_scale;
+    scaled_height = FLAGS_scale;
   } else if (img.rows > img.cols) {
-    scaled_width = c10::FLAGS_scale;
-    scaled_height = static_cast<float>(img.rows) * c10::FLAGS_scale / img.cols;
+    scaled_width = FLAGS_scale;
+    scaled_height = static_cast<float>(img.rows) * FLAGS_scale / img.cols;
   } else {
-    scaled_height = c10::FLAGS_scale;
-    scaled_width = static_cast<float>(img.cols) * c10::FLAGS_scale / img.rows;
+    scaled_height = FLAGS_scale;
+    scaled_width = static_cast<float>(img.cols) * FLAGS_scale / img.rows;
   }
   cv::resize(
       img,
@@ -87,9 +87,9 @@ std::vector<float> convertToVector(cv::Mat& img) {
   std::vector<float> mean(3, 0);
   std::vector<float> std(3, 1);
   bool bgrtorgb = false;
-  assert(img.cols == c10::FLAGS_scale);
-  assert(img.rows == c10::FLAGS_scale);
-  vector<string> steps = caffe2::split(',', c10::FLAGS_preprocess);
+  assert(img.cols == FLAGS_scale);
+  assert(img.rows == FLAGS_scale);
+  vector<string> steps = caffe2::split(',', FLAGS_preprocess);
   for (int i = 0; i < steps.size(); i++) {
     auto step = steps[i];
     if (step == "subtract128") {
@@ -112,8 +112,8 @@ std::vector<float> convertToVector(cv::Mat& img) {
     }
   }
 
-  int C = c10::FLAGS_color ? 3 : 1;
-  int total_size = C * c10::FLAGS_scale * c10::FLAGS_scale;
+  int C = FLAGS_color ? 3 : 1;
+  int total_size = C * FLAGS_scale * FLAGS_scale;
   std::vector<float> values(total_size);
   if (C == 1) {
     cv::MatIterator_<uchar> it, end;
@@ -130,9 +130,9 @@ std::vector<float> convertToVector(cv::Mat& img) {
     for (it = img.begin<cv::Vec3b>(), end = img.end<cv::Vec3b>(); it != end;
          ++it, i++) {
       values[i] = (((*it)[b] / normalize[0] - mean[0]) / std[0]);
-      int offset = c10::FLAGS_scale * c10::FLAGS_scale + i;
+      int offset = FLAGS_scale * FLAGS_scale + i;
       values[offset] = (((*it)[g] / normalize[1] - mean[1]) / std[1]);
-      offset = c10::FLAGS_scale * c10::FLAGS_scale + offset;
+      offset = FLAGS_scale * FLAGS_scale + offset;
       values[offset] = (((*it)[r] / normalize[2] - mean[2]) / std[2]);
     }
   }
@@ -145,8 +145,7 @@ std::vector<float> convertOneImage(std::string& filename) {
   std::cout << "Converting " << filename << std::endl;
   // Load image
   cv::Mat img = cv::imread(
-      filename,
-      c10::FLAGS_color ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
+      filename, FLAGS_color ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
 
   cv::Mat crop = cropToSquare(img);
 
@@ -155,17 +154,17 @@ std::vector<float> convertOneImage(std::string& filename) {
   // Assert we don't have to deal with alignment
   DCHECK(resized_img.isContinuous());
   assert(resized_img.rows == resized_img.cols);
-  assert(resized_img.rows == c10::FLAGS_scale);
+  assert(resized_img.rows == FLAGS_scale);
   std::vector<float> one_image_values = convertToVector(resized_img);
   return one_image_values;
 }
 
 void convertImages() {
   vector<string> file_names;
-  if (c10::FLAGS_input_images != "") {
-    file_names = caffe2::split(',', c10::FLAGS_input_images);
-  } else if (c10::FLAGS_input_image_file != "") {
-    std::ifstream infile(c10::FLAGS_input_image_file);
+  if (FLAGS_input_images != "") {
+    file_names = caffe2::split(',', FLAGS_input_images);
+  } else if (FLAGS_input_image_file != "") {
+    std::ifstream infile(FLAGS_input_image_file);
     std::string line;
     while (std::getline(infile, line)) {
       vector<string> file_name = caffe2::split(',', line);
@@ -181,7 +180,7 @@ void convertImages() {
     assert(false);
   }
   std::vector<std::vector<float>> values;
-  int C = c10::FLAGS_color ? 3 : 1;
+  int C = FLAGS_color ? 3 : 1;
   for (int i = 0; i < file_names.size(); i++) {
     std::vector<float> one_image_values = convertOneImage(file_names[i]);
     values.push_back(one_image_values);
@@ -193,19 +192,19 @@ void convertImages() {
   data->set_data_type(TensorProto::FLOAT);
   data->add_dims(values.size());
   data->add_dims(C);
-  data->add_dims(c10::FLAGS_scale);
-  data->add_dims(c10::FLAGS_scale);
+  data->add_dims(FLAGS_scale);
+  data->add_dims(FLAGS_scale);
 
   for (int i = 0; i < values.size(); i++) {
-    assert(values[i].size() == C * c10::FLAGS_scale * c10::FLAGS_scale);
+    assert(values[i].size() == C * FLAGS_scale * FLAGS_scale);
     for (int j = 0; j < values[i].size(); j++) {
       data->add_float_data(values[i][j]);
     }
   }
-  if (c10::FLAGS_text_output) {
-    caffe2::WriteProtoToTextFile(protos, c10::FLAGS_output_tensor);
+  if (FLAGS_text_output) {
+    caffe2::WriteProtoToTextFile(protos, FLAGS_output_tensor);
   } else {
-    caffe2::WriteProtoToBinaryFile(protos, c10::FLAGS_output_tensor);
+    caffe2::WriteProtoToBinaryFile(protos, FLAGS_output_tensor);
   }
 }
 

binaries/db_throughput.cc

@@ -40,11 +40,11 @@ using caffe2::string;
 
 void TestThroughputWithDB() {
   std::unique_ptr<DB> in_db(caffe2::db::CreateDB(
-      c10::FLAGS_input_db_type, c10::FLAGS_input_db, caffe2::db::READ));
+      FLAGS_input_db_type, FLAGS_input_db, caffe2::db::READ));
   std::unique_ptr<Cursor> cursor(in_db->NewCursor());
-  for (int iter_id = 0; iter_id < c10::FLAGS_repeat; ++iter_id) {
+  for (int iter_id = 0; iter_id < FLAGS_repeat; ++iter_id) {
     caffe2::Timer timer;
-    for (int i = 0; i < c10::FLAGS_report_interval; ++i) {
+    for (int i = 0; i < FLAGS_report_interval; ++i) {
       string key = cursor->key();
       string value = cursor->value();
       //VLOG(1) << "Key " << key;
@@ -58,15 +58,15 @@ void TestThroughputWithDB() {
         "Iteration %03d, took %4.5f seconds, throughput %f items/sec.\n",
         iter_id,
         elapsed_seconds,
-        c10::FLAGS_report_interval / elapsed_seconds);
+        FLAGS_report_interval / elapsed_seconds);
   }
 }
 
 void TestThroughputWithReaderWorker(const DBReader* reader, int thread_id) {
   string key, value;
-  for (int iter_id = 0; iter_id < c10::FLAGS_repeat; ++iter_id) {
+  for (int iter_id = 0; iter_id < FLAGS_repeat; ++iter_id) {
     caffe2::Timer timer;
-    for (int i = 0; i < c10::FLAGS_report_interval; ++i) {
+    for (int i = 0; i < FLAGS_report_interval; ++i) {
       reader->Read(&key, &value);
     }
     double elapsed_seconds = timer.Seconds();
@@ -76,14 +76,14 @@ void TestThroughputWithReaderWorker(const DBReader* reader, int thread_id) {
         thread_id,
         iter_id,
         elapsed_seconds,
-        c10::FLAGS_report_interval / elapsed_seconds);
+        FLAGS_report_interval / elapsed_seconds);
   }
 }
 
 void TestThroughputWithReader() {
-  caffe2::db::DBReader reader(c10::FLAGS_input_db_type, c10::FLAGS_input_db);
+  caffe2::db::DBReader reader(FLAGS_input_db_type, FLAGS_input_db);
   std::vector<std::unique_ptr<std::thread>> reading_threads(
-      c10::FLAGS_num_read_threads);
+      FLAGS_num_read_threads);
   for (int i = 0; i < reading_threads.size(); ++i) {
     reading_threads[i].reset(new std::thread(
         TestThroughputWithReaderWorker, &reader, i));
@@ -95,7 +95,7 @@ void TestThroughputWithReader() {
 
 int main(int argc, char** argv) {
   caffe2::GlobalInit(&argc, &argv);
-  if (c10::FLAGS_use_reader) {
+  if (FLAGS_use_reader) {
     TestThroughputWithReader();
   } else {
     TestThroughputWithDB();