added pretty print of elapsed time to main.rs and fixed minor indentation errors in doc

Author: zommiommy

README.md

@@ -16,34 +16,34 @@ provides simple ways to manage very large graphs, exploiting modern compression
 techniques. More precisely, it is currently made of:
 
 - A set of simple codes, called ζ _codes_, which are particularly suitable for
- storing web graphs (or, in general, integers with a power-law distribution in a
- certain exponent range).
+  storing web graphs (or, in general, integers with a power-law distribution in a
+  certain exponent range).
 
 - Algorithms for compressing web graphs that exploit gap compression and
- differential compression (à la
- [LINK](http://www.hpl.hp.com/techreports/Compaq-DEC/SRC-RR-175.html)),
- intervalisation, and ζ codes to provide a high compression ratio (see [our
- datasets](http://law.di.unimi.it/datasets.php)). The algorithms are controlled
- by several parameters, which provide different tradeoffs between access speed
- and compression ratio.
+  differential compression (à la
+  [LINK](http://www.hpl.hp.com/techreports/Compaq-DEC/SRC-RR-175.html)),
+  intervalisation, and ζ codes to provide a high compression ratio (see [our
+  datasets](http://law.di.unimi.it/datasets.php)). The algorithms are controlled
+  by several parameters, which provide different tradeoffs between access speed
+  and compression ratio.
 
 - Algorithms for accessing a compressed graph without actually decompressing
- it, using lazy techniques that delay the decompression until it is actually
- necessary.
+  it, using lazy techniques that delay the decompression until it is actually
+  necessary.
 
 - Algorithms for analysing very large graphs, such as {@link
- it.unimi.dsi.webgraph.algo.HyperBall}, which has been used to show that
- Facebook has just [four degrees of
- separation](http://vigna.di.unimi.it/papers.php#BBRFDS).
+  it.unimi.dsi.webgraph.algo.HyperBall}, which has been used to show that
+  Facebook has just [four degrees of
+  separation](http://vigna.di.unimi.it/papers.php#BBRFDS).
 
 - A [Java implementation](http://webgraph.di.unimi.it/) of the algorithms above,
   now in maintenance mode.
 
 - This crate, providing a complete, documented implementation of the algorithms
   above in Rust. It is free software distributed under either the  [GNU Lesser
- General Public License
- 2.1+](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html) or the [Apache
- Software License 2.0](https://www.apache.org/licenses/LICENSE-2.0).
+  General Public License
+  2.1+](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html) or the [Apache
+  Software License 2.0](https://www.apache.org/licenses/LICENSE-2.0).
 
 - [Data sets](http://law.di.unimi.it/datasets.php) for large graph (e.g.,
   billions of links).
@@ -107,7 +107,7 @@ for_!((src, succ) in graph {
 ## More Options
 
 - By starting from the [`BVGraphSeq`] class you can obtain an instance that does
-not need the `BASENAME.ef` file, but provides only [iteration].
+  not need the `BASENAME.ef` file, but provides only [iteration].
 
 - Graphs can be labeled by [zipping] them together with a [labeling]. In fact,
   graphs are just labelings with `usize` labels.

src/algo/llp/mod.rs

@@ -67,9 +67,9 @@ pub mod preds;
 ///   [par_apply](crate::traits::SequentialLabeling::par_apply).
 /// * `gammas` - The ɣ values to use in the LLP algorithm.
 /// * `num_threads` - The number of threads to use. If `None`, the number of
-/// threads is set to [`num_cpus::get`].
+///   threads is set to [`num_cpus::get`].
 /// * `chunk_size` - The chunk size used to randomize the permutation. This is
-/// an advanced option: see
+///   an advanced option: see
 ///   [par_apply](crate::traits::SequentialLabeling::par_apply).
 /// * `granularity` - The granularity of the parallel processing expressed as
 ///   the number of arcs to process at a time. If `None`, the granularity is

src/graphs/bvgraph/codecs/factories.rs

@@ -14,7 +14,7 @@ Implementations of the [`BitReaderFactory`] trait can be used to create
 bit readers accessing a graph data using different techniques.
 - [`FileFactory`] uses a [std::fs::File] to create a bit reader.
 - [`MemoryFactory`] creates bit readers from a slice of memory,
-either [allocated](MemoryFactory::new_mem) or [mapped](MemoryFactory::new_mmap).
+  either [allocated](MemoryFactory::new_mem) or [mapped](MemoryFactory::new_mmap).
 - [`MmapHelper`] can be used to create a bit reader from a memory-mapped file.
 
 Any factory can be plugged either into a

src/graphs/bvgraph/random_access.rs

@@ -57,14 +57,14 @@ where
     ///
     /// # Arguments
     /// - `reader_factory`: backend that can create objects that allows
-    /// us to read the bitstream of the graph to decode the edges.
+    ///   us to read the bitstream of the graph to decode the edges.
     /// - `offsets`: the bit offset at which we will have to start for decoding
-    /// the edges of each node. (This is needed for the random accesses,
-    /// [`BVGraphSeq`] does not need them)
+    ///   the edges of each node. (This is needed for the random accesses,
+    ///   [`BVGraphSeq`] does not need them)
     /// - `min_interval_length`: the minimum size of the intervals we are going
-    /// to decode.
+    ///   to decode.
     /// - `compression_window`: the maximum distance between two nodes that
-    /// reference each other.
+    ///   reference each other.
     /// - `number_of_nodes`: the number of nodes in the graph.
     /// - `number_of_arcs`: the number of arcs in the graph.
     ///

src/main.rs

@@ -11,6 +11,7 @@ use clap_complete::shells::Shell;
 use webgraph::{build_info, cli};
 
 pub fn main() -> Result<()> {
+    let start = std::time::Instant::now();
     env_logger::builder()
         .filter_level(log::LevelFilter::Debug)
         .try_init()?;
@@ -92,5 +93,50 @@ pub fn main() -> Result<()> {
         simplify,
         to_csv,
         transpose
-    )
+    )?;
+
+    log::info!(
+        "The command took {}",
+        pretty_print_elapsed(start.elapsed().as_secs_f64())
+    );
+
+    Ok(())
+}
+
+/// Pretty print the elapsed seconds in a human readable format.
+fn pretty_print_elapsed(elapsed: f64) -> String {
+    let mut result = String::new();
+    let mut elapsed_seconds = elapsed as u64;
+    let weeks = elapsed_seconds / (60 * 60 * 24 * 7);
+    elapsed_seconds %= 60 * 60 * 24 * 7;
+    let days = elapsed_seconds / (60 * 60 * 24);
+    elapsed_seconds %= 60 * 60 * 24;
+    let hours = elapsed_seconds / (60 * 60);
+    elapsed_seconds %= 60 * 60;
+    let minutes = elapsed_seconds / 60;
+    //elapsed_seconds %= 60;
+
+    match weeks {
+        0 => {}
+        1 => result.push_str("1 week "),
+        _ => result.push_str(&format!("{} weeks ", weeks)),
+    }
+    match days {
+        0 => {}
+        1 => result.push_str("1 day "),
+        _ => result.push_str(&format!("{} days ", days)),
+    }
+    match hours {
+        0 => {}
+        1 => result.push_str("1 hour "),
+        _ => result.push_str(&format!("{} hours ", hours)),
+    }
+    match minutes {
+        0 => {}
+        1 => result.push_str("1 minute "),
+        _ => result.push_str(&format!("{} minutes ", minutes)),
+    }
+
+    result.push_str(&format!("{:.3} seconds ({}s)", elapsed % 60.0, elapsed));
+    result
 }