[Refactor] Replace std::tie with structured bindings (#12610)

* [Refactor] Replace std::tie with structured bindings

With C++17 enabled in #12337, using
structured bindings to replace cases where `std::tie` is used to
define local variables.

* Added missing header for <optional>

* Silenced unused variable warnings after structured bindings

This is a bug in gcc version 7, resolved in gcc 8.  While gcc version
7 is used for CI, we'll need to silence unused variable warnings
resulting from using only part of a structured binding.

More information: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81767

Author: Lunderberg

src/auto_scheduler/auto_schedule.cc

@@ -78,9 +78,7 @@ TVM_REGISTER_GLOBAL("auto_scheduler.TuningOptions")
 
 TVM_REGISTER_GLOBAL("auto_scheduler.AutoSchedule")
     .set_body_typed([](SearchPolicy search_policy, TuningOptions tuning_options) {
-      te::Schedule sch;
-      Array<te::Tensor> return_tensors;
-      std::tie(sch, return_tensors) = AutoSchedule(search_policy, tuning_options);
+      auto [sch, return_tensors] = AutoSchedule(search_policy, tuning_options);
       return Array<ObjectRef>{sch, return_tensors};
     });
 }  // namespace auto_scheduler

src/auto_scheduler/compute_dag.cc

@@ -1325,10 +1325,9 @@ State ComputeDAG::InferBound(const State& state) const {
 
   Array<te::Stage> stages;
   StageToAxesMap stage_to_axes;
-  te::Schedule sch;
-  Array<te::Tensor> tensors;
   // Replay steps to tvm::Schedule
-  std::tie(sch, tensors) = ApplySteps(pstate->transform_steps, &stages, &stage_to_axes);
+  auto [sch, tensors] = ApplySteps(pstate->transform_steps, &stages, &stage_to_axes);
+  (void)tensors;  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81767
   sch = sch.normalize_for_feature_extraction();
   // Get bound information from TVM schedule
   Map<IterVar, Range> bounds = te::InferBound(sch);
@@ -1382,9 +1381,8 @@ Array<State> ComputeDAG::InferBound(const Array<State>& states) const {
 }
 
 ComputeDAG ComputeDAG::ReplayAndGetDAG(const Array<Step>& transform_steps) const {
-  te::Schedule sch;
-  Array<te::Tensor> old_tensors;
-  std::tie(sch, old_tensors) = ApplySteps(transform_steps);
+  auto [sch, old_tensors] = ApplySteps(transform_steps);
+  (void)old_tensors;  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81767
   return ComputeDAG(sch);
 }
 
@@ -1481,11 +1479,8 @@ TVM_REGISTER_GLOBAL("auto_scheduler.ComputeDAG")
 
 TVM_REGISTER_GLOBAL("auto_scheduler.ComputeDAGApplyStepsFromState")
     .set_body_typed([](const ComputeDAG& dag, const State& state, int layout_rewrite) {
-      te::Schedule sch;
-      Array<te::Tensor> return_tensors;
-      std::tie(sch, return_tensors) =
-          dag.ApplySteps(state->transform_steps, nullptr, nullptr,
-                         static_cast<LayoutRewriteOption>(layout_rewrite));
+      auto [sch, return_tensors] = dag.ApplySteps(state->transform_steps, nullptr, nullptr,
+                                                  static_cast<LayoutRewriteOption>(layout_rewrite));
       return Array<ObjectRef>{sch, return_tensors};
     });
 

src/auto_scheduler/feature.cc

@@ -952,9 +952,7 @@ class PerStoreFeatureExtractor : public StmtExprVisitor {
         unique_lines = std::max(unique_lines, 1.0f);
       }
 
-      ReuseType reuse_type;
-      float reuse_dis_iter, reuse_dis_bytes, reuse_ct;
-      std::tie(reuse_type, reuse_dis_iter, reuse_dis_bytes, reuse_ct) =
+      auto [reuse_type, reuse_dis_iter, reuse_dis_bytes, reuse_ct] =
           ComputeReuse(t, acc.indices, for_loop_stack_, for_touch_regions_, ana_);
 
       acc_feas.emplace_back();
@@ -1356,10 +1354,7 @@ void GetPerStoreFeatureName(int max_n_bufs, std::vector<std::string>* ret) {
 
 void GetPerStoreFeaturesWorkerFunc(const SearchTask& task, const State& state, int max_n_bufs,
                                    std::vector<float>* feature, std::atomic<int>* error_ct) {
-  te::Schedule sch;
-  Array<te::Tensor> tensors;
-
-  std::tie(sch, tensors) = task->compute_dag.ApplySteps(state->transform_steps);
+  auto [sch, tensors] = task->compute_dag.ApplySteps(state->transform_steps);
 
   // When inlining, replace const matrices with const values.
   // Produces wrong IR, but good enough for feature extraction, and

src/auto_scheduler/search_policy/search_policy.cc

@@ -106,9 +106,7 @@ TVM_REGISTER_GLOBAL("auto_scheduler.SearchPolicyRunCallbacks")
 
 TVM_REGISTER_GLOBAL("auto_scheduler.SearchPolicyContinueSearchOneRound")
     .set_body_typed([](SearchPolicy policy, int num_measure, ProgramMeasurer measurer) {
-      Array<MeasureInput> inputs;
-      Array<MeasureResult> results;
-      std::tie(inputs, results) = policy->ContinueSearchOneRound(num_measure, measurer);
+      auto [inputs, results] = policy->ContinueSearchOneRound(num_measure, measurer);
       return Array<ObjectRef>{inputs, results};
     });
 

src/auto_scheduler/search_policy/sketch_policy_rules.cc

@@ -343,8 +343,7 @@ SketchGenerationRule::ConditionKind RuleCrossThreadReduction::MeetCondition(
   const auto& op = state->stages[stage_id]->op;
   if (op->IsInstance<te::ComputeOpNode>()) {
     // Compute the product of lengths of all space iters and all reduce iters
-    int cum_space_len, cum_reduce_len;
-    std::tie(cum_space_len, cum_reduce_len) =
+    auto [cum_space_len, cum_reduce_len] =
         GetCumulativeSpaceAndReductionLength(state->stages[stage_id]);
 
     if (NeedsMultilevelTiling(policy.search_task, state, stage_id)) {

src/ir/instrument.cc

@@ -288,10 +288,7 @@ String RenderPassProfiles() {
   os << std::fixed;
 
   while (profiles.size() > 0) {
-    size_t depth;
-    PassProfile::Duration parent_duration;
-    PassProfile* profile;
-    std::tie(depth, parent_duration, profile) = profiles.top();
+    auto [depth, parent_duration, profile] = profiles.top();
     profiles.pop();
 
     // indent depth

src/meta_schedule/database/json_database.cc

@@ -115,9 +115,7 @@ class JSONDatabaseNode : public DatabaseNode {
 
   Workload CommitWorkload(const IRModule& mod) {
     // Try to insert `mod` into `workloads_`
-    decltype(this->workloads2idx_)::iterator it;
-    bool inserted = false;
-    std::tie(it, inserted) =
+    auto [it, inserted] =
         this->workloads2idx_.emplace(Workload(mod, tvm::StructuralHash()(mod)), -1);
     Workload workload = it->first;
     // If `mod` is new in `workloads2idx_`, append it to the workload file

src/meta_schedule/mutator/mutate_compute_location.cc

@@ -86,9 +86,7 @@ std::vector<MutateComputeLocationNode::Candidate> MutateComputeLocationNode::Fin
       int old_decision = Downcast<Integer>(decision)->value;
 
       // Step 2. Collect all the compute_at locations.
-      Array<tir::StmtSRef> location_srefs;
-      std::vector<int> location_indices;
-      std::tie(location_srefs, location_indices) = CollectComputeLocation(sch->state(), block_sref);
+      auto [location_srefs, location_indices] = CollectComputeLocation(sch->state(), block_sref);
       // Step 3. Remove the old decision.
       auto it = std::find(location_indices.begin(), location_indices.end(), old_decision);
       if (it != location_indices.end()) {

src/meta_schedule/schedule_rule/cross_thread_reduction.cc

@@ -64,15 +64,11 @@ class CrossThreadReductionNode : public ScheduleRuleNode {
     // Step 2. Check the opportunity for block fusion. We say "fusible", if we can compute-at the
     // block to its consumers. We want to fuse as much as possible because it results in
     // significantly faster schedule.
-    bool fusible = false;
     // `target_loop` is the loop position where the input block will be computed at.
-    tir::LoopRV target_loop{nullptr};
     // `target_block` is the consumer block that we want to compute-at the input block to.
-    tir::BlockRV target_block{nullptr};
     // `tgt_block_innermost_loop` is the innermost loop outside the target block.
-    tir::LoopRV tgt_block_innermost_loop{nullptr};
 
-    std::tie(fusible, target_loop, target_block, tgt_block_innermost_loop) =
+    auto [fusible, target_loop, target_block, tgt_block_innermost_loop] =
         GetComputeTargetLoopAndBlock(tmp_sch, block_rv);
 
     // Step 3. Try block fusion.

src/meta_schedule/space_generator/post_order_apply.cc

@@ -140,9 +140,7 @@ class PostOrderApplyNode : public SpaceGeneratorNode {
       result.clear();
       while (!stack.empty()) {
         // get the stack.top()
-        tir::Schedule sch;
-        Array<tir::BlockRV> blocks;
-        std::tie(sch, blocks) = stack.back();
+        auto [sch, blocks] = stack.back();
         stack.pop_back();
         // if all blocks are visited
         if (blocks.empty()) {