small memory optimization

This also now allows you to change the number of max threads

Author: BoisterousCoder

src/main.rs

@@ -1,37 +1,44 @@
 #![allow(non_snake_case)]
 use std::thread;
 use std::env;
-use std::process::Command;
 use std::sync::mpsc::SyncSender;
 use std::sync::mpsc::sync_channel;
 use std::fs::File;
 use std::io::prelude::*;
 use std::time::Instant;
 
-const maxThreads:i8 = 8;
 
 struct CompleteTask{
     startNode: i16,
     paths: Vec<Vec<i16>>,
 }
 
 fn main(){
+    let mut argI:i8 = 0;
     let mut _totalNodes:String = "0".to_string();
+    let mut _maxThreads:String = "8".to_string();
     for argument in env::args() {
-        _totalNodes = argument.to_string();
+        if argI == 1 {
+            _totalNodes = argument.to_string();
+        } else if argI == 2 {
+            _maxThreads = argument.to_string();
+        }
+        argI += 1;
     }
     println!("You have chosen to order numbers upto {}", _totalNodes);
+    println!("You have chosen to hava a max number of threads of {}", _maxThreads);
     let totalNodes:i16 = _totalNodes.parse::<i16>().unwrap();
+    let maxThreads:i8 = _maxThreads.parse::<i8>().unwrap();
     let now = Instant::now();
 
-    let paths = getCore(totalNodes, now);
+    let paths = getCore(totalNodes, maxThreads, now);
 
     let endTime = now.elapsed().as_secs();
     printResult(paths, totalNodes);
     println!("It took aproximately {} seconds to compute", endTime);
 }
 
-fn getCore(totalNodes:i16, now:Instant) -> Vec<Vec<i16>>{
+fn getCore(totalNodes:i16, maxThreads:i8, now:Instant) -> Vec<Vec<i16>>{
     let connections:Vec<[i16; 2]> = findConnections(totalNodes);
     let (sender, reciever) = sync_channel(maxThreads as usize);
     let mut paths:Vec<Vec<i16>> = vec![];
@@ -67,7 +74,7 @@ fn startCalcAsync(startNode:i16, connections:Vec<[i16; 2]>, totalNodes:i16, send
     path.push(startNode);
 
     thread::spawn(move || {
-        let paths = doThread(connections, path, totalNodes);
+        let paths = doThread(connections, &mut path.clone(), totalNodes);
         sender.send(CompleteTask{
             startNode:startNode,
             paths:paths,
@@ -84,7 +91,7 @@ fn printResult(paths:Vec<Vec<i16>>, totalNodes:i16){
             return;
         },
     };
-    let mut completePaths:i16 = 0;
+    let mut completePaths:i32 = 0;
     for path in paths.clone(){
         if path.len() == totalNodes as usize {
             write!(file, "A working path is ");
@@ -102,8 +109,7 @@ fn printResult(paths:Vec<Vec<i16>>, totalNodes:i16){
     println!("All working paths have been outputted to Output.txt");
 }
 
-fn doThread(connections:Vec<[i16; 2]>, _path:Vec<i16>, totalNodes:i16) -> Vec<Vec<i16>>{
-    let mut path = _path.clone();
+fn doThread(connections:Vec<[i16; 2]>, path:&mut Vec<i16>, totalNodes:i16) -> Vec<Vec<i16>>{
     let mut paths:Vec<Vec<i16>> = Vec::with_capacity(totalNodes as usize);
 
     loop{
@@ -128,7 +134,7 @@ fn doThread(connections:Vec<[i16; 2]>, _path:Vec<i16>, totalNodes:i16) -> Vec<Ve
                     let mut newPath = path.clone();
                     newPath.push(connectedTo);
                     let newConnections = connections.clone();
-                    paths.append(&mut doThread(newConnections, newPath, totalNodes));
+                    paths.append(&mut doThread(newConnections, &mut newPath, totalNodes));
                 }
             }
         }
@@ -139,7 +145,7 @@ fn doThread(connections:Vec<[i16; 2]>, _path:Vec<i16>, totalNodes:i16) -> Vec<Ve
         }
     }
 
-    paths.push(path);
+    paths.push(path.clone());
     return paths;
 }