Identify what's causing segmentation fault in Yambo - Revision history

Daniele at 10:07, 23 February 2024

2024-02-23T10:07:40Z

Claudio at 08:11, 11 January 2021

2021-01-11T08:11:12Z

← Older revision		Revision as of 08:11, 11 January 2021
Line 14:		Line 14:
	## Change the number of processors		## Change the number of processors
	## Use automatic parallelization, unset all parallel variable in input		## Use automatic parallelization, unset all parallel variable in input
	## Try to disable MPI parallelism by doing <code>yambo -nompi</~~cope~~> and/or OPEN-MP parallelism by doing <code>yambo -noopenmp</code>		## Try to disable MPI parallelism by doing <code>yambo -nompi</code> and/or OPEN-MP parallelism by doing <code>yambo -noopenmp</code>
	## Compile yambo without MPI and run in serial		## Compile yambo without MPI and run in serial
	# '''Optimization''': use a lower optimization level for example -O1 or -O0, by doing <code>./configure FCFLAGS="-O0" FFLAGS="-O1"</code>		# '''Optimization''': use a lower optimization level for example -O1 or -O0, by doing <code>./configure FCFLAGS="-O0" FFLAGS="-O1"</code>

Claudio at 08:10, 11 January 2021

2021-01-11T08:10:57Z

← Older revision		Revision as of 08:10, 11 January 2021
Line 14:		Line 14:
	## Change the number of processors		## Change the number of processors
	## Use automatic parallelization, unset all parallel variable in input		## Use automatic parallelization, unset all parallel variable in input
	## ~~Run~~ in serial		## Try to disable MPI parallelism by doing <code>yambo -nompi</cope> and/or OPEN-MP parallelism by doing <code>yambo -noopenmp</code>
			## Compile yambo without MPI and run in serial
	# '''Optimization''': use a lower optimization level for example -O1 or -O0, by doing <code>./configure FCFLAGS="-O0" FFLAGS="-O1"</code>		# '''Optimization''': use a lower optimization level for example -O1 or -O0, by doing <code>./configure FCFLAGS="-O0" FFLAGS="-O1"</code>
	# '''Compilers''': change C/Fortran compiler if it is possible, move form intel fortran to gfortran or vice-versa. <br>In order to set compilers in the configure use <code>./configure FC=ifort F77=ifort CC=icc</code> for Intel and <code>./configure FC=gfortran F77=gfortran CC=gcc</code> for gfortran.		# '''Compilers''': change C/Fortran compiler if it is possible, move form intel fortran to gfortran or vice-versa. <br>In order to set compilers in the configure use <code>./configure FC=ifort F77=ifort CC=icc</code> for Intel and <code>./configure FC=gfortran F77=gfortran CC=gcc</code> for gfortran.

Claudio at 08:06, 11 January 2021

2021-01-11T08:06:23Z

← Older revision		Revision as of 08:06, 11 January 2021
Line 15:		Line 15:
	## Use automatic parallelization, unset all parallel variable in input		## Use automatic parallelization, unset all parallel variable in input
	## Run in serial		## Run in serial
	# '''Optimization''': use a lower optimization level for example -O1 or -O0, by doing <code>./configure FCFLAGS="-O0" ~~F77FLAGS~~="-O1"</code>		# '''Optimization''': use a lower optimization level for example -O1 or -O0, by doing <code>./configure FCFLAGS="-O0" FFLAGS="-O1"</code>
	# '''Compilers''': change C/Fortran compiler if it is possible, move form intel fortran to gfortran or vice-versa. <br>In order to set compilers in the configure use <code>./configure FC=ifort F77=ifort CC=icc</code> for Intel and <code>./configure FC=gfortran F77=gfortran CC=gcc</code> for gfortran.		# '''Compilers''': change C/Fortran compiler if it is possible, move form intel fortran to gfortran or vice-versa. <br>In order to set compilers in the configure use <code>./configure FC=ifort F77=ifort CC=icc</code> for Intel and <code>./configure FC=gfortran F77=gfortran CC=gcc</code> for gfortran.
	<br>		<br>

Attacc at 21:04, 10 January 2021

2021-01-10T21:04:35Z

← Older revision		Revision as of 21:04, 10 January 2021
Line 26:		Line 26:
	## for g-fortran compiler <code>./configure FCFLAGS="-O1 -g -fcheck=all" UFLAGS="-O0 -g -fcheck=all" FFLAGS="-O1 -g -fcheck=all" --enable-keep-src"</code>		## for g-fortran compiler <code>./configure FCFLAGS="-O1 -g -fcheck=all" UFLAGS="-O0 -g -fcheck=all" FFLAGS="-O1 -g -fcheck=all" --enable-keep-src"</code>
	## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>		## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>
	# '''Use a debugger''': Compile with debugging options<br>		# '''Use a debugger''': Compile with debugging options<br> for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br> for intel fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br> then execute the job in a debugger for example <code>[https://www.gnu.org/software/gdb/ gdb] --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]
	for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br>
	for intel fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br>
	then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]
	# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>		# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>

Attacc at 21:03, 10 January 2021

2021-01-10T21:03:04Z

← Older revision		Revision as of 21:03, 10 January 2021
Line 26:		Line 26:
	## for g-fortran compiler <code>./configure FCFLAGS="-O1 -g -fcheck=all" UFLAGS="-O0 -g -fcheck=all" FFLAGS="-O1 -g -fcheck=all" --enable-keep-src"</code>		## for g-fortran compiler <code>./configure FCFLAGS="-O1 -g -fcheck=all" UFLAGS="-O0 -g -fcheck=all" FFLAGS="-O1 -g -fcheck=all" --enable-keep-src"</code>
	## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>		## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>
	# '''Use a debugger''': Compile with debugging options		# '''Use a debugger''': Compile with debugging options<br>
	* for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code>		for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br>
	* for intel fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code>		for intel fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br>
	then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]		then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]
	# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>		# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>

Attacc at 21:02, 10 January 2021

2021-01-10T21:02:25Z

← Older revision		Revision as of 21:02, 10 January 2021
Line 26:		Line 26:
	## for g-fortran compiler <code>./configure FCFLAGS="-O1 -g -fcheck=all" UFLAGS="-O0 -g -fcheck=all" FFLAGS="-O1 -g -fcheck=all" --enable-keep-src"</code>		## for g-fortran compiler <code>./configure FCFLAGS="-O1 -g -fcheck=all" UFLAGS="-O0 -g -fcheck=all" FFLAGS="-O1 -g -fcheck=all" --enable-keep-src"</code>
	## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>		## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>
	# '''Use a debugger''': Compile with debugging options ~~<br>~~		# '''Use a debugger''': Compile with debugging options
	## for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code~~><br~~>		* for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code>
	## for intel fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code~~><br~~>		* for intel fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code>
	then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]		then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]
	# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>		# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>

Attacc at 21:00, 10 January 2021

2021-01-10T21:00:21Z

← Older revision		Revision as of 21:00, 10 January 2021
Line 27:		Line 27:
	## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>		## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>
	# '''Use a debugger''': Compile with debugging options <br>		# '''Use a debugger''': Compile with debugging options <br>
	** for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br>		## for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br>
	** for intel fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br>		## for intel fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br>
	then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]		then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]
	# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>		# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>

Attacc at 20:59, 10 January 2021

2021-01-10T20:59:44Z

← Older revision		Revision as of 20:59, 10 January 2021
Line 27:		Line 27:
	## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>		## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>
	# '''Use a debugger''': Compile with debugging options <br>		# '''Use a debugger''': Compile with debugging options <br>
	for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br>		** for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br>
	for ~~intelb~~ fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br>		** for intel fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br>
	then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]		then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]
	# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>		# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>

Attacc at 20:59, 10 January 2021

2021-01-10T20:59:12Z

← Older revision		Revision as of 20:59, 10 January 2021
Line 27:		Line 27:
	## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>		## for intel fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>
	# '''Use a debugger''': Compile with debugging options <br>		# '''Use a debugger''': Compile with debugging options <br>
	for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br>		for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br>
	for intelb fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br>		for intelb fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br>
	then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]		then execute the job in a debugger for example <code>gdb --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]
	# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>		# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>

← Older revision		Revision as of 10:07, 23 February 2024
Line 1:		Line 1:
	There may be different reasons why the Yambo code generates segmentation faults in a run.<br>		There may be different reasons why the Yambo code generates segmentation faults in a run.<br>
	To help Yambo developers understand where the problem lies and help you, please follow the steps below.		To help Yambo developers understand where the problem lies and help you, please follow the steps below.
	If one of the step solves your problem and please report the result in the [http://www.yambo-code.~~org~~/forum/ forum].		If one of the step solves your problem, and please report the result in the [http://www.yambo-code.eu/forum/ forum].


	'''Rule out possible causes of the segmentation fault:'''		'''Rule out possible causes of the segmentation fault:'''

	# '''GPU''': recompile without GPU support, remove the <code>--enable-cuda</code> flag. If this ~~solve~~ the problem report the bug in forum GPU section [http://www.yambo-code.~~org~~/forum/viewforum.php?f=38 Yambo on GPU machines].		# '''GPU''': recompile without GPU support, remove the <code>--enable-cuda</code> flag. If this solves the problem report the bug in forum GPU section [http://www.yambo-code.eu/forum/viewforum.php?f=38 Yambo on GPU machines].
	# '''OPEN-MP''': compile and run Yambo without open-mp support, no <code>--enable-open-mp</code> flag in the configure and <code>OMP_NUM_THREADS="1"</code>.		# '''OPEN-MP''': compile and run Yambo without open-mp support, no <code>--enable-open-mp</code> flag in the configure and <code>OMP_NUM_THREADS="1"</code>.
	# '''Lapack/Blas''': use internal Lapack/Blas. Reconfigure Yambo with the flag <code>--enable-int-linalg</code>, recompile and run our job again.		# '''Lapack/Blas''': use internal Lapack/Blas. Reconfigure Yambo with the flag <code>--enable-int-linalg</code>, recompile and run our job again.
	# '''FFT''': compile Yambo with internal FFT libraries <code>--enable-internal-fftsg</code> .		# '''FFT''': compile Yambo with internal FFT libraries <code>--enable-internal-fftsg</code>.
	# '''Scalapack''': compile without Scalpack, unset the flag <code>--with-scalapack-libs</code>.		# '''Scalapack''': compile without Scalpack, unset the flag <code>--with-scalapack-libs</code>.
	# '''Parallelism'''		# '''Parallelism'''
Line 17:		Line 17:
	## Compile yambo without MPI and run in serial		## Compile yambo without MPI and run in serial
	# '''Optimization''': use a lower optimization level for example -O1 or -O0, by doing <code>./configure FCFLAGS="-O0" FFLAGS="-O1"</code>		# '''Optimization''': use a lower optimization level for example -O1 or -O0, by doing <code>./configure FCFLAGS="-O0" FFLAGS="-O1"</code>
	# '''Compilers''': change C/Fortran compiler if it is possible, move ~~form~~ intel ~~fortran~~ to gfortran or vice-versa. <br>In order to set compilers in the configure use <code>./configure FC=ifort F77=ifort CC=icc</code> for Intel and <code>./configure FC=gfortran F77=gfortran CC=gcc</code> for gfortran.		# '''Compilers''': change C/Fortran compiler if it is possible, move from intel Fortran to gfortran or vice-versa. <br>In order to set compilers in the configure, use <code>./configure FC=ifort F77=ifort CC=icc</code> for Intel and <code>./configure FC=gfortran F77=gfortran CC=gcc</code> for gfortran.
	<br>		<br>
	If no one of the previous steps solved your problem, contact us again in the [http://www.yambo-code.~~org~~/forum/ forum]. <br>		If no one of the previous steps solved your problem, contact us again in the [http://www.yambo-code.eu/forum/ forum]. <br>
	If you want you can try to debug Yambo and identity the origin of segmentation fault following the steps below. This will help developers to find a solution to the problem more quickly: <br>		If you want you can try to debug Yambo and identity the origin of segmentation fault following the steps below. This will help developers to find a solution to the problem more quickly: <br>

	'''Debugging the segmentation fault:'''		'''Debugging the segmentation fault:'''
Line 26:		Line 26:
	# '''Checking options''': compile Yambo with the compiler checking options and run again your simulation, then report the result in the forum:		# '''Checking options''': compile Yambo with the compiler checking options and run again your simulation, then report the result in the forum:
	## for g-fortran compiler <code>./configure FCFLAGS="-O1 -g -fcheck=all" UFLAGS="-O0 -g -fcheck=all" FFLAGS="-O1 -g -fcheck=all" --enable-keep-src"</code>		## for g-fortran compiler <code>./configure FCFLAGS="-O1 -g -fcheck=all" UFLAGS="-O0 -g -fcheck=all" FFLAGS="-O1 -g -fcheck=all" --enable-keep-src"</code>
	## for intel ~~fortran~~ <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>		## for intel Fortran <code>./configure FCFLAGS="-O1 -g -CB -CA -debug" UFLAGS="-O0 -g -CB -CA -debug" FFLAGS="-O1 -g -CB -CA -debug" --enable-keep-src"</code>
	# '''Use a debugger''': Compile with debugging options<br> for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br> for intel ~~fortran~~ <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br> then execute the job in a debugger for example <code>[https://www.gnu.org/software/gdb/ gdb] --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]		# '''Use a debugger''': Compile with debugging options<br> for g-fortran compiler <code>./configure FCFLAGS="-Og -g" UFLAGS="-Og -g" FFLAGS="-Og -g" --enable-keep-src" CFLAGS="-g"</code><br> for intel Fortran <code>./configure FCFLAGS="-O1 -g -debug" UFLAGS="-O0 -g -debug" FFLAGS="-O1 -g -debug" --enable-keep-src" CFLAGS="-g -debug"</code><br> then execute the job in a debugger for example <code>[https://www.gnu.org/software/gdb/ gdb] --args yambo -F yambo_input.in</code>. It can work also in parallel see [https://www.open-mpi.org/faq/?category=debugging here] and [https://stackoverflow.com/questions/329259/how-do-i-debug-an-mpi-program here]
	# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>		# '''Memory leaks''': [only for experts] compile Yambo with debugging options then run your job with [https://valgrind.org/ valgrind]: <code>valgrind --tool=memcheck --leak-check=summary ./yambo</code>