==========================================================
Esta es la documentación para compilar y ejecutar su tarea
==========================================================

Se está ejecutando el comando: less README.txt

***************************
*** Para salir: tecla q ***
***************************

Para avanzar a una nueva página: tecla <page down>
Para retroceder a la página anterior: tecla <page up>
Para avanzar una sola línea: tecla <enter>
Para buscar un texto: tecla / seguido del texto (/...texto...)
         por ejemplo: /ddd

-----------------------------------------------

Instrucciones para resolver la tarea

Cree el archivo mutex.c que resuelva el problema con los spinlocks
implementados en test.c. Su solución debe correr correctamente
compilándola de estas 4 formas con pSystem:

make pbin : compilación optimizada
make pbin-g : compilación con opciones de debugging para usar con ddd
make pbin-mg : compilación para verificar el uso correcto de la memoria
make pbin-tg : compilación para verificar la ausencia de dataraces

La ejecución de los binarios resultantes de estas 4 compilaciones debe
felicitarlo porque se aprobaron todos los tests.

Si una de las compilaciones falla, lea atentamente el mensaje de error,
edite el archivo mutex.c y resuelva el problema.

Si la compilación es exitosa pero uno de las ejecuciones no
termina con felicitaciones, deberá depurar su tarea.  Verifique primero
que no hay errores de manejo de memoria o dataraces ejecutando las
compilaciones con make mem y make thread.
Si no presenta este tipo de problema prefiera depurar con ddd la compilación
con make ddd, make ddd-mg (sanitize de memoria) o make ddd-tg (sanitize para
threads).  Al aparecer la ventana de ddd, los programas ya están en ejecución,
pero detenida en nMain.  Presione el botón cont para continuar la ejecución.

Si falla uno de los tests, la ejecución se detendrá justo después del
test que falló.  Vaya al menu Status de ddd y seleccione Backtrace para abrir
una ventana con las funciones en ejecución.  Seleccione alguna de estas
funciones para determinar que sucedió.

Es normal que ddd abra una ventana de diálogo para reclamar porque no
encuentra los fuentes de exit por ejemplo.  Ignore el problema presionando el
botón OK y continúe.

-----------------------------------------------

Limpieza de archivos

make clean: hace limpieza borrando todos los archivos que se pueden volver
            a reconstruir a partir de los fuentes: *.o *.bin* *.a etc.

-----------------------------------------------

Acerca de sanitize

En esta tarea se usa el compilador gcc con la opción -fsanitize=address
para verificar el uso correcto de la memoria.  Es similar a valgrind pero
con ayuda del compilador se logra detectar una variedad más amplia de errores.

Tambien se usa gcc con la opción -fsanitize=thread para detectar
dataraces.  Es similar a valgrind con drd u otros, pero más eficiente.

-----------------------------------------------

Acerca del comando make

El comando make sirve para automatizar el proceso de compilación asegurando
recompilar el archivo binario ejecutable cuando cambió uno de los archivos
fuentes de los cuales depende.

La especificación de los archivos de los cuales depende está en el archivo
Makefile, que es muy complicado de entender.  Es el profesor el que los
elabora.

Durante la invocación, make muestra los comandos que está ejecutando,
junto a otros mensajes.  Ud.  puede invocar manualmente estos comandos
en el terminal y obtendrá el mismo resultado, si los invoca en el
mismo orden.

A veces es útil usar make con la opción -n para que solo muestre
exactamente qué comandos va a ejecutar, sin ejecutarlos de verdad.
Por ejemplo en la tarea 1 la invocación de: make clean; make -n partec-mem
mostrará:

  make --no-print-directory VAR=-mg "OPT=-fsanitize=address -g -DVALGRIND" lib test-disco.pbin-mg

O sea se invoca a sí mismo (recursivamente) pero con otras opciones para
detallar mejor qué trabajo se debe hacer.  La pregunta es qué va a hacer
esta invocación recursiva.  Para ello basta usar nuavemente la opción -n,
es decir invocar el comando: make -n --no-print-directory VAR=-mg "OPT=-fsanitize=address -g -DVALGRIND" lib test-disco.pbin-mg

que mostrará:

  echo "<<< Construccion de npsystem/lib/libpSys-mg.a >>>"
  cd npsystem; make --no-print-directory "SYS=p" "OPT=-fsanitize=address -g -DVALGRIND" "VAR=-mg" lib/libpSys-mg.a
  echo "<<< Construccion terminada >>>"
  cc -fsanitize=address -g -DVALGRIND -Wall -Werror -pedantic -std=c18 -Inpsystem/include discoq.c test.c npsystem/lib/libpSys-mg.a -pthread -o test-discoq.pbin-mg
  echo "Invoke this command to run the executable:" ./test-discoq.pbin-mg
  
¿Qué comandos usaría para determinar que hace make --no-print-directory "SYS=p" "OPT=-fsanitize=address -g -DVALGRIND" "VAR=-mg" lib/libpSys-mg.a?
 
===

También es útil usar make con la opción -B para forzar la recompilación
de los fuentes a pesar de que no han cambiado desde la última compilación.
Por ejemplo:

make -B partec-mem

Recompilará todo lo que corresponde a psystem-mem.
Si a continuacion invoca:

make partec-mem

No recompilará nada porque los fuentes no han cambiado desde la última
compilación.  Eso es útil para no recompilar el nSystem cuando no es necesario.

Si ahora invoca:

make -B partec-mem

Se recompilará todo nuevamente, producto de la opción -B, a pesar de que
los fuentes no han cambiado.
