fix: remove excess task_name/tid clones for ExecState

src/engine/dag.rs

@@ -174,11 +174,10 @@ impl Dag {
     /// - Create a graph from task dependencies.
     /// - Generate task heart sequence according to topological sorting of graph.
     pub(crate) fn init(&mut self) -> Result<(), DagError> {
+        self.execute_states.reserve(self.tasks.len());
         self.tasks.values().for_each(|task| {
-            self.execute_states.insert(
-                task.id(),
-                Arc::new(ExecState::new(task.id(), task.name().to_string())),
-            );
+            self.execute_states
+                .insert(task.id(), Arc::new(ExecState::new()));
         });
 
         self.create_graph()?;

src/engine/mod.rs

@@ -70,19 +70,18 @@ impl Engine {
     /// Given a Dag name, execute this Dag.
     /// Returns true if the given Dag executes successfully, otherwise false.
     pub fn run_dag(&mut self, name: &str) -> bool {
-        if !self.dags.contains_key(name) {
+        if let Some(dag) = self.dags.get(name) {
+            self.runtime.block_on(dag.run())
+        } else {
             error!("No job named '{}'", name);
             false
-        } else {
-            let job = self.dags.get(name).unwrap();
-            self.runtime.block_on(job.run())
         }
     }
 
     /// Execute all the Dags in the Engine in sequence according to the order numbers of the Dags in
     /// the sequence from small to large. The return value is the execution status of all tasks.
     pub fn run_sequential(&mut self) -> Vec<bool> {
-        let mut res = Vec::new();
+        let mut res = Vec::with_capacity(self.sequence.len());
         for seq in 1..self.sequence.len() + 1 {
             let name = self.sequence.get(&seq).unwrap().clone();
             res.push(self.run_dag(name.as_str()));
@@ -92,11 +91,7 @@ impl Engine {
 
     /// Given the name of the Dag, get the execution result of the specified Dag.
     pub fn get_dag_result<T: Send + Sync + Clone + 'static>(&self, name: &str) -> Option<Arc<T>> {
-        if self.dags.contains_key(name) {
-            self.dags.get(name).unwrap().get_result()
-        } else {
-            None
-        }
+        self.dags.get(name).and_then(|dag| dag.get_result())
     }
 }
 

src/task/state.rs

@@ -81,9 +81,6 @@ pub(crate) struct ExecState {
     success: AtomicBool,
     /// Output produced by a task.
     output: AtomicPtr<Output>,
-    /// Task output identified by id.
-    tid: usize,
-    task_name: String,
     /// The semaphore is used to control the synchronous blocking of subsequent tasks to obtain the
     /// execution results of this task.
     /// When a task is successfully executed, the permits inside the semaphore will be increased to
@@ -105,15 +102,13 @@ pub enum Output {
 #[derive(Debug)]
 pub struct Input(Vec<Content>);
 
-#[allow(dead_code)]
 impl ExecState {
     /// Construct a new [`ExeState`].
-    pub(crate) fn new(task_id: usize, task_name: String) -> Self {
+    pub(crate) fn new() -> Self {
+        // initialize the task to failure without output.
         Self {
             success: AtomicBool::new(false),
             output: AtomicPtr::new(std::ptr::null_mut()),
-            tid: task_id,
-            task_name,
             semaphore: Semaphore::new(0),
         }
     }
@@ -145,23 +140,6 @@ impl ExecState {
         self.success.store(true, Ordering::Relaxed)
     }
 
-    pub(crate) fn get_err(&self) -> Option<String> {
-        if let Some(out) = unsafe { self.output.load(Ordering::Relaxed).as_ref() } {
-            out.get_err()
-        } else {
-            None
-        }
-    }
-
-    /// Use id to indicate the output of which task.
-    pub(crate) fn tid(&self) -> usize {
-        self.tid
-    }
-
-    pub(crate) fn task_name(&self) -> &str {
-        &self.task_name
-    }
-
     /// The semaphore is used to control the synchronous acquisition of task output results.
     /// Under normal circumstances, first use the semaphore to obtain a permit, and then call
     /// the `get_output` function to obtain the output. If the current task is not completed

src/yaml/yaml_parser.rs

@@ -77,17 +77,15 @@ impl Parser for YamlParser {
             .as_hash()
             .ok_or(YamlTaskError::StartWordError)?;
 
-        let mut tasks = Vec::new();
-        let mut map = HashMap::new();
+        let mut tasks = Vec::with_capacity(yaml_tasks.len());
+        let mut map = HashMap::with_capacity(yaml_tasks.len());
         // Read tasks
         for (v, w) in yaml_tasks {
             let id = v.as_str().unwrap();
-            let task = if specific_actions.contains_key(id) {
-                let action = specific_actions.remove(id).unwrap();
-                self.parse_one(id, w, Some(action))?
-            } else {
-                self.parse_one(id, w, None)?
-            };
+            let task = specific_actions.remove(id).map_or_else(
+                || self.parse_one(id, w, None),
+                |action| self.parse_one(id, w, Some(action)),
+            )?;
             map.insert(id, task.id());
             tasks.push(task);
         }