A profiler is a performance analysis tool used in software development. It measures the behavior of a program by collecting data on various aspects such as execution time, memory usage, and CPU usage. Profilers help developers identify performance bottlenecks and optimize their code. There are several types of profilers, each focusing on different aspects of performance:
- CPU Profiler: Measures which parts of the code are consuming the most CPU time. This helps in identifying functions or methods that are slowing down the execution of the program.
- Memory Profiler: Tracks memory usage of the application, identifying memory leaks and inefficient memory allocation that can lead to excessive memory consumption.
- I/O Profiler: Monitors input/output operations, such as file reads and writes, and network activity, helping to identify slow I/O operations that may be impacting performance.
- Concurrency Profiler: Analyzes multi-threaded or parallel applications, identifying issues such as thread contention, deadlocks, and suboptimal thread usage.

Profilers are essential tools for performance analysis and optimization in software development. They provide detailed insights into various performance aspects, helping developers improve the efficiency and effectiveness of their applications. Converting profiler output into dot graphs can aid in the visual analysis of performance data, making it easier to understand and address performance issues.

## Example Profilers
- **gprof**: A GNU profiler that produces a flat profile and a call graph, showing the time spent in each function and the call hierarchy.
- **Valgrind**: A memory profiler that can detect memory leaks, memory corruption, and other memory-related issues.
- **perf**: A performance analysis tool for Linux that can profile CPU, cache usage, and other hardware events.
- **VisualVM**: A visual tool for profiling Java applications, providing insights into CPU and memory usage, thread activity, and more.
- **Instruments**: A profiling tool for macOS and iOS applications, part of Xcode, that provides a variety of performance metrics.

---

# Using `gprof` and `gprof2dot` to obtain plots

1. Install `gprof2dot`
  ```
  pip install gprof2dot
  ```
1. Make sure certain flags are disabled
  ```Makefile
  CXXFLAGS += -pg # Generate extra code to write profile information suitable for the analysis program prof (for -p) or gprof (for -pg)
  #CXXFLAGS += -O3 -fno-stack-protector # we don't want any optimization
  ```
1. Compile the program with whatever build system tool you are using.
  ```sh
  make
  ```
1. Use `gprof` profiler to analyze the performance of the executable
  ```sh
  gprof /path/to/executable > flat_profile.txt
  ```
1. Obtain the graph plot from the profile performance
  ```sh
  \cat flat_profile.txt | gprof2dot | dot -Tpng -o output.png 
  ```

The final result is something like

![](https://raw.githubusercontent.com/jrfonseca/gprof2dot/c63fb2e098770d49a0a94d743266bef5cc144092/sample.svg)

# Utilize `sanitize` flags to detect issues (memory errors, undefined behavior, thread race conditions, etc.)
1. Add flags to Makefile
  ```
  #CXXFLAGS += -O3 -fno-stack-protector
  # CXXFLAGS += -pg
  CXXFLAGS += -ggdb3
  CXXFLAGS += -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=null -fno-sanitize=alignment -fsanitize-address-use-after-scope
  ```
1. Run the executable with these flags.

# Use Valgrind: A memory profiler that can detect memory leaks, memory corruption, and other memory-related issues.

1. Download [Valgrind](https://valgrind.org/downloads/)
2. Add flags to Makefile
  ```Makefile
  #CXXFLAGS += -O3 -fno-stack-protector
  # CXXFLAGS += -pg
  CXXFLAGS += -ggdb3
  ```
1. Run valgrind along with some imporant flags
  ```
  valgrind --leak-check=full --track-origins=yes /path/to/executable --flags --of --the --executable
  ```