controle

ctrl_machine/README.md

@@ -0,0 +1,106 @@
+# Contrôle machine BUT2FI 16/10/2024
+Créez  un répertoire cntr_r3.05, et pour chaque exercice un sous-répertoire (EX1, EX2, EX3) pour y placer vos réponses.
+ 
+Les exercices sont indépendants.
+- EX1 : fichiers, mémoire.
+- EX2 : signaux.
+- EX3 : processus, communication tubes.
+
+> Vous rendrez une archive avec vos réponses [ici](http://www.iut-fbleau.fr/site/site/DEVOIR)
+
+**Même si vous ne faites pas tout ce qui est demandé pour un exercice, donnez une solution modulaire en raffinant les problèmes 
+pour  montrer que vous avez compris et savez faire des choses : gestion de fichiers, gestions processus, etc.**:
+
+
+### EX1
+Écrire en C une commande qui prend en argument 2 noms de fichiers, et qui
+détermine si les deux fichiers  ont le même contenu. 
+
+- Votre commande renverra le code de retour 0 (fichiers	identiques) ou
+ 1 (fichiers différents). Vous testerez d'abord la taille des deux fichiers, et si nécessaire leur 
+ contenu.
+- Utilisez un buffer pour limiter les accès aux fichiers. 
+
+Fonctions et macro utiles :
+
+```c
+int open(const char *pathname, int flags, ...
+                  /* mode_t mode */ );
+int stat(const char *restrict pathname,
+                struct stat *restrict statbuf);
+off_t lseek(int fd, off_t offset, int whence);
+ssize_t read(int fd, void buf[.count], size_t count);
+int memcmp(const void s1[.n], const void s2[.n], size_t n);
+int close(int fd);
+```
+
+
+### EX2 
+
+La suite de syracuse est définie par 
+
+```
+u(n+1) = u(n)/2     si u(n) est pair
+         3*u(n) + 1 sinon 
+``` 
+
+Une conjecture affirme  que quelle que soit  la valeur initiale u(0)  non nul, la
+suite  finit toujours  par valoir  1 (puis  boucler sur  4,2,1). Par  exemple, à
+partir de 14, on construit la suite des nombres : 14, 7, 22, 11, 34, 17, 52, 26,
+13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, ...
+
+On appelle :
+- temps de vol le plus petit indice k tel que u(k) = 1,
+- altitude maximale la plus grande valeur  de la suite durant son temps de vol.
+
+Le programme  [syracuse.c](./src/syracuse.c) calcule, sans  jamais s'arrêter,  le temps de  vol et
+l'altitude maximal  en faisant varier  le terme  initial u(0). On  sauvegarde le
+plus  grand  terme  initiale testé,  le  plus  grand  temps  de vol  obtenu,  et
+l'altitude maximale la plus grande calculée.
+
+A l'aide de l'api des signaux, modifiez le programme pour que :
+
+-  à la réception du signal SIGTSTP (Ctrl-Z depuis le terminal), le programme affiche la
+valeur initiale courante, l’indice du dernier terme calculé et la valeur prise par la suite,
+sans stopper le programme (fonction `infos`),
+- le signal SIGINT (Ctrl-C depuis le terminal) reçu 2 fois dans un intervalle de 2 secondes termine le programme.
+
+Fonctions et macro utiles :
+
+```c
+int sigaction(int signum,
+              const struct sigaction *_Nullable restrict act,
+              struct sigaction *_Nullable restrict oldact);
+unsigned int alarm(unsigned int seconds);
+```
+### EX3
+
+1. Donnez une commande bash qui permet de remplir un fichier avec  avec `n`  int (binaires) aléatoires.
+2. Écrire un programme C `min_max.c` qui prend en argument optionnel un nom de fichier et met en oeuvre le schéma de processus suivant :
+
+```
+P                      -> P1 -                  -> P2
+ \        -------    /        \     --------   /
+  \- >   ()     () -/          \-> ()      ()-/
+	      --------                  --------
+```
+
+- Le processus P crée 2 fils, P1 et P2. P consomme le fichier généré à question 1 (un [exemple](./src/data.bin)) ou l'entrée standard, et envoie les entiers positifs
+  au processus P1 à l'aide d'un tube.
+- P1 calcule le minimum au fur et à mesure et les transmet au fur et à mesure à P2 à l'aide d'un tube.
+- P2 calcule le maximum au fur et à mesure.
+
+Lorsque tous les entiers sont passés, P1 et P2 affichent la valeur du miminimum et maximum.
+
+
+Fonctions et macro utiles :
+```c
+int rand(void);
+int pipe(int pipefd[2]);
+pid_t fork(void);
+int open(const char *pathname, int flags, ...
+                  /* mode_t mode */ );
+ssize_t read(int fd, void buf[.count], size_t count);
+ssize_t write(int fd, const void buf[.count], size_t count);
+int close(int fd);
+```

ctrl_machine/src/syracuse.c

@@ -0,0 +1,51 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+
+/* variables pour le calcul */
+
+long in, inmax, inkmax, inumax;
+long long k, kmax;
+long long u, umax;
+
+
+void infos(void) 
+{
+	printf("\n");
+	printf("Plus grand terme initial : %ld\n", inmax);
+	printf("Altitude maximale : %lld (v.i. %ld)\n", umax, inumax);
+	printf("Plus long temps de vol : %lld (v.i. %ld)\n", kmax, inkmax);
+}
+void sig_alarme(int n)
+{
+infos();
+alarm(2);
+}
+void syracuse(void)
+{
+	while ( u > 1 ) {
+		if (u % 2) u = 3*u + 1;
+		else u = u/2;
+		if (u > umax) {
+			umax = u;
+			inumax = in;
+		}
+		k++;
+	}
+}
+int main(int argc, char *argv[])
+{
+	signal(SIGALRM, sig_alarme);
+	alarm(2);
+	for (in = 1; ; in++) {
+		k = 0;
+		u = in;
+		syracuse();
+		inmax = in;
+		if (k > kmax) {
+			kmax = k;
+			inkmax = in;
+		}
+	}
+}