Anthony Jaguenaud a écrit 1970 commentaires

Pour un programme informatique, tu as des entrées en général des entrées clavier. Ici c’est 17.9.
Des sorties : Le résultat.
Le corps du programme qui contient :
* L’algorithme ;
* Les données internes (déduite des entrées)
* Les constantes.

Ton H peut être une entrée ou une constante de réglage, c’est ton choix ou celui de l’énoncé.

Peux-tu détailler les étapes pour refaire ce que tu as fait au dessus ?

Je commence :

Demander un nombre et le stocker dans une variable x
…

Une femme aura-t-elle vraiment un comportement différent d’un homme s’ils ont les mêmes aspirations, les mêmes recherche… ?

Pour moi, le sexe des personas n’a pas d’intérêt que de faire un procès inutile. Il suffit de les mettre toutes aux féminins et ce sera réglé, non ?

Prenons la fonction x au carré pour essayer.

Tu as 17.9, f(x) = x²

Comment tu fais ? Si tu arrives à expliquer, tu auras fait la moitié de ton travail.

Choix d’un nombre dérivé ?
Déterminer la valeur approchée de ce nombre, avec l’accroissement moyen ?
Définir une fonction ?

• Je choisie 17,9

• Maintenant comment tu détermines l’accroissement moyen ?

Tu veux un exemple, ça m'a pris 5 minutes pour trouver:
https://packages.debian.org/fr/stretch-backports/libwebkit2gtk-4.0-37

Je ne suis pas allé voir, mais là, tu parles dans les backports… C’est à dire des versions plus récentes que celle maintenu par l’équipe de sécurité qui est dans stable.

Merci de me corriger si je dis une connerie.

Si tu suis ce commentaire, tu devrais pouvoir remonter la chaîne…
Ce n’est qu’une supposition bien sûr, mais la ressemblance est troublante.

Depuis quelques temps, tu reviens pleurer, nous dire qu’on est méchant… mais si nous sommes tous affreux, débile… (laisse libre cours à ton imagination) pourquoi t’acharnes-tu à vouloir faire parti de cette communauté que tu décries ?

J’ai commandé mon produit.
Par contre, niveau sécurité… ils m’ont envoyé mon mot de passe par courriel ! Comme si je ne le connaissais pas.

En fait, tout les fichiers dans /dev finissent dans un driver de périphérique du noyau.
Tu as deux types de fichiers, les types block qui ont une taille et dans lesquels ont peut se déplacer (les périphériques disque notamment) et les types caractère qu’on ne peut lire que en flux, ou on retrouve clavier, souris, RS232, etc.

C’est marrant, je connaissais avec ssh.

ssh compte1@ordi1:tar czf - repertoire_a_sauver | ssh compte2@ordi2:tar xzf -

En fonction de la puissance des machines et de la rapidité du réseau, ça peut aller plus vite sans compression.

D’ailleurs, l’autre jour, je voulais relire les geekscottes. Mais le site à disparu :'(

Quelqu’un sait-il pourquoi ?

avec awk pas de souci, …

Je suis navré, je croyais que tu cherchais une solution et j’ai essayé d’utiliser l’outil qui me semblait le plus adapté pour résoudre ton problème tel que je l’avais compris. Mais si le but était le défi intellectuel de le faire avec sed effectivement, j’ai répondu a côté de la plaque… tu m’en vois navré.

Merci, je ne savais pas qu’on pouvait utiliser $x en lvalue.

Awk permet de traiter un fichier ligne par ligne en matchant des regex ou des valeurs de champs.

awk  '
($5=="ici"){print $1 "\t" $2 "\t"… "salut" }' <fichier>

Un truc du genre devrait marcher à peu près.

Salut,
En programmation il est important de bien séparer les données de leur affichage.
Effectivement, stocké les temps en seconde est une bonne idée. Ensuite il suffit de convertir le temps pour avoir un affichage joli.

• 83s => 1:23
• 4000s => 1h06:40

Il te faut également une fonction qui à partir d’une entrée te donne le temps en seconde.

• 1h02:00 => 3720

Pour les centièmes, il y a deux solutions :

• Considérer les valeurs comme des valeur à virgule et donc 83.48s => 1mn 23s et 48 centièmes
• Garder que des valeurs entières : au lieu de stocker 83, tu stockes 8300.

J’espère être clair…

Merci à vous deux.

Avec le apt list j’ai pu vérifier que le driver nvidia était bien sur la version standard. Il ne compilait plus dû à un changement d’interface dans un .h au passage du 4.13 -> 4.14.
En passant le driver en backport tout roule.

J’utilise k3b le logiciel de KDE. Il fait le job en utilisant les outils en ligne de commande que tu as cité.

Si tu as un « linux » moderne, insère un CD vierge dans ton lecteur et ton desktop devrait te proposer automatiquement un logiciel.

Et utiliser weboob pour la partie bancaire ?

Edit: Grillé… :'(

Je trouve ça vraiment très beau. Je vais probablement remplacer ma CSS actuelle.

Il y a deux détails :

• Les nouveaux commentaires manquent de visibilité.
• La barre d’état est peu lisible quand il y a du texte dessous.

Comme je ne sais pas vraiment ce qu’on peu faire, je ne pense pas être pertinent pour proposer des améliorations, encore moins les réalisés.

Quand on dit que l’ordonnanceur est préemptif, ça veut dire qu’il peut interrompre une tâche s’il le veut… ou la laisser tourner s’il le veut.
C’est en opposition à l’ordonnanceur coopératif, ou il faut appeler une fonction spéciale pour être reschedulé, ou certaines fonction de l’OS le font d’eux même.

L’ordonnanceur à beau être préemptif (capable de préempté la tâche) si tu lui dit explicitement de la laisser tourner, il va le faire. Temps qu’on utilise l’ordonnanceur en temps partagé, tous les thread auront à un moment du temps CPU. En mode Temps Réel, c’est différent. Ce n’est pas à utiliser à la légère. Par exemple, malgré un aspect temps réel sur l’affichage de page internet, et comme ce n’est pas critique, les navigateur web utilise les priorités standard. Ça suffit la plupart du temps, et quand ça suffit pas, ce n’est pas grave.

Imagine que firefox, utilise des threads temps réel pour rendre une page… et que celle-ci prennent du temps à cause de sa complexité, son javascript… tout ton système serait à la ramasse. C’est pour ça que ce n’est pas utilisé comme ça. C’est moins grave que ça lague un peu, plutôt que ça bloque le système.

Je ne sais pas ce que tu veux faire, tu ne précises rien. Mais réfléchie bien à si tu en as vraiment besoin… après, si c’est juste des TPs pour appréhender les concepts, alors continue, il n’y a rien de mieux que de ce prendre les pieds dans le tapis pour comprendre qu’il faut les lever ;-)

d'accord et un processus de priorité 10 et de politique d'ordonnancement SCHED_RR est autant prioritaire qu'un processus de priorité 10 et de politique d'ordonnancement SCHED_FIFO ou les politique d’ordonnancement SCHED_FIFO sont plus prioritaire que SCHED_RR ?

Là, tu me poses une colle. Je ne joue pas à ça. À une priorité donnée, je mets soit RR soit FIFO, mais pas les deux. Il faudrait regarder ce qui est marqué dans la norme POSIX. Mais il y a toujours un risque sur l’implémentation sur le système que tu utilises. Quand on passe les tâches en TR, c’est pour gagner en maîtrise, ce n’est pas pour ajouter de l’incertitude. Donc je ne le ferai pas.

Instinctivement, je dirai que FIFO 10 est plus prioritaire que RR 10, mais moins que RR11. Mais je n’ai jamais essayé de mixer.

Je cite (vu sur un site) :
"(…). N’étant
pas préemptible, ce processus s’exécute jusqu’à la fin sans libération du processeur"

Il parle de processus de même priorité. C’est pour alerter que les autres tâches n’auront pas de CPU (en multi cœur c’est faux), et que ça peut bloquer l’ordi. Je vois ça plus comme une mise en garde. Mais je t’accorde que c’est imprécis.

je retrouve souvent ca, et je bug la dessus car j'ai l'impression de comprendre que le noyau laisse le processus finir sa tache peu importe qu'il y ait des processus de plus grande priorité.

Non, la tâche sera bien interrompu par des tâches plus prioritaire.

si j'ai deux processus de meme priorité mais avec un processus tres court en temps processeur et l'autre tres lent, alors l'ordonnanceur lance le premier (FIFO) car le processus qui est tres court peut se retrouver en second dans la file READY.

Je ne sais pas ce que tu veux faire. Le temps réel est quelques chose de particulier. Si tu veux faire de l’applicatif « normal » n’utilise pas. L’objectif du temps réel est de garantir des temps de réponse, pas d’aller vite. Donc toute ton architecture se base sur des euristiques de temps de traitement de chaque tâche, et chaque tâche répond a un stimuli auquel on veut répondre.

Ex: J’ai une tâche qui surveille la monté d’eau dans un aquarium. Je connais le débit d’eau, la hauteur au dessus de mon capteur, donc je sais déterminer combien de temps il me reste quand le capteur me dit plein. On enlève un peu de temps, il y a potentiellement des remous ou que sais-je.

À partir de ta cascade d’événements, qui produisent des réponses pouvant être des stimuli d’autres tâches.

Ce qui est différent avec la politique d'ordonnanceur RR qui lui aurait partagé le temps du CPU. Donc le politique SCHED_FIFO peut rendre des systèmes instables car il peut lancer pendant des heures juste un processus (dans le cas ou on a qu'un seul coeur et un seul thread processeur)?

Normalement, quand tu mets une tâche en SCHED_FIFO, c’est qu’elle est suffisamment courte.

Je ne sais pas où tu as lu ça, mais je pense que l’idée et de dire que tant qu’aucune tâche de plus haute priorité n’est prête, la tâche ne sera pas interrompue. Même si elle passe 1h à s’exécuter.

Néanmoins, il n’y a aucun rapport entre préemptif (adj.) et SCHED_FIFO qui est une politique d’ordonnancement. C’est un peu comme dire : « La couleur de ce chat est angora. ».

Pour résumer, oui un ordonnanceur qui implémente la politique SCHED_FIFO est un ordonnanceur préemptif.
Fait attention aux sites que tu lis. Certains expliquent des trucs qu’ils croient avoir compris, ça nous arrive à tous, mais quand on publie il faut être plus rigoureux de façon à ne pas induire quelqu’un en erreur.

Sur ton message précédent, j’ai été volontairement flou sur certains points pour pas te noyer au premier message. Si tu as besoin de précision, n’hésite pas à répondre là où tu as besoin.

Tu as deux modes de gestions multi tâches.
Le mode Temps Réél, et le mode temps partagé. Par défaut, on lance les processus en mode temps partagé. Je vais expliquer à la pelleteuse (très grosse louche) le principe de fonctionnement et comment nice modifie ça.
Quand on lance un programme en temps partagé, le noyau lui alloue un quota de temps. Partons du postulat que le quota par défaut est 100ms. Deux programmes « Ready » vont donc partagé le processeur chacun ayant 100ms de quota à tour de rôle. nice va modifier se quota : nice -m 20 va donner un quota de 120ms pour le programme correspondant. Mais n’empêchera pas l’autre programme d’utiliser son quota qui est toujours de 100ms. Néanmoins, sans nice chacun va s’exécuter pendant 5s. Si on a un quota 120/100, on va avoir un résultat de 4,xs contre 5,y (1-0,x == 0,y).

Les processus en mode TR (temps réel) ne rendent jamais la main ! (enfin, sauf s’ils se mettent en attente avec select par exemple). En fonction des priorités, ça peut rendre un ordinateur de bureau inutilisable (interface graphique bloquée…)

L’ordonnanceur choisi la tâche TR ayant la priorité la plus élevée, et l’exécute. Quand elle a fini, ou qu’elle se met en attente d’un événement extérieur, l’ordonnanceur donne la main à la nouvelle tâche prête ayant la priorité TR la plus élevée. S’il n’y a plus de tâche TR, les tâches en mode partagée sont exécutées.

La concurrence entre les tâches TR, s’effectue suivant deux modes. FIFO ou RR. Prenons deux tâches TR de même priorité :

• en mode FIFO, la première qui a la main, s’exécutera jusqu’à ce qu’elle est terminée, puis l’autre tâche sera exécuté. Si la première redevient prête, elle attendra que la seconde est finie.
• en mode RR, les deux tâches vont travailler en temps partagé, mais seulement entre elles, puisque les autres tâches sont moins prioritaires.

J’espère avoir été clair.

Le sched RR (Round Robin) il donne du temps alternativement à tous les process ayant la même priorité. Ceux de priorité inférieur ne seront pas exécuté.
C’est Sched FIFO, qui attendra que la tâche soit terminé pour exécuter la suivante.

En bash tu as deux limiteurs de chaine, en plus tu peux les coller pour les concaténer…

./sendmail.sh '"'"$adresse"'"'  #devrait marcher

Après, ça peut dépendre de l’intérieur du script et de comment sendmail.sh gére le paramètre $1

$ adresse=toto
$ echo  '"'"$adresse"'"'  #devrait marcher
"toto"
$