Video on Demand in a IEEE 802.11p based Vehicular Network

 

This page describes the ns-3 simulations used in the following paper:

Thomas Begin, Anthony Busson, Isabelle Guerin-Lassous, Azzedine Boukerche, Video On Demand in IEEE 802.11p-based Vehicular Networks: Analysis and Dimensioning. MSWIM 2018.

So, please cite this paper if you use this simulation scenario.

The ns-3 files are available here. It corresponds to scenario 1 in the paper. It is a zip archive that contains the ns-3 main file (the .cc file), a mobility trace file, a the video trace file (Star Wars Episode 4 but only for 10 minutes) and a script to run the simulations automatically. The best way to run the simulation:

  • Put the ns-3 main file in the folder ns-3/scratch (as usual)
  • Create two folders in the ns-3 directory: mobilityTrace and videoTrace and put the mobility trace file and video trace file in it
  • You can run the simulation directly from the ns-3 main file (for a distance between RSU=4000 meters)

            ./waf --run "scratch/vanet-videoTCP-scenario1 --distanceRSU=4000"

  • You can use the script here to run 10 simulations for diatnce between RSU varying between 1500 to 8000 meters. It has to be put and executed from the ns-3 folder. Output are given in different output files in the ns-3 directory.

 

 

 

 

 

 

 

Information IUT Lyon 1

 

Les calendriers:

Calendrier IUT 2017-2018

Calendrier DevOps 2017-2018

Calendrier SID 2017-2018

Calendrier ESSIR 2017-2018

 

Calendrier IUT 2018-2019 (Attention version provisoire)

Calendrier DevOps 2018-2019

Calendrier SID 2018-2019

Calendrier ESSIR 2018-2019

 

 Les fiches modules:                                 Statistiques diverses:

Liste des modules                                       Statistiques sur les étudiants boursiers

Fiche module vierge                                     Indicateurs de réussite du département

Exemples de fiches: fiche1 fiche2                 Retour étudiants S4 sur la formation

PPN        lienCaroline

 

Les présentations/compte rendu de réunion

Présentation chef de Dept                                        Réunion de département Lundi 18/12/2017

AG 1er Septembre 2017                                           Réunion de département Lundi 05/02/2017

Réunion de département Lundi 25/09/2017                 Réunion de département Lundi 05/03/2017

Réunion de département Lundi 23/10/2017                 Réunion de département Lundi 14/05/2017

Réunion de département Lundi 20/11/2017                 Réunion de département Lundi 11/06/2017

Réunion de département 27/11 relation internationale + slides d'Hamamache + slides High-tech.

ACDi Belfort des 16 et 17 Novembre

Réunion sur la plateforme PARCOURSUP 15 Janvier 2018

Programme pour le marché région

Compte rendu Journée pédagogique 7 Mai 2018

 

 

Le lien de P-A Champin vers Tomuss

 

Le site pour les missions: ici

 

Les rattrapages mutualisés des Jeudi après midi:

18/01 François

01/03 Rémi

15/03 Alex

29/03 Christine

26/04 Anthony

24/5 Stéphane

31/05 Samba

07/06 Aurélie

21/06 P-A

 

Les déclarattions d'heures: 

Voici les heures d'encadrement de projets tuteurés à déclarer dans Gasel :
 - S1 : 2h par projet UE11
 - S2 : 2,5h par projet UE21
 - S3 : 4,5h UE33
 - S4 : 3h par projet UE43
 - ASPE : 7,5h par projet réparties en 4,5h en UE11 et 3h en UE21

Pour les suivis d'alternants (même principe dans les 3 LP): 

- 10h dans l'UE 5 alternance,

- 4h dans l'UE 4 projet tuteuré.

 

 

 

 

TP3 - Programmation système (M3101-1) SE TP UE3

Redirection, tâches de fond, et pipe.

 

 

Conseil préliminaire

Dans ce TP, on ne vous fournit pas de fichier Makefile. C'est à vous de l'écrire (voir avec votre enseignant pour un petit cours en début de séance).

 

Exercice 1 : redirection de la sortie standard

Un shell classique permet de rediriger les entrées/sorties standards vers d'autres fichiers, en utilisant les ca­ractères spéciaux < et >. Vous devez d'abord tester ces fonctionnalités dans votre shell (>, >>, 2>, 2>> et <). Ces fonctionnalités sont implementées au niveau du shell. Celui-ci recherche ces caractères spéciaux avant de lancer la commande. Il effectue la redirection et supprime ces caractères spéciaux (ainsi que ce qui est à leur droite) lors du passage des arguments à la commande. Cependant, notez que ces fonctionnalité n'ont pas besoin d'être interne au shell : elles peuvent être implantées avec une syntaxe différente, comme une commande externe.

On vous demande d'intégrer ces fonctionnalités à votre shell (TP 3).  Vous devrez tester avec une commande qui prenne au minimum deux arguments :

uneCommande unArgument > nomDeFichier

par exemple

  ls toto.txt > out.txt

Votre shell doit ouvrir en écriture le fichier dont le nom lui est passé après la redirection (out.txt dans l'exemple ci-dessus), et redirige sa propre sortie standard vers ce fichier, à l'aide de la fonction dup2(2) ou dup(2). Ensuite, il exécute la commande passée en première argument (ls dans l'exemple), en lui passant tous les arguments suivants le cas échéant (toto.txt dans l'exemple).

Notez que si le fichier n'existe pas (out.txt), il doit être créé ; s'il existe, son contenu doit être remplacé.

On notera que le paramètre argv de la fonction main respecte le format attendu par la fonction execvp(3) : il se termine par un pointeur NULL.

 

Exercice 2 : redirections généralisées¶

En partant du programme de l'exercice précédent, vuos devez prendre en compte les redirections suivantes:

  • >> redirection de la sortie standard en mode ajout
  • 2> redirection de la sortie erreur (vous pourrez tester avec ls fichierQuiNexistePas.txt)
  • 2>> redirection de la sortie erreur en mode ajout
  • < redirection de l'entrée standard (vous pourrez tester avec cat: cat < fichier.txt)

 

Exercice 3 : tâches de fond

Dans un shell classique, on peut lancer une commande en tâche de fond, en particulier lorsque l’on ne souhaite pas mono­poliser l’interpréteur pour cette commande, et que l’on veut pouvoir lancer d’autres commandes en parallèle. Pour cela, on fait suivre la ligne de commande d’un &.

 

Il s’agit maintenant de rajouter cette fonctionnalité à votre shell, basé sur le shell de l'exercice précédent ou celui du TP3 pour simplifier. Lorsque la ligne de commande saisie finit par & (tâche de fond), alors la commande sera lancée dans un nouveau processus (fonctionnement normal), mais votre shell n’attendra pas la fin de l’exécution et il ré­affichera immédiatement l'invite de saisie pour saisir et exécuter la commande suivante.

Lorsque la ligne de commande saisie ne finit pas par le caractère &, la commande correspondante sera exécutée, et votre programme attendra la fin de l’exécution pour ré­afficher l'invite de saisie (même com­portement que dans le TP3).

Attention encore à ne pas créer de zombies...

Vous ferez en sorte que, lorsqu’une commande lancée en tâche de fond se termine, votre shell affiche un message indiquant la fin du processus (avec son numéro de pid). Testez avec le shell (le vrai) pour voir le comportement attendu (avec "sleep 5 &" par exemple).

Exercice 4 : Tubes (pipes)

Vous devez apporter une dernière amélioration à votre shell: la gestion des tubes (pipes en anglais). Il s’agit de rediriger la sortie standard d’une première commande sur l’entrée standard d’une deuxième commande, mais pour que la communication puisse avoir lieu il vous faudra utiliser un tube entre ces deux entrées-sorties. Vous pourrez tester le bon fonctionnement de votre shell avec la commande:

                       monPrompt$ cat fichier | wc –l

L'appel système à utiliser est: pipe(2).

TP - Programmation répartie (M4102) UE 41

Les signaux.

 

Les signaux sont un ensemble de procédés implémenté par le système, permettant à celui-ci d'avertir un processus d'un évenement. Ce TP vise à vous familiariser avec ces signaux et leurs usages au travers de quelques exemples. Tous les signaux ne sont pas vus, ni certaines de leurs subtilités (les différents types de masquages par exemple). 

 

Exercice 1 : SIGINT et Ctrl-C.

  1. Vous devez écrire un programme simple qui affiche le message "Bonjour" toutes les secondes et qui ne s'arrête jamais (vous utiliserez sleep()).
  2. Vous devrez coder un handler qui devra afficher un message du type « Fin du programme » à la réception du signal SIGINT (généré par le système lorsque l'utilisateur appuie sur Contrôle-C). Le handler finira par un exit()
  3. Retirer l'instruction exit() du handler et testez.
  4. Masquer le signal SIGINT pendant 60 secondes puis libérez le. Testez en appuyant sur Ctrl-C durant ces 60 secondes.

 

Exercice 2 : Zombies et SIGCHLD

 

Afin de tester la gestion synchrone des zombies vous devez écrire le programme suivant:

1. Création de zombies:

  • création de deux fils
  • le fils 1 attend x secondes (avec sleep())
  • le fils 2 attend y secondes (avec sleep()) et y>x
  • le père une fois les deux fils créés boucle indéfiniment.

Observez les zombies avec la commande ps (ps aux).

 

2. Créez un handler qui intercèpte le signal SIGCHD (celui-ci est émis au moment de la terminaison d'un fils), gérez les processus zombies (avec waitpid()), puis affichez un message du type "Terminaison du fils de pid xxx". Vérifiez qu'il n'y a effectivement plus de zombies avec la commande ps.

 

Exercice 3 : Lecture d'un fichier de configuration à chaud (SIGHUP)

Vous allez coder une version extrêmement basique de votre mini-shell. Celui-ci lit un fichier de configuration au moment de son lancement. Ce fichier ne contient qu'une seule ligne qui correspond au prompt qui doit être affiché.  Le fichier de configuration pourra s’appeler shell.conf.

Ce que fait votre mini-shell:

  • Affichage du prompt sans retour à la ligne
  • Lecture de l'entrée standard (read(0,...))
  • Affichage de ce qui a été saisie sur l'entrée standard
  • retour à l'affichage du prompt

 

Afin de prendre en compte les modifications qui pourraient être apporté sur ce fichier alors que le mini-shell est en cours d’exécution, il vous faudra recharger ce fichier de configuration à chaque réception du signal SIGHUP. Vous testerez également le signal avec et sans l’option SA_RESTART.

Appels : sigaction(2).

Commandes pour tester : kill(2).

 

 

TP2 - Programmation système (M3101-1) SE TP UE31

Manipulation d'un fichier binaire et verrouillage

 

Exercice :

L'idée de l'exrecice est de vous faire manipuler un fichier binaire (non ASCII), lecture, écriture, déplacement, et d'introduire les notions de verrouillages de fichiers.

Vous devez télécharger le fichier lockfile.c. Celui-ci contient le squellete (main, nom des fonctions et arguments) permettant de gérer un répertoire de noms. Commencez par lire attentivement les commentaires qui précèdent chaque procédure/fonction afin de comprendre leur rôle.

  1. Modifiez/complétez les fonctions ajout() et modificationEntree().

  2. Modifiez/complétez les fonctions litUneEntree(), affichage(), affichageEntree().

  3. Modifiez les fonctions verrouillage et deverrouillage(). Vous devrez utiliser la fonction de la libc lockf(). Celles ci doivent être utilisées dans les fonctions ajout() et modificationEntree() de manière à garantir qu'il ne pourra pas y avoir d'accès concurrent en écriture sur les parties du fichier concernées. Vous testerez un verrouillage bloquant et un verrouillage non bloquant. Pour ce dernier, si un verrou est en cours, le programme devra afficher un message d'erreur et revenir au menu principal.

Question (vous devez répondre dans lockfileEmpty.c) :

1. Le verrouillage fonctionne-t-il pour des accès en lecture ?

2. Quelle est la différence entre les opérations F_TLOCK et F_TEST ?