X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a04d968fb2054d0ba895ddabb2b86f0ff42fd4aa..e080adacaf1ba847ad467f5b8d21da385636ed3c:/src/simdag/sd_daxloader.cpp

diff --git a/src/simdag/sd_daxloader.cpp b/src/simdag/sd_daxloader.cpp
index b98851100e..4131660a6e 100644
--- a/src/simdag/sd_daxloader.cpp
+++ b/src/simdag/sd_daxloader.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2018. The SimGrid Team.
+/* Copyright (c) 2009-2020. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -11,17 +11,18 @@
 #include "xbt/misc.h"
 #include <algorithm>
 #include <map>
-
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_daxparse, sd, "Parsing DAX files");
+#include <stdexcept>
 
 #include "dax_dtd.h"
 #include "dax_dtd.c"
 
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_daxparse, sd, "Parsing DAX files");
+
 /* Ensure that transfer tasks have unique names even though a file is used several times */
 void uniq_transfer_task_name(SD_task_t task)
 {
-  SD_task_t child = *(task->successors->begin());
-  SD_task_t parent = *(task->predecessors->begin());
+  const_SD_task_t child  = *(task->successors->begin());
+  const_SD_task_t parent = *(task->predecessors->begin());
 
   std::string new_name =
       std::string(SD_task_get_name(parent)) + "_" + SD_task_get_name(task) + "_" + SD_task_get_name(child);
@@ -29,30 +30,31 @@ void uniq_transfer_task_name(SD_task_t task)
   SD_task_set_name(task, new_name.c_str());
 }
 
-static bool children_are_marked(SD_task_t task){
+static bool children_are_marked(const_SD_task_t task)
+{
   return std::none_of(task->successors->begin(), task->successors->end(),
                       [](const SD_task_t& elm) { return not elm->marked; }) &&
          std::none_of(task->outputs->begin(), task->outputs->end(),
                       [](const SD_task_t& elm) { return not elm->marked; });
 }
 
-static bool parents_are_marked(SD_task_t task){
+static bool parents_are_marked(const_SD_task_t task)
+{
   return std::none_of(task->predecessors->begin(), task->predecessors->end(),
                       [](const SD_task_t& elm) { return not elm->marked; }) &&
          std::none_of(task->inputs->begin(), task->inputs->end(), [](const SD_task_t& elm) { return not elm->marked; });
 }
 
-bool acyclic_graph_detail(xbt_dynar_t dag){
+bool acyclic_graph_detail(const_xbt_dynar_t dag)
+{
   unsigned int count;
   bool all_marked = true;
   SD_task_t task = nullptr;
   std::vector<SD_task_t> current;
-  xbt_dynar_foreach(dag,count,task){
-    if(task->kind != SD_TASK_COMM_E2E){
-      if(task->successors->empty() && task->outputs->empty())
-        current.push_back(task);
-    }
-  }
+  xbt_dynar_foreach (dag, count, task)
+    if (task->kind != SD_TASK_COMM_E2E && task->successors->empty() && task->outputs->empty())
+      current.push_back(task);
+
   while (not current.empty()) {
     std::vector<SD_task_t> next;
     for (auto const& t : current) {
@@ -209,7 +211,7 @@ xbt_dynar_t SD_daxload(const char *filename)
   xbt_dynar_foreach(result, cpt, file) {
     if (SD_task_get_kind(file) == SD_TASK_COMM_E2E) {
       uniq_transfer_task_name(file);
-    } else if (SD_task_get_kind(file) == SD_TASK_COMP_SEQ){
+    } else {
       /* If some tasks do not take files as input, connect them to the root
        * if they don't produce files, connect them to the end node.
        */
@@ -219,21 +221,19 @@ xbt_dynar_t SD_daxload(const char *filename)
         if (file->outputs->empty())
           SD_task_dependency_add(file, end_task);
       }
-    } else {
-      THROW_IMPOSSIBLE;
     }
   }
 
   if (not acyclic_graph_detail(result)) {
     XBT_ERROR("The DAX described in %s is not a DAG. It contains a cycle.",
-              simgrid::xbt::Path(filename).getBasename().c_str());
+              simgrid::xbt::Path(filename).get_base_name().c_str());
     xbt_dynar_foreach(result, cpt, file)
       SD_task_destroy(file);
     xbt_dynar_free_container(&result);
-    return nullptr;
-  } else {
-    return result;
+    result = nullptr;
   }
+
+  return result;
 }
 
 void STag_dax__adag()
@@ -241,7 +241,7 @@ void STag_dax__adag()
   try {
     double version = std::stod(std::string(A_dax__adag_version));
     xbt_assert(version == 2.1, "Expected version 2.1 in <adag> tag, got %f. Fix the parser or your file", version);
-  } catch (std::invalid_argument& ia) {
+  } catch (const std::invalid_argument&) {
     throw std::invalid_argument(std::string("Parse error: ") + A_dax__adag_version + " is not a double");
   }
 }
@@ -257,7 +257,7 @@ void STag_dax__job()
     current_job = SD_task_create_comp_seq(name.c_str(), nullptr, runtime);
     jobs.insert({A_dax__job_id, current_job});
     xbt_dynar_push(result, &current_job);
-  } catch (std::invalid_argument& ia) {
+  } catch (const std::invalid_argument&) {
     throw std::invalid_argument(std::string("Parse error: ") + A_dax__job_runtime + " is not a double");
   }
 }
@@ -267,7 +267,7 @@ void STag_dax__uses()
   double size;
   try {
     size = std::stod(std::string(A_dax__uses_size));
-  } catch (std::invalid_argument& ia) {
+  } catch (const std::invalid_argument&) {
     throw std::invalid_argument(std::string("Parse error: ") + A_dax__uses_size + " is not a double");
   }
   bool is_input = (A_dax__uses_link == A_dax__uses_link_input);
@@ -277,7 +277,7 @@ void STag_dax__uses()
   SD_task_t file;
   if (it == files.end()) {
     file = SD_task_create_comm_e2e(A_dax__uses_file, nullptr, size);
-    sd_global->initial_tasks->erase(file);
+    sd_global->initial_tasks.erase(file);
     files[A_dax__uses_file] = file;
   } else {
     file = it->second;