Typos

Author: lorenzotomada

.gitignore

@@ -200,3 +200,6 @@ skbuild/*
 # files from profiling
 *.lprof
 *Profiling*
+
+# SLURM logs
+*dtsc*

README.md

@@ -36,7 +36,7 @@ In order to solve an eigenvalue problem, we considered multiple strategies.
 1. The most trivial one was to implement the power method in order to be able to compute (at least) the biggest eigenvalue. We then used `numba` to try and optimize it, but in this case just-in-time compilation was not extremely beneficial.The implementation of the power method is contained in `eigenvalues.py`.
 2. Lanczos + QR: this is an approach (tailored to the case of symmetric matrices) to compute *all* the eigenvalues and eigenvectors. Notice that, also in the case of the QR method,`numba` was not very beneficial in terms of speed-up, resulting in a pretty slow methodology. For this reason, we implemented the QR method in `C++` and used `pybind11` to expose it to `Python`. All the code written in `C++` can be found in `cxx_utils.cpp`.
 3. `CuPy` implementation of all of the above: we implemented all the above methodologies using `CuPy` to see whether using GPU could speed up computations. Since this was not the case, we commented all the lines of code involving `CuPy`, so that installation of the package is no longer required and we can use our code also on machines that do not have GPU.
-4. The core of the project is the implementation (as well as a generalization of the simplified case in which $\rho=\$ considered in our reference) of the _divide et implera_ method for the computation of eigenvalues of a symmetric matrix. Some helpers were originally written in `Python` and then translated to `C++` for efficiency reasons: their original implementation is in `zero_finder.py` and is still present in the project for testing purposes. The translated version can be found in `cxx_utils.cpp`. Instead, the implementation of the actual method to compute the eigenvalues starting from a tridiagonal matrix is contained in `parallel_tridiag_eigen.py` and makes use of `mpi4py`.
+4. The core of the project is the implementation (as well as a generalization of the simplified case in which $\rho=1$ considered in our reference) of the _divide et implera_ method for the computation of eigenvalues of a symmetric matrix. Some helpers were originally written in `Python` and then translated to `C++` for efficiency reasons: their original implementation is in `zero_finder.py` and is still present in the project for testing purposes. The translated version can be found in `cxx_utils.cpp`. Instead, the implementation of the actual method to compute the eigenvalues starting from a tridiagonal matrix is contained in `parallel_tridiag_eigen.py` and makes use of `mpi4py`.
 
 # Results
 The results of the profiling (runtime vs matrix size, memory consumption, scalability, and so on) are discussed in detail in `Documentation.ipynb`.

shell/submit.sbatch

@@ -1,13 +1,12 @@
 #!/bin/bash
 
-#SBATCH --partition=gpu2
+#SBATCH --partition=regular1
 #SBATCH --job-name=dtsc
 #SBATCH --nodes=1
-#SBATCH --gpus=1
-#SBATCH --ntasks-per-node=1
-#SBATCH --gpus-per-task=1
+#SBATCH --ntasks=4
+#SBATCH --cpus-per-task=1
 #SBATCH --mem=10000
-#SBATCH --time=12:00:00
+#SBATCH --time=06:00:00
 #SBATCH [email protected]
 #SBATCH --output=%x.o%j.%N
 #SBATCH --error=%x.e%j.%N
@@ -29,11 +28,12 @@ module load cmake/3.29.1
 module load intel/2021.2
 module load openmpi3/3.1.4
 
+conda init
 conda activate devtools_scicomp
 
 # Ranges over which we iterate
-n_processes=(1 2 4 8)
-matrix_sizes=(10 100 500 1000)
+n_processes=(1 2 4)
+matrix_sizes=(10 15 20)
 
 last_dim="${matrix_sizes[-1]}"
 last_nproc="${n_processes[-1]}"
@@ -69,4 +69,4 @@ done
 # Restore the original config file
 mv ${CONFIG_FILE}.bak $CONFIG_FILE
 
-echo "Experiment completed!"
+echo "Experiment completed!"