Compare commits
No commits in common. "a619a2142e3213e94e14f2d683420e61dc8c36fc" and "4f2f24fe7eed93a8570a0ecb5b7908a437c0ab3f" have entirely different histories.
a619a2142e
...
4f2f24fe7e
19 changed files with 99 additions and 2931 deletions
|
|
@ -176,66 +176,3 @@ Selon le protocol, il est également possible d'avoir des bits de 'stuffing' alt
|
||||||
|
|
||||||
> Note :
|
> Note :
|
||||||
> Le 'stuffing' peut servir de synchronisation d'horloge car il assure une alternance dans le signal.
|
> Le 'stuffing' peut servir de synchronisation d'horloge car il assure une alternance dans le signal.
|
||||||
|
|
||||||
## transmission des messages
|
|
||||||
|
|
||||||
Il est possible d'interfacer entre plusieurs bus grâce à un controlleur.
|
|
||||||
- exemple : VAN 1 -> CAN -> VAN 2
|
|
||||||
|
|
||||||
Les IDs doivent être traduits d'une manière cohérente aux deux protocoles interfaçés.
|
|
||||||
|
|
||||||
## Réseaux terrain
|
|
||||||
|
|
||||||
Les réseaux terrain permettent l'interconnexion entre plusieurs entités d'un même système.
|
|
||||||
|
|
||||||
Cette communication se déroule sur une zone limitée set sur laquelle on désire une réduction maximale de la longueur des liaisons entre les différents éléments grace à un médium commun den transmission.
|
|
||||||
|
|
||||||
Cette réduciton est liée à une volonté de sécurité (sur des automates d'usine par exemple).
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
L'utilisateur ne se soucie pas du chemin suivi par les informations, de la conversion des formats type de l'interlocuteur ou bien du type de constructeur d'un élément.
|
|
||||||
Les tecnhiques de réseaux facilitent grandement l'insertion ou la suppression d'élements au sein d'un même système.
|
|
||||||
|
|
||||||
Un bus de terrein permet de transférer das la plupart des cas les informations de maniere séquentielle, ou bien par paquet de bits.
|
|
||||||
Il faut savoir que le bus de terrain permet un échange de données qui serait difficile (voire impossibl) par un autre moyen.
|
|
||||||
|
|
||||||
Derrière ce concept technologique se cachent de réels protocoles de communications qui n'ont fait qu'évoluer depuis 15 ans.
|
|
||||||
|
|
||||||
Basés sur l'optimisation de place et de temps, on a vu apparaitre des controles-commandes de plus en plus perfectionnés.
|
|
||||||
Ces technologies ne cessent d'etre améliorées et sont de plus en plus utilisés pour des raisons de cout, de confort et de flexibilité.
|
|
||||||
|
|
||||||
### Le système OSI
|
|
||||||
|
|
||||||
Le multiplexage se fait selon les principes des couches du modèle OSI.
|
|
||||||
|
|
||||||
1. la couche physique
|
|
||||||
2. la couche de liaison
|
|
||||||
|
|
||||||
Les autres couches ne sont pas présentes dans une communication BUS.
|
|
||||||
|
|
||||||
### Temps réel
|
|
||||||
|
|
||||||
Un système est dit 'temps réel' lorsqu'il a besoin de s'exécuter en un temps maximal pour assurer sa fiabilité / intégrité.
|
|
||||||
|
|
||||||
Ce qui ressort est la notion de synchronisation entre le traitement de l'information et la génération issue du monde extérieur.
|
|
||||||
En effet, ce qui prete souvent à confusion est le temps de réponse de la macjine par rapport au temps effectif qui s'écoule par l'environnement.
|
|
||||||
Naturellement, on pense à des ordres de grandeurs infinitésimale, de l'ordre du millième de secondes.
|
|
||||||
|
|
||||||
Deux types de systèmes :
|
|
||||||
|
|
||||||
- Transactionnel, ou 'temps réel mou'
|
|
||||||
- le système tolère des dépassements et les traitera comme des exception potentiellement récupérables. Cela ne déstabilisera par nécessairement le système.
|
|
||||||
|
|
||||||
- Commande, ou 'temps réel dur'
|
|
||||||
- Les invariances du système dépendent du respect de la temporalité du programme, et un dépassement sera perçu comme une erreur fatale.
|
|
||||||
- Nous cherchons à concevoir des systèmes déterministes et prévisible.
|
|
||||||
|
|
||||||
Différentes urgences vont devoir être gérées et priorisés (maintient de la synchronicité du BUS, attentes I/O, gestion d'erreurs)
|
|
||||||
|
|
||||||
Synchronisation des orloges :
|
|
||||||
|
|
||||||
- Différents calculateurs ne produirons pas les données à un débit égal. Mais la vitesse d'une transmission entre deux controleurs doit être unifiée / synchronisée.
|
|
||||||
- La vitesse de transfert dépends donc de la distance, mais aussi de la fréquence des horloges des partis.
|
|
||||||
- La synchronisation se fait au début du flux, mais elle doit également se faire en cas de resynchronisation en plein transfert de message.
|
|
||||||
|
|
||||||
|
|
|
||||||
98
bus/init.md
Normal file
98
bus/init.md
Normal file
|
|
@ -0,0 +1,98 @@
|
||||||
|
# Multiplexage
|
||||||
|
|
||||||
|
## Pourquoi ?
|
||||||
|
|
||||||
|
Machines à plusieurs objectifs.
|
||||||
|
|
||||||
|
- sécurisation
|
||||||
|
- réduction de consomation
|
||||||
|
- confort de conduite
|
||||||
|
|
||||||
|
Grand nombre de périphériques à connecter.
|
||||||
|
|
||||||
|
### Conventionnalité : une connection par liaison nécessaire :
|
||||||
|
|
||||||
|
```
|
||||||
|
+---+ +---+
|
||||||
|
| A |---| B |
|
||||||
|
| |-+ | |
|
||||||
|
+---+ | +---+
|
||||||
|
| |
|
||||||
|
| +---+
|
||||||
|
+-| C |
|
||||||
|
+---+
|
||||||
|
```
|
||||||
|
|
||||||
|
- Nombre de connections exponentelle.
|
||||||
|
- Difficile à mettre à jour.
|
||||||
|
|
||||||
|
### Multiplexage : une connection commune en 'réseau'.
|
||||||
|
|
||||||
|
```
|
||||||
|
+---+ +---+
|
||||||
|
| A |-+-| B |
|
||||||
|
+---+ | +---+
|
||||||
|
|
|
||||||
|
| +---+
|
||||||
|
+-| C |
|
||||||
|
+---+
|
||||||
|
```
|
||||||
|
|
||||||
|
- Nombre de connections linéaire.
|
||||||
|
- Disponibilité de l'information.
|
||||||
|
|
||||||
|
## Avantages
|
||||||
|
|
||||||
|
- moins de capteurs et de nombres de liaisons
|
||||||
|
- le poids et les couts diminuent
|
||||||
|
- extensibilité avec un cout minimal
|
||||||
|
- reconnu par une norme iso de fiabilité
|
||||||
|
|
||||||
|
## Principes
|
||||||
|
|
||||||
|
- un capteur par donnée nécessaire
|
||||||
|
- échange de donnée sur un cannal global.
|
||||||
|
|
||||||
|
### Détail
|
||||||
|
|
||||||
|
- Un réseau unifié
|
||||||
|
- Structuration des trames
|
||||||
|
- Synchronisation des horloges
|
||||||
|
- Arbitrage, priorisation de l'accès au Bus
|
||||||
|
|
||||||
|
## Architecture en couches
|
||||||
|
|
||||||
|
### étage d'entrée
|
||||||
|
|
||||||
|
Interface avec les capteurs
|
||||||
|
|
||||||
|
### étage de calcul
|
||||||
|
|
||||||
|
Le microprocesseur
|
||||||
|
|
||||||
|
- contient possiblement des mémoires
|
||||||
|
|
||||||
|
### étage de sortie
|
||||||
|
|
||||||
|
Interface avec les actionneurs
|
||||||
|
|
||||||
|
## Architecture réseau
|
||||||
|
|
||||||
|
- maitre esclave
|
||||||
|
- multi-maitre
|
||||||
|
- mixte
|
||||||
|
|
||||||
|
## Protocole
|
||||||
|
|
||||||
|
- l'acheminement des trames
|
||||||
|
- synchronisation d'horloges
|
||||||
|
- deux trames peuvent être émise en même temps
|
||||||
|
- l'arbitrage détermine celle qui est transmise
|
||||||
|
- la seconde sera ré-émise ensuite pour ne pas perdre d'information
|
||||||
|
|
||||||
|
### Méthode CSMA
|
||||||
|
|
||||||
|
- chaque message a un ID, un ID faible donne une plus haute priorité
|
||||||
|
- un temps est réservé pour la lecture des messages à envoyer
|
||||||
|
- un hashset des IDs supperposés est écrit sur le BUS,
|
||||||
|
- l'ID le plus faible enverra son message au temps suivant
|
||||||
2
gpu/tp2/.gitignore
vendored
2
gpu/tp2/.gitignore
vendored
|
|
@ -1,2 +0,0 @@
|
||||||
bin/
|
|
||||||
*.zip
|
|
||||||
|
|
@ -1,20 +0,0 @@
|
||||||
#!/bin/sh
|
|
||||||
cd "$(dirname "$(realpath "$0")")"
|
|
||||||
set -e
|
|
||||||
|
|
||||||
TARGET="ex1.cu ex2.cu ex3.cu ex4.cu"
|
|
||||||
|
|
||||||
if [ $# -gt 0 ]
|
|
||||||
then TARGET=$1
|
|
||||||
fi
|
|
||||||
|
|
||||||
rm -fr bin
|
|
||||||
mkdir -p bin
|
|
||||||
|
|
||||||
for target in $TARGET
|
|
||||||
do nvcc src/$target -o bin/${target%.cu}.out
|
|
||||||
done
|
|
||||||
|
|
||||||
for target in $TARGET
|
|
||||||
do ./bin/${target%.cu}.out
|
|
||||||
done
|
|
||||||
|
|
@ -1,72 +0,0 @@
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include <vector>
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
#define CUDA_CHECK(code) { cuda_check((code), __FILE__, __LINE__); }
|
|
||||||
inline void cuda_check(cudaError_t code, const char *file, int line) {
|
|
||||||
if(code != cudaSuccess) {
|
|
||||||
std::cout << file << ':' << line << ": [CUDA ERROR] " << cudaGetErrorString(code) << std::endl;
|
|
||||||
std::abort();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace linalg {
|
|
||||||
|
|
||||||
//
|
|
||||||
// Generic matrix of type T (int, float, double...)
|
|
||||||
//
|
|
||||||
template<typename T>
|
|
||||||
class Matrix
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
// construct matrix, allocate the 2D pitched memory on the device
|
|
||||||
__host__ Matrix(int rows, int cols);
|
|
||||||
|
|
||||||
// free allocated device memory
|
|
||||||
__host__ void free();
|
|
||||||
|
|
||||||
public:
|
|
||||||
// copy values from host std::vector to device Matrix
|
|
||||||
// values must be a vector of size rows x cols
|
|
||||||
// allocation is already done in the constructor
|
|
||||||
__host__ void to_cuda(const std::vector<T>& values);
|
|
||||||
|
|
||||||
// copy values from device Matrix to host std::vector
|
|
||||||
// values may not ne resized
|
|
||||||
__host__ void to_cpu(std::vector<T>& values) const;
|
|
||||||
|
|
||||||
public:
|
|
||||||
// accessor at row i and column j
|
|
||||||
__device__ const T& operator()(int i, int j) const;
|
|
||||||
__device__ T& operator()(int i, int j);
|
|
||||||
|
|
||||||
public:
|
|
||||||
__host__ Matrix operator + (const Matrix<T>& other) const;
|
|
||||||
__host__ Matrix operator - (const Matrix<T>& other) const;
|
|
||||||
__host__ Matrix operator * (const Matrix<T>& other) const;
|
|
||||||
__host__ Matrix operator / (const Matrix<T>& other) const;
|
|
||||||
|
|
||||||
private:
|
|
||||||
// apply binary functor f on all pairs of elements
|
|
||||||
// f must provide the following operator
|
|
||||||
//
|
|
||||||
// T operator()(T a, T b)
|
|
||||||
//
|
|
||||||
// template<typename BinaryFunctor>
|
|
||||||
// __host__ Matrix apply(const Matrix<T>& other, BinaryFunctor&& f) const;
|
|
||||||
|
|
||||||
public:
|
|
||||||
__host__ __device__ inline int rows() const {return m_rows;}
|
|
||||||
__host__ __device__ inline int cols() const {return m_cols;}
|
|
||||||
|
|
||||||
private:
|
|
||||||
T* m_data_ptr; // device pointer
|
|
||||||
int m_rows;
|
|
||||||
int m_cols;
|
|
||||||
size_t m_pitch;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace linalg
|
|
||||||
|
|
||||||
#include "Matrix.hpp"
|
|
||||||
|
|
@ -1,99 +0,0 @@
|
||||||
#include "Matrix.h"
|
|
||||||
|
|
||||||
namespace linalg {
|
|
||||||
|
|
||||||
namespace kernel {
|
|
||||||
|
|
||||||
//
|
|
||||||
// step 10
|
|
||||||
// CUDA kernel add
|
|
||||||
//
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
//
|
|
||||||
// step 12
|
|
||||||
// CUDA kernel apply
|
|
||||||
//
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
} // namespace kernel
|
|
||||||
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__host__ Matrix<T>::Matrix(int rows, int cols) :
|
|
||||||
m_data_ptr(nullptr),
|
|
||||||
m_rows(rows),
|
|
||||||
m_cols(cols),
|
|
||||||
m_pitch(0)
|
|
||||||
{
|
|
||||||
// step 07
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__host__ void Matrix<T>::free()
|
|
||||||
{
|
|
||||||
// step 07
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__host__ void Matrix<T>::to_cuda(const std::vector<T>& values)
|
|
||||||
{
|
|
||||||
// step 08
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__host__ void Matrix<T>::to_cpu(std::vector<T>& values) const
|
|
||||||
{
|
|
||||||
// step 08
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__device__ const T& Matrix<T>::operator()(int i, int j) const
|
|
||||||
{
|
|
||||||
// step 09
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__device__ T& Matrix<T>::operator()(int i, int j)
|
|
||||||
{
|
|
||||||
// step 09
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__host__ Matrix<T> Matrix<T>::operator + (const Matrix<T>& other) const
|
|
||||||
{
|
|
||||||
// step 11
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__host__ Matrix<T> Matrix<T>::operator - (const Matrix<T>& other) const
|
|
||||||
{
|
|
||||||
// step 12
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__host__ Matrix<T> Matrix<T>::operator * (const Matrix<T>& other) const
|
|
||||||
{
|
|
||||||
// step 12
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
__host__ Matrix<T> Matrix<T>::operator / (const Matrix<T>& other) const
|
|
||||||
{
|
|
||||||
// step 12
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace linalg
|
|
||||||
|
|
@ -1,78 +0,0 @@
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
//
|
|
||||||
// example: CUDA_CHECK( cudaMalloc(dx, x, N*sizeof(int) );
|
|
||||||
//
|
|
||||||
#define CUDA_CHECK(code) { cuda_check((code), __FILE__, __LINE__); }
|
|
||||||
inline void cuda_check(cudaError_t code, const char *file, int line) {
|
|
||||||
if(code != cudaSuccess) {
|
|
||||||
std::cout << file << ':' << line << ": [CUDA ERROR] " << cudaGetErrorString(code) << std::endl;
|
|
||||||
std::abort();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//
|
|
||||||
// step 01
|
|
||||||
// return the linear index corresponding to the element at row i and column j
|
|
||||||
// in a matrix of size rows x cols, using row-major storage
|
|
||||||
//
|
|
||||||
__device__ int linear_index(int i, int j, int rows, int cols) {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// step 02
|
|
||||||
// CUDA kernel add
|
|
||||||
//
|
|
||||||
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
constexpr int rows = 200;
|
|
||||||
constexpr int cols = 80;
|
|
||||||
int* x = (int*)malloc(rows*cols*sizeof(int));
|
|
||||||
int* y = (int*)malloc(rows*cols*sizeof(int));
|
|
||||||
for(int i = 0; i < rows*cols; ++i) {
|
|
||||||
x[i] = i;
|
|
||||||
y[i] = std::pow(-1,i) * i;
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// step 03
|
|
||||||
//
|
|
||||||
int* dx;
|
|
||||||
int* dy;
|
|
||||||
// 1. allocate on device
|
|
||||||
|
|
||||||
// 2. copy from host to device
|
|
||||||
|
|
||||||
// 3. launch CUDA kernel
|
|
||||||
// const dim3 threads_per_bloc{32,32,1};
|
|
||||||
|
|
||||||
// 4. copy result from device to host
|
|
||||||
|
|
||||||
// 5. free device memory
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// checking results
|
|
||||||
bool ok = true;
|
|
||||||
for(int i = 0; i < rows*cols; ++i) {
|
|
||||||
const int expected_result = std::pow(-1,i) * i + i;
|
|
||||||
if(y[i] != expected_result) {
|
|
||||||
std::cout << "Failure" << std::endl;
|
|
||||||
std::cout << "Result at index i="
|
|
||||||
<< i << ": expected "
|
|
||||||
<< std::pow(-1,i) * i << '+' << i << '=' << expected_result << ", got " << y[i] << std::endl;
|
|
||||||
ok = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(ok) std::cout << "Success" << std::endl;
|
|
||||||
|
|
||||||
free(x);
|
|
||||||
free(y);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
@ -1,80 +0,0 @@
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
//
|
|
||||||
// example: CUDA_CHECK( cudaMalloc(dx, x, N*sizeof(int) );
|
|
||||||
//
|
|
||||||
#define CUDA_CHECK(code) { cuda_check((code), __FILE__, __LINE__); }
|
|
||||||
inline void cuda_check(cudaError_t code, const char *file, int line) {
|
|
||||||
if(code != cudaSuccess) {
|
|
||||||
std::cout << file << ':' << line << ": [CUDA ERROR] " << cudaGetErrorString(code) << std::endl;
|
|
||||||
std::abort();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// step 04
|
|
||||||
// return a pointer to the value at row i and column j from base_address
|
|
||||||
// with pitch in bytes
|
|
||||||
//
|
|
||||||
__device__ inline int* get_ptr(int* base_address, int i, int j, size_t pitch) {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// step 05
|
|
||||||
// CUDA kernel add
|
|
||||||
//
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
constexpr int rows = 200;
|
|
||||||
constexpr int cols = 80;
|
|
||||||
int* x = (int*)malloc(rows*cols*sizeof(int));
|
|
||||||
int* y = (int*)malloc(rows*cols*sizeof(int));
|
|
||||||
for(int i = 0; i < rows*cols; ++i) {
|
|
||||||
x[i] = i;
|
|
||||||
y[i] = std::pow(-1,i) * i;
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// step 06
|
|
||||||
//
|
|
||||||
int* dx;
|
|
||||||
int* dy;
|
|
||||||
size_t pitch;
|
|
||||||
// 1. allocate on device
|
|
||||||
|
|
||||||
// 2. copy from host to device
|
|
||||||
|
|
||||||
// 3. launch CUDA kernel
|
|
||||||
// const dim3 threads_per_bloc{32,32,1};
|
|
||||||
|
|
||||||
// 4. copy result from device to host
|
|
||||||
|
|
||||||
// 5. free device memory
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// checking results
|
|
||||||
bool ok = true;
|
|
||||||
for(int i = 0; i < rows*cols; ++i) {
|
|
||||||
const int expected_result = std::pow(-1,i) * i + i;
|
|
||||||
if(y[i] != expected_result) {
|
|
||||||
std::cout << "Failure" << std::endl;
|
|
||||||
std::cout << "Result at index i="
|
|
||||||
<< i << ": expected "
|
|
||||||
<< std::pow(-1,i) * i << '+' << i << '=' << expected_result << ", got " << y[i] << std::endl;
|
|
||||||
ok = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(ok) std::cout << "Success" << std::endl;
|
|
||||||
|
|
||||||
free(x);
|
|
||||||
free(y);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
@ -1,148 +0,0 @@
|
||||||
#include "Matrix.h"
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
{
|
|
||||||
const int rows = 4;
|
|
||||||
const int cols = 4;
|
|
||||||
// instantiate two matrices of integers on the device
|
|
||||||
linalg::Matrix<int> A(rows, cols);
|
|
||||||
linalg::Matrix<int> B(rows, cols);
|
|
||||||
// fill the two matrices
|
|
||||||
A.to_cuda({ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16});
|
|
||||||
B.to_cuda({16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1});
|
|
||||||
|
|
||||||
// compute the sum
|
|
||||||
auto C = A + B;
|
|
||||||
|
|
||||||
// transfert the result on the host
|
|
||||||
std::vector<int> c_res;
|
|
||||||
C.to_cpu(c_res);
|
|
||||||
C.free();
|
|
||||||
|
|
||||||
// check results
|
|
||||||
const std::vector<int> c_expected{17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17};
|
|
||||||
if(c_res != c_expected) {
|
|
||||||
std::cout << __FILE__ << ":" << __LINE__ << ": Failure (+):" << std::endl;
|
|
||||||
std::cout << " expected: ";
|
|
||||||
for(int i : c_expected) std::cout << i << " ";
|
|
||||||
std::cout << std::endl;
|
|
||||||
std::cout << " got: ";
|
|
||||||
for(int i : c_res) std::cout << i << " ";
|
|
||||||
std::cout << std::endl;
|
|
||||||
} else {
|
|
||||||
std::cout << "Success" << std::endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
// compute the difference
|
|
||||||
auto D = A - B;
|
|
||||||
|
|
||||||
// transfert the result on the host
|
|
||||||
std::vector<int> d_res;
|
|
||||||
D.to_cpu(d_res);
|
|
||||||
D.free();
|
|
||||||
|
|
||||||
// check results
|
|
||||||
const std::vector<int> d_expected{-15, -13, -11, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 11, 13, 15};
|
|
||||||
if(d_res != d_expected) {
|
|
||||||
std::cout << __FILE__ << ":" << __LINE__ << ": Failure (-):" << std::endl;
|
|
||||||
std::cout << " expected: ";
|
|
||||||
for(int i : d_expected) std::cout << i << " ";
|
|
||||||
std::cout << std::endl;
|
|
||||||
std::cout << " got: ";
|
|
||||||
for(int i : d_res) std::cout << i << " ";
|
|
||||||
std::cout << std::endl;
|
|
||||||
} else {
|
|
||||||
std::cout << "Success" << std::endl;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// ------------------------------------------------------------------------
|
|
||||||
{
|
|
||||||
const int rows = 89;
|
|
||||||
const int cols = 128;
|
|
||||||
linalg::Matrix<float> A(rows, cols);
|
|
||||||
linalg::Matrix<float> B(rows, cols);
|
|
||||||
std::vector<float> a_values(rows*cols);
|
|
||||||
std::vector<float> b_values(rows*cols);
|
|
||||||
for(int i = 0; i < rows*cols; ++i) {
|
|
||||||
a_values[i] = 1 + float(i) / 100;
|
|
||||||
b_values[i] = std::pow(-1, i) * float(i)/(rows*cols) * 100;
|
|
||||||
}
|
|
||||||
A.to_cuda(a_values);
|
|
||||||
B.to_cuda(b_values);
|
|
||||||
|
|
||||||
auto C = A + B;
|
|
||||||
auto D = A - B;
|
|
||||||
auto E = A * B;
|
|
||||||
auto F = A / B;
|
|
||||||
|
|
||||||
std::vector<float> c_values;
|
|
||||||
C.to_cpu(c_values);
|
|
||||||
std::vector<float> d_values;
|
|
||||||
D.to_cpu(d_values);
|
|
||||||
std::vector<float> e_values;
|
|
||||||
E.to_cpu(e_values);
|
|
||||||
std::vector<float> f_values;
|
|
||||||
F.to_cpu(f_values);
|
|
||||||
|
|
||||||
C.free();
|
|
||||||
D.free();
|
|
||||||
E.free();
|
|
||||||
F.free();
|
|
||||||
|
|
||||||
const float epsilon = 0.001;
|
|
||||||
bool ok = true;
|
|
||||||
for(int i = 0; i < rows*cols; ++i) {
|
|
||||||
const float diff = std::abs( c_values[i] - (a_values[i] + b_values[i]) );
|
|
||||||
if(diff > epsilon) {
|
|
||||||
std::cout << __FILE__ << ":" << __LINE__ << ": Failure (+):" << std::endl;
|
|
||||||
std::cout << " expected: " << a_values[i] + b_values[i] << std::endl;
|
|
||||||
std::cout << " got: " << c_values[i] << std::endl;
|
|
||||||
ok = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(ok) std::cout << "Success" << std::endl;
|
|
||||||
|
|
||||||
ok = true;
|
|
||||||
for(int i = 0; i < rows*cols; ++i) {
|
|
||||||
const float diff = std::abs( d_values[i] - (a_values[i] - b_values[i]) );
|
|
||||||
if(diff > epsilon) {
|
|
||||||
std::cout << __FILE__ << ":" << __LINE__ << ": Failure (-):" << std::endl;
|
|
||||||
std::cout << " expected: " << a_values[i] - b_values[i] << std::endl;
|
|
||||||
std::cout << " got: " << d_values[i] << std::endl;
|
|
||||||
ok = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(ok) std::cout << "Success" << std::endl;
|
|
||||||
|
|
||||||
ok = true;
|
|
||||||
for(int i = 0; i < rows*cols; ++i) {
|
|
||||||
const float diff = std::abs( e_values[i] - (a_values[i] * b_values[i]) );
|
|
||||||
if(diff > epsilon) {
|
|
||||||
std::cout << __FILE__ << ":" << __LINE__ << ": Failure (*):" << std::endl;
|
|
||||||
std::cout << " expected: " << a_values[i] * b_values[i] << std::endl;
|
|
||||||
std::cout << " got: " << e_values[i] << std::endl;
|
|
||||||
ok = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(ok) std::cout << "Success" << std::endl;
|
|
||||||
|
|
||||||
ok = true;
|
|
||||||
for(int i = 0; i < rows*cols; ++i) {
|
|
||||||
const float diff = std::abs( f_values[i] - (a_values[i] / b_values[i]) );
|
|
||||||
if(diff > epsilon) {
|
|
||||||
std::cout << __FILE__ << ":" << __LINE__ << ": Failure (/):" << std::endl;
|
|
||||||
std::cout << " expected: " << a_values[i] / b_values[i] << std::endl;
|
|
||||||
std::cout << " got: " << f_values[i] << std::endl;
|
|
||||||
ok = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(ok) std::cout << "Success" << std::endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
4
ia/tp2/.gitignore
vendored
4
ia/tp2/.gitignore
vendored
|
|
@ -1,4 +0,0 @@
|
||||||
/__pycache__
|
|
||||||
/.pytest_cache
|
|
||||||
/env
|
|
||||||
/*.zip
|
|
||||||
262
ia/tp2/main.py
262
ia/tp2/main.py
|
|
@ -1,262 +0,0 @@
|
||||||
#!/usr/bin/env -S python
|
|
||||||
|
|
||||||
import pandas
|
|
||||||
import numpy
|
|
||||||
import seaborn
|
|
||||||
import matplotlib.pyplot
|
|
||||||
import sklearn.model_selection
|
|
||||||
import sklearn.linear_model
|
|
||||||
import sklearn.ensemble
|
|
||||||
import sklearn.metrics
|
|
||||||
|
|
||||||
DATA_COLUMNS = [ "fixed acidity", "volatile acidity", "citric acid", "residual sugar", "chlorides", "free sulfur dioxide", "total sulfur dioxide", "density", "pH", "sulphates", "alcohol", "quality" ]
|
|
||||||
HAHA_FUNI_NUMBER = 42
|
|
||||||
|
|
||||||
def main():
|
|
||||||
wine_quality = q_01_01_load_data("./winequality-red.csv")
|
|
||||||
|
|
||||||
# q_01_02_print_raw_data(wine_quality)
|
|
||||||
#
|
|
||||||
# > __q_02_print_raw_data__
|
|
||||||
# > fixed acidity volatile acidity citric acid ... sulphates alcohol quality
|
|
||||||
# > 0 7.4 0.700 0.00 ... 0.56 9.4 5
|
|
||||||
# > 1 7.8 0.880 0.00 ... 0.68 9.8 5
|
|
||||||
# > ... ...
|
|
||||||
#
|
|
||||||
# note :
|
|
||||||
# - Les colomnes "citric acid" (2) et "quality" (11) ont des valeur discrètes, donc des indices de cathégories.
|
|
||||||
# - Les autres colomnes sont numériques.
|
|
||||||
|
|
||||||
# q_01_03_plot_raw_data(wine_quality)
|
|
||||||
#
|
|
||||||
# note :
|
|
||||||
# Aucune correllation n'est évidente.
|
|
||||||
|
|
||||||
|
|
||||||
(quality_categories, parameters) = q_02_01_split_set(wine_quality)
|
|
||||||
# print("quality_categories", quality_categories.shape, "parameters", parameters.shape)
|
|
||||||
#
|
|
||||||
# > quality_categories (1599, 1) parameters (1599, 11)
|
|
||||||
|
|
||||||
(training_set, validation_set) = q_02_02_model_sets(parameters, quality_categories)
|
|
||||||
# print("training_set", training_set.shape, "validation_set", validation_set.shape)
|
|
||||||
#
|
|
||||||
# > training_set (1199, 11) validation_set (400, 11)
|
|
||||||
|
|
||||||
linear_model = q_02_03_train_linear_model(*training_set)
|
|
||||||
linear_accuracy = q_02_04_evaluate_error(linear_model, *validation_set)
|
|
||||||
# print("linear_accuracy", linear_accuracy)
|
|
||||||
#
|
|
||||||
# > linear_accuracy 0.38830173868689244
|
|
||||||
|
|
||||||
# q_02_05_print_one_prediction(linear_model, training_set[0])
|
|
||||||
#
|
|
||||||
# > q_02_05_print_one_prediction 5.23381934012872
|
|
||||||
#
|
|
||||||
# note :
|
|
||||||
# Nous cherchons des valeurs discrètes pour procéder à une catégorisation, la nature de la prédiction est incorrecte.
|
|
||||||
|
|
||||||
|
|
||||||
forest_model = q_03_01_train_forest_model(*training_set)
|
|
||||||
forest_training_accuracy = q_03_02_evaluate_error(forest_model, *training_set)
|
|
||||||
forest_validation_accuracy = q_03_02_evaluate_error(forest_model, *validation_set)
|
|
||||||
# print("forest_training_accuracy", forest_training_accuracy, "forest_validation_accuracy", forest_validation_accuracy)
|
|
||||||
#
|
|
||||||
# > forest_training_accuracy 0.0 forest_validation_accuracy 0.42
|
|
||||||
#
|
|
||||||
# note :
|
|
||||||
# Le modèle semble sur-spécialisé pour le set d'entrainement.
|
|
||||||
|
|
||||||
confusion = q_03_03_confusion_matrix(forest_model, *validation_set)
|
|
||||||
# print("confusion", confusion)
|
|
||||||
#
|
|
||||||
# > confusion [[ 0 0 1 0 0 0]
|
|
||||||
# > [ 0 0 5 8 0 0]
|
|
||||||
# > [ 0 0 123 39 2 0]
|
|
||||||
# > [ 0 0 37 122 10 0]
|
|
||||||
# > [ 0 0 0 24 23 1]
|
|
||||||
# > [ 0 0 0 1 4 0]]
|
|
||||||
#
|
|
||||||
# note :
|
|
||||||
# Les occurences de classes fortement représentées statistiquement sont presque évaluées correctement.
|
|
||||||
# Cependant le modèle tend à classifier les valeurs peu représentées dans les catégories fortement représentées.
|
|
||||||
|
|
||||||
|
|
||||||
training_alternate_expects_set = q_04_01_reclassify_expects(training_set[1])
|
|
||||||
validation_alternate_expects_set = q_04_01_reclassify_expects(validation_set[1])
|
|
||||||
alt_forest_model = q_04_02_train_forest_model(training_set[0], training_alternate_expects_set)
|
|
||||||
alt_forest_training_accuracy = q_04_03_evaluate_error(alt_forest_model, training_set[0], training_alternate_expects_set)
|
|
||||||
alt_forest_validation_accuracy = q_04_03_evaluate_error(alt_forest_model, validation_set[0], validation_alternate_expects_set)
|
|
||||||
# print("alt_forest_training_accuracy", alt_forest_training_accuracy, "alt_forest_validation_accuracy", alt_forest_validation_accuracy)
|
|
||||||
#
|
|
||||||
# > alt_forest_training_accuracy 0.0 alt_forest_validation_accuracy 0.085
|
|
||||||
#
|
|
||||||
# note :
|
|
||||||
# Le modèle obtient un bien meilleur score pour une tache plus simple et un set avec une représentation plus uniforme.
|
|
||||||
# Le modèle ne souffre pas de sur-spécialisation.
|
|
||||||
|
|
||||||
alt_confusion = q_04_04_confusion_matrix(alt_forest_model, validation_set[0], validation_alternate_expects_set)
|
|
||||||
# print("alt_confusion", alt_confusion)
|
|
||||||
#
|
|
||||||
# > alt_confusion [[338 9]
|
|
||||||
# > [ 25 28]]
|
|
||||||
#
|
|
||||||
# Tip top.
|
|
||||||
|
|
||||||
|
|
||||||
q_05_01_read_doc()
|
|
||||||
search_grid = q_05_02_make_search_grid(alt_forest_model)
|
|
||||||
q_05_03_k()
|
|
||||||
# best_estimator = q_05_04_get_best_params(search_grid, training_set[0], training_alternate_expects_set)
|
|
||||||
# print("best_estimator", best_estimator)
|
|
||||||
#
|
|
||||||
# > best_estimator RandomForestClassifier(bootstrap=False, min_samples_leaf=2, n_estimators=200, random_state=42)
|
|
||||||
|
|
||||||
# définition alternative pour 'best_estimator'
|
|
||||||
best_estimator = sklearn.ensemble.RandomForestClassifier(bootstrap=False, min_samples_leaf=2, n_estimators=200, random_state=42).fit(training_set[0], training_alternate_expects_set)
|
|
||||||
best_estimator_accuracy = q_05_05_evaluate_error(best_estimator, validation_set[0], validation_alternate_expects_set)
|
|
||||||
# print("best_estimator_accuracy", best_estimator_accuracy)
|
|
||||||
#
|
|
||||||
# > best_estimator_accuracy 0.0975
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
def q_01_01_load_data(path: str):
|
|
||||||
return pandas.read_csv(path, sep=';')
|
|
||||||
|
|
||||||
def q_01_02_print_raw_data(data: pandas.DataFrame):
|
|
||||||
print("__q_02_print_raw_data__\n", data)
|
|
||||||
|
|
||||||
def q_01_03_plot_raw_data(data: pandas.DataFrame):
|
|
||||||
seaborn.pairplot(data)
|
|
||||||
matplotlib.pyplot.show()
|
|
||||||
|
|
||||||
|
|
||||||
def q_02_01_split_set(data: pandas.DataFrame):
|
|
||||||
quality_categories = data["quality"]
|
|
||||||
parameters_columns = [ name for name in DATA_COLUMNS if name != "quality" ]
|
|
||||||
parameters = data[parameters_columns]
|
|
||||||
return (quality_categories, parameters)
|
|
||||||
|
|
||||||
|
|
||||||
def q_02_02_model_sets(parameters: pandas.Series, expects: pandas.Series):
|
|
||||||
(
|
|
||||||
training_parameters_set, validation_parameters_set,
|
|
||||||
training_expects_set, validation_expects_set
|
|
||||||
) = sklearn.model_selection.train_test_split(parameters, expects, random_state=HAHA_FUNI_NUMBER)
|
|
||||||
|
|
||||||
assert type(training_parameters_set) is pandas.DataFrame
|
|
||||||
assert type(validation_parameters_set) is pandas.DataFrame
|
|
||||||
assert type(training_expects_set) is pandas.Series
|
|
||||||
assert type(validation_expects_set) is pandas.Series
|
|
||||||
return ((training_parameters_set, training_expects_set), (validation_parameters_set, validation_expects_set))
|
|
||||||
|
|
||||||
def q_02_03_train_linear_model(training_parameters_set: pandas.DataFrame, training_expects_set: pandas.Series):
|
|
||||||
model = sklearn.linear_model.LinearRegression()
|
|
||||||
model.fit(training_parameters_set, training_expects_set)
|
|
||||||
return model
|
|
||||||
|
|
||||||
def q_02_04_evaluate_error(
|
|
||||||
model: sklearn.linear_model.LinearRegression,
|
|
||||||
validation_parameters_set: pandas.DataFrame,
|
|
||||||
validation_expects_set: pandas.Series
|
|
||||||
):
|
|
||||||
predictions = model.predict(validation_parameters_set)
|
|
||||||
error = sklearn.metrics.mean_squared_error(validation_expects_set, predictions)
|
|
||||||
return error
|
|
||||||
|
|
||||||
def q_02_05_print_one_prediction(model: sklearn.linear_model.LinearRegression, parameter_set: pandas.DataFrame):
|
|
||||||
parameters = parameter_set.head(1)
|
|
||||||
[prediction, *_] = model.predict(parameters)
|
|
||||||
print("q_02_05_print_one_prediction", prediction)
|
|
||||||
|
|
||||||
|
|
||||||
def q_03_01_train_forest_model(training_parameters_set: pandas.DataFrame, training_expects_set: pandas.Series):
|
|
||||||
model = sklearn.ensemble.RandomForestClassifier(random_state=HAHA_FUNI_NUMBER)
|
|
||||||
model.fit(training_parameters_set, training_expects_set)
|
|
||||||
return model
|
|
||||||
|
|
||||||
def q_03_02_evaluate_error(
|
|
||||||
model: sklearn.ensemble.RandomForestClassifier,
|
|
||||||
validation_parameters_set: pandas.DataFrame,
|
|
||||||
validation_expects_set: pandas.Series
|
|
||||||
):
|
|
||||||
predictions = model.predict(validation_parameters_set)
|
|
||||||
error = sklearn.metrics.mean_squared_error(validation_expects_set, predictions)
|
|
||||||
return error
|
|
||||||
|
|
||||||
def q_03_03_confusion_matrix(
|
|
||||||
model: sklearn.ensemble.RandomForestClassifier,
|
|
||||||
validation_parameters_set: pandas.DataFrame,
|
|
||||||
validation_expects_set: pandas.Series
|
|
||||||
):
|
|
||||||
predictions = model.predict(validation_parameters_set)
|
|
||||||
confusion = sklearn.metrics.confusion_matrix(validation_expects_set, predictions)
|
|
||||||
return confusion
|
|
||||||
|
|
||||||
|
|
||||||
def q_04_01_reclassify_expects(quality_series: pandas.Series):
|
|
||||||
QUALITY_THRESHOLD = 7
|
|
||||||
high_quality_series = quality_series.map(lambda quality: 1 if quality >= QUALITY_THRESHOLD else 0)
|
|
||||||
return high_quality_series
|
|
||||||
|
|
||||||
def q_04_02_train_forest_model(training_parameters_set: pandas.DataFrame, training_expects_set: pandas.Series):
|
|
||||||
model = sklearn.ensemble.RandomForestClassifier(random_state=HAHA_FUNI_NUMBER)
|
|
||||||
model.fit(training_parameters_set, training_expects_set)
|
|
||||||
return model
|
|
||||||
|
|
||||||
def q_04_03_evaluate_error(
|
|
||||||
model: sklearn.ensemble.RandomForestClassifier,
|
|
||||||
validation_parameters_set: pandas.DataFrame,
|
|
||||||
validation_expects_set: pandas.Series
|
|
||||||
):
|
|
||||||
predictions = model.predict(validation_parameters_set)
|
|
||||||
error = sklearn.metrics.mean_squared_error(validation_expects_set, predictions)
|
|
||||||
return error
|
|
||||||
|
|
||||||
def q_04_04_confusion_matrix(
|
|
||||||
model: sklearn.ensemble.RandomForestClassifier,
|
|
||||||
validation_parameters_set: pandas.DataFrame,
|
|
||||||
validation_expects_set: pandas.Series
|
|
||||||
):
|
|
||||||
predictions = model.predict(validation_parameters_set)
|
|
||||||
confusion = sklearn.metrics.confusion_matrix(validation_expects_set, predictions)
|
|
||||||
return confusion
|
|
||||||
|
|
||||||
|
|
||||||
def q_05_01_read_doc():
|
|
||||||
pass
|
|
||||||
|
|
||||||
def q_05_02_make_search_grid(base_model: sklearn.ensemble.RandomForestClassifier):
|
|
||||||
param_grid = {
|
|
||||||
"n_estimators": [100, 200, 300],
|
|
||||||
"max_depth": [None, 10, 20, 30],
|
|
||||||
"min_samples_split": [2, 5, 10],
|
|
||||||
"min_samples_leaf": [1, 2, 4],
|
|
||||||
"bootstrap": [True, False]
|
|
||||||
}
|
|
||||||
grid_search = sklearn.model_selection.GridSearchCV(base_model, param_grid, n_jobs=-1)
|
|
||||||
return grid_search
|
|
||||||
|
|
||||||
def q_05_03_k():
|
|
||||||
pass
|
|
||||||
|
|
||||||
def q_05_04_get_best_params(
|
|
||||||
grid_search: sklearn.model_selection.GridSearchCV,
|
|
||||||
training_parameters_set: pandas.DataFrame,
|
|
||||||
training_expects_set: pandas.Series
|
|
||||||
):
|
|
||||||
grid_search.fit(training_parameters_set, training_expects_set)
|
|
||||||
return grid_search.best_estimator_
|
|
||||||
|
|
||||||
def q_05_05_evaluate_error(
|
|
||||||
model: sklearn.ensemble.RandomForestClassifier,
|
|
||||||
validation_parameters_set: pandas.DataFrame,
|
|
||||||
validation_expects_set: pandas.Series
|
|
||||||
):
|
|
||||||
predictions = model.predict(validation_parameters_set)
|
|
||||||
error = sklearn.metrics.mean_squared_error(validation_expects_set, predictions)
|
|
||||||
return error
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__": main()
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
pandas
|
|
||||||
numpy
|
|
||||||
seaborn
|
|
||||||
matplotlib
|
|
||||||
scikit-learn
|
|
||||||
PyQt5
|
|
||||||
File diff suppressed because it is too large
Load diff
103
os/01_init.md
103
os/01_init.md
|
|
@ -1,103 +0,0 @@
|
||||||
|
|
||||||
# Systèmes d'exploitation et Programmation temps-réel
|
|
||||||
|
|
||||||
> Note :
|
|
||||||
> - 12 h de cours
|
|
||||||
> - 10 h de TP
|
|
||||||
>
|
|
||||||
> 1. Introduction
|
|
||||||
> 2. Système d'exploitation et temps réel
|
|
||||||
> 3. Interuptions de processus
|
|
||||||
> 4. Outils de synchronisation et de communication des taches
|
|
||||||
> 5. Gestion de la mémoire
|
|
||||||
> 6. Ordonancement et gestion des taches, ordonancement temps réel
|
|
||||||
|
|
||||||
# Introduction
|
|
||||||
|
|
||||||
Des domaines d'application :
|
|
||||||
|
|
||||||
- automatisme
|
|
||||||
- avionique
|
|
||||||
- robotique
|
|
||||||
- villes intelligentes
|
|
||||||
- armement
|
|
||||||
|
|
||||||
- multimédia
|
|
||||||
- télécommunications
|
|
||||||
- e-commerce
|
|
||||||
- santé, implants
|
|
||||||
- domotique
|
|
||||||
|
|
||||||
## Exemple d'une voiture moderne
|
|
||||||
|
|
||||||
- 30 calculateurs
|
|
||||||
- 100 capteurs
|
|
||||||
- 1 000 000 lignes de code
|
|
||||||
|
|
||||||
## Définitions
|
|
||||||
|
|
||||||
Un système embarqué
|
|
||||||
- dispositif matériel comportant des parties logicielles
|
|
||||||
- utilisé pour controler et agir sur son environnement
|
|
||||||
- observe les variations de son environnement grace à des capteurs et agir sur lui grace à des actionneurs
|
|
||||||
|
|
||||||
contraintes physiques peuvent s'appliquer :
|
|
||||||
- résistance à des températures extrêmes
|
|
||||||
- résistance aux champs magnétiques
|
|
||||||
- résistance aux vibrations
|
|
||||||
|
|
||||||
Les termes de système embarqué désignent aussi bien le matériel que le logiciel utilisé.
|
|
||||||
Pour concevoir un système embarqué, il faut généralement combiner des compétences en électronique, en informatique industrielle et en automatique.
|
|
||||||
|
|
||||||
Un système embarqué est un système informatisé spécialisé qui constitue une partie intégrante d'un système plus large ou une machine.
|
|
||||||
Typiquement, c'est un système sur un seul processeur et dont les programmes sont stockés en mémoire non volatile.
|
|
||||||
|
|
||||||
## Histoire
|
|
||||||
|
|
||||||
- Le premier système à être embarqué a été le système de guidage de la mission apolo en 1967.
|
|
||||||
- Le premier processeur spécialisé pour l'embarqué, le Intel 4004 est sorti en 1971.
|
|
||||||
- Le premier appareil commercial piloté par ordinateur était l'airbus A320 en 1984.
|
|
||||||
- Le premier métro autonome a été le métro de lile en 1983.
|
|
||||||
- L'émergeance des IoT en 1999.
|
|
||||||
- Premier smartphone tactile correctement commercialisé en 2007 (après philips).
|
|
||||||
- Premières attaques d'envergures par bot internet en 2016.
|
|
||||||
|
|
||||||
## Caractéristiques
|
|
||||||
|
|
||||||
- Encombrement de l'équipement (mémoire limitée pas de disque en général)
|
|
||||||
- Consommation d'énergie et autonomie (batterie)
|
|
||||||
- Mobilité
|
|
||||||
- Communication
|
|
||||||
- Contraintes de sécurité
|
|
||||||
- Contraintes de temps réel
|
|
||||||
- Ergonomie
|
|
||||||
- Impacts : éthiques et sociétaux
|
|
||||||
- coût de produits en relation avec le secteur cible
|
|
||||||
|
|
||||||
- intégration assive de composants embarqués répartis pour batir la société de l'information
|
|
||||||
- téléphones cellulaires
|
|
||||||
- tablettes
|
|
||||||
- automobile
|
|
||||||
- appareils médicaux
|
|
||||||
- photo/vidéo/hifi
|
|
||||||
- électroménager
|
|
||||||
- avionique
|
|
||||||
- spacial
|
|
||||||
- jouets
|
|
||||||
|
|
||||||
- outils théorques pratiques our l'intégration permettantn de prendre en compte tous ces critères
|
|
||||||
|
|
||||||
- construire des systèmes de fonctionnalité et qualité déterminée et agarantie, à cout acceptable.
|
|
||||||
|
|
||||||
|
|
||||||
## Considérations
|
|
||||||
|
|
||||||
- Techniqeus : conception conjointe
|
|
||||||
- économiques : optimisation par rapport au marché, entre cout, qualité et spécialisation
|
|
||||||
- multi compétence : combinaison de compétences en logiciel, controle, réseaux, ingénierie en électronique, ihm, automatique, médecine, mécanique
|
|
||||||
|
|
||||||
## Problématiques
|
|
||||||
|
|
||||||
- Hétérogénéité : Construire des systèmes complexes par intégration de composants hétérogènes
|
|
||||||
- Complexité : L'effort de développement augmente exonsentiellement avec le nombre de composantsi intégrés, d'où la nécessité de remplacer les méthodes de validation postérieure par des méthodes de validation incrémentale.
|
|
||||||
- Intelligence : Moyen d'améliorer la qualité de systèmes : autodiagnostic, auto configuration, adaptabilité à l'environnement, évaluation des risques.
|
|
||||||
|
|
@ -8,7 +8,7 @@ on utilise une onde qui est modulée avec le signal d'entrée dans le but de tra
|
||||||
|
|
||||||
+-----+ +-----+ +--------------+ +--------------+ +-----+ +-----+
|
+-----+ +-----+ +--------------+ +--------------+ +-----+ +-----+
|
||||||
| DTE |--| DCE |--| Modulateur & |. . . .| Modulateur & |--| DCE |--| DTE |
|
| DTE |--| DCE |--| Modulateur & |. . . .| Modulateur & |--| DCE |--| DTE |
|
||||||
+-----+ +-----+ | Démodulateur | canal | Démodulateur | +-----+ +-----+
|
+-----+ +-----+ | Démodulateur | | Démodulateur | +-----+ +-----+
|
||||||
+--------------+ +--------------+
|
+--------------+ +--------------+
|
||||||
|
|
||||||
```
|
```
|
||||||
|
|
@ -387,6 +387,3 @@ Exemple : USB, token-ring 802.5 (IBM).
|
||||||
Une station qui veut émettre écoute le medium.
|
Une station qui veut émettre écoute le medium.
|
||||||
- si celui-ci est libre, elle commence sa transmission, tout en vérifiant qu'auune autre station n'est en train d'émettre.
|
- si celui-ci est libre, elle commence sa transmission, tout en vérifiant qu'auune autre station n'est en train d'émettre.
|
||||||
- en cas de collision, les stations interromptent leur communication et attendent un délai aléatoire (rng back-off) puis la première ayant passé ce délai peut réémettre.
|
- en cas de collision, les stations interromptent leur communication et attendent un délai aléatoire (rng back-off) puis la première ayant passé ce délai peut réémettre.
|
||||||
|
|
||||||
Une analogie serait la colision dans une discussion entre humain :
|
|
||||||
- lorsque deux personnes se mettent à parler simultanément, ils se coupent et un des deux, chois au hasard, reprends.
|
|
||||||
|
|
|
||||||
327
reseau/03_net.md
327
reseau/03_net.md
|
|
@ -1,327 +0,0 @@
|
||||||
# Detection des collisions
|
|
||||||
|
|
||||||
Influende du temps de propagation.
|
|
||||||
|
|
||||||
```
|
|
||||||
Postes : A B C D E
|
|
||||||
*---*---*---*---*
|
|
||||||
. . . . .
|
|
||||||
T0 : ####.___.___.___.
|
|
||||||
. . . . .
|
|
||||||
T0+x : .___.####___._xxx
|
|
||||||
. . . . .
|
|
||||||
T0+y : .___.__####_xxx_.
|
|
||||||
. . . . .
|
|
||||||
T0+z : .___.____#x#x___.
|
|
||||||
. . . . .
|
|
||||||
```
|
|
||||||
|
|
||||||
à T0+z, la collision à lieu, A et E ont fini d'émettre et n'ont pas détecté la collision,
|
|
||||||
elles pensent pouvoir continuer à envoyer des trames sur le médium.
|
|
||||||
|
|
||||||
## Solution : slot-time
|
|
||||||
|
|
||||||
Pour éviter ce genre de collision, nous introduisons un délai avant chaque nouvelle transmission
|
|
||||||
pour s'assurer que l'information ait pu rejoindre tout le réseau avant d'émettre à nouveau.
|
|
||||||
|
|
||||||
Ce délai (slot-time) est généralement choisi à deux fois le temps de parcours de l'information sur tout le médium.
|
|
||||||
|
|
||||||
## Taille minimum d'une trame
|
|
||||||
|
|
||||||
Pour que l'on puisse détecter la collision, il faut que la station émettrice
|
|
||||||
soit toujours en train d'émettre lorsque la station la plus éloignée détecte l'émission.
|
|
||||||
|
|
||||||
Il faut donc que le temps d'émission d'un trame de longueur minimale soit supérieure au slot-time.
|
|
||||||
|
|
||||||
ex :
|
|
||||||
|
|
||||||
vitesse | taille mini | slot time
|
|
||||||
|
|
||||||
...
|
|
||||||
|
|
||||||
## Reprise après collision (binary exponential backoff)
|
|
||||||
|
|
||||||
Après la détection de la collision, la station doit retransmettre la même trame au bout d'un temps aléatoire dépassant le slot-time et du nombre de collisions successives déjà subies.
|
|
||||||
|
|
||||||
Le nompre de collisions successives est proportionnel au temps de retransmission.
|
|
||||||
|
|
||||||
Calcul du temps d'attente : M x slot Time
|
|
||||||
- 0 =< M < 2^k
|
|
||||||
- 0 < k < 2^(n-1).
|
|
||||||
- n est le nombre de collision par rapport à la station
|
|
||||||
|
|
||||||
|
|
||||||
- le nombre aléatoire est d'abord choisi dans [0, 1]
|
|
||||||
- puis dans [0, 3]
|
|
||||||
- puis [0, 7]
|
|
||||||
- ...
|
|
||||||
- à la 10e tentative, [0, 1023]
|
|
||||||
- à la 16e tentative, la transmission est abandonnée.
|
|
||||||
|
|
||||||
## Exemple
|
|
||||||
|
|
||||||
```
|
|
||||||
station : A B C D E
|
|
||||||
-*---*---*---*---*-
|
|
||||||
|
|
||||||
```
|
|
||||||
|
|
||||||
A et E subissent une collision :
|
|
||||||
|
|
||||||
### Cas 1
|
|
||||||
|
|
||||||
```
|
|
||||||
station : A E
|
|
||||||
-*---*-#####-*---*-
|
|
||||||
n : 1 1
|
|
||||||
k : [0,1] [0,1]
|
|
||||||
```
|
|
||||||
|
|
||||||
règles :
|
|
||||||
|
|
||||||
- k_A = 0 & k_E = 0 => collision
|
|
||||||
- k_A = 0 & k_E = 1 => pas de collision
|
|
||||||
- k_A = 1 & k_E = 0 => pas de collision
|
|
||||||
- k_A = 1 & k_E = 1 => pas de collision
|
|
||||||
|
|
||||||
valeurs de k
|
|
||||||
|
|
||||||
| A | E |
|
|
||||||
|---|---|
|
|
||||||
| 0 | 0 |
|
|
||||||
| 0 | 1 |
|
|
||||||
| 1 | 0 |
|
|
||||||
| 1 | 1 |
|
|
||||||
|
|
||||||
|
|
||||||
probabilité que A gagne : 1/4
|
|
||||||
probabilité que E gagne : 1/4
|
|
||||||
probabilité de collision à nouveau : 1/2
|
|
||||||
|
|
||||||
|
|
||||||
### Cas 2
|
|
||||||
|
|
||||||
```
|
|
||||||
station : A E
|
|
||||||
-*---*-#####-*---*-
|
|
||||||
n : 1 2
|
|
||||||
k : [0,1] [0,1,2,3]
|
|
||||||
```
|
|
||||||
|
|
||||||
valeurs de k
|
|
||||||
|
|
||||||
| A | E |
|
|
||||||
|---|---|
|
|
||||||
| 0 | 0 |
|
|
||||||
| 0 | 1 |
|
|
||||||
| 0 | 2 |
|
|
||||||
| 0 | 3 |
|
|
||||||
| 1 | 0 |
|
|
||||||
| 1 | 1 |
|
|
||||||
| 1 | 2 |
|
|
||||||
| 1 | 3 |
|
|
||||||
|
|
||||||
probabilité que A gagne : 5/8
|
|
||||||
probabilité que E gagne : 3/8
|
|
||||||
probabilité de collision à nouveau : 2/8 : 1/4
|
|
||||||
|
|
||||||
|
|
||||||
## Domaine de collision
|
|
||||||
|
|
||||||
- sur une topologie BUS, ou sur une topologie étoile constituée d'un HUB, le signal ethernet est ...
|
|
||||||
|
|
||||||
## Conclusion
|
|
||||||
|
|
||||||
le CSMA/CD n'est potentiellement pas adapté aux applications temps réel car non déterministe
|
|
||||||
|
|
||||||
|
|
||||||
# CSMA/CR (Collision .. with Collision Resolution)
|
|
||||||
|
|
||||||
dans la méthode CSMA/CR, la station utilises des fonctionnalité plus élabotées pour détecter une collision dès que possible.
|
|
||||||
|
|
||||||
Pour éviter les collisions en chaine, une station qui transmet une trame cesse d'émettre si elle recoit un bit différent du sien ;
|
|
||||||
- Une station qui émet un bit à 1 s'arrete si elle voir passer sur le support un bit à zéro.
|
|
||||||
- Une station qui recoit un bit identique à celui qu'elle a émis continue à émettre.
|
|
||||||
|
|
||||||
## Évolutions
|
|
||||||
|
|
||||||
| Port | mode |
|
|
||||||
|-------------|-------------|
|
|
||||||
| 10BT | Half-duplex |
|
|
||||||
| 100BASETx | Full-duplex |
|
|
||||||
| GB ethernet | Full-duplex |
|
|
||||||
|
|
||||||
### Switch
|
|
||||||
|
|
||||||
```
|
|
||||||
[ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ]
|
|
||||||
| | : | |
|
|
||||||
A B C D E
|
|
||||||
```
|
|
||||||
|
|
||||||
| Port | Mac |
|
|
||||||
|------|-----|
|
|
||||||
| 1 | A |
|
|
||||||
| 2 | B |
|
|
||||||
| 3 | C |
|
|
||||||
| 4 | D |
|
|
||||||
| 5 | E |
|
|
||||||
| 6 | |
|
|
||||||
|
|
||||||
chaque port du switch est un domaine de collision.
|
|
||||||
Le switch n'envoie le trafic que sur le port concerné.
|
|
||||||
|
|
||||||
# Trame ethernet
|
|
||||||
|
|
||||||
```
|
|
||||||
+-----------+-----+-----------+----------+------+----------+-----+-----+
|
|
||||||
| préambule | SFD | Dést. MAC | Src. MAC | Type | donnée | FCS | IPG |
|
|
||||||
+-----------+-----+-----------+----------+------+----------+-----+-----+
|
|
||||||
```
|
|
||||||
|
|
||||||
- préambule : 7 octets pour synchroniser les horloges du traget.
|
|
||||||
- Start Frame DElimiter : 1 octet qui indique au récepteur que le champ destination MAC démarre au prochain octet (synchro)
|
|
||||||
|
|
||||||
- Dest : 6 octets d'une addresse MAC
|
|
||||||
- Src : 6 octets d'une addresse MAC
|
|
||||||
|
|
||||||
## Domaine de Broadcast
|
|
||||||
|
|
||||||
Au contraire d'une communication unicast, il est possible d'adresser des trames de données
|
|
||||||
à tous les membred d'un même réseau uniquement par des adresses spécifiques.
|
|
||||||
|
|
||||||
Adresse MAC de diffusion générale est FF.FF.FF.FF.FF.FF
|
|
||||||
|
|
||||||
Un switch recevant une trame broadcast sur l'un de ses ports la diffusera sur tous les autres ports.
|
|
||||||
|
|
||||||
> note :
|
|
||||||
> un broadcast propagé dans un réseau contenant un cycle risque de se répéter à l'infini sur ce dernier.
|
|
||||||
> La solution est d'utiliser des switch implémentant le protocole spanning tree ;
|
|
||||||
> Qui réduit le nombre de récepteur des paquets broadcast à un réseau ne contenant pas de cycles entre les switchs.
|
|
||||||
|
|
||||||
Un routeur ne propage pas de broadcast car il interface deux réseaux différents, et un broadcast est adressé à un seul réseau.
|
|
||||||
|
|
||||||
## VLAN
|
|
||||||
|
|
||||||
un VLAN permet de, virtuellement, utiliser une seule liaison pour véhiculer deux réseaux séparés entre deux switchs qui le supportent.
|
|
||||||
|
|
||||||
```
|
|
||||||
[ switch A ] =trunk= [ switch B ]
|
|
||||||
| | | |
|
|
||||||
| | | |
|
|
||||||
[A][X] [B][Y]
|
|
||||||
/ \ / \
|
|
||||||
vlan1 vlan2 vlan1 vlan2
|
|
||||||
. . . .
|
|
||||||
. . . . . . . . . . . . .
|
|
||||||
. . . . . . . . . . .
|
|
||||||
```
|
|
||||||
|
|
||||||
Sur un switch, chaque VLAN est un domaine de broadcast.
|
|
||||||
|
|
||||||
Il est possible de joindre des VLAN avec un Routeur ;
|
|
||||||
mais il est préférable de contrôler l'accès entre deux VLAN
|
|
||||||
de responsabilités différentes avec un Routeur configuré en pare-feu.
|
|
||||||
|
|
||||||
> note : LAN est une norme 802
|
|
||||||
|
|
||||||
# Réseau WIFI
|
|
||||||
|
|
||||||
## Topologies
|
|
||||||
|
|
||||||
### Ad-Hoc / indépendant
|
|
||||||
|
|
||||||
```
|
|
||||||
A
|
|
||||||
| \
|
|
||||||
| \
|
|
||||||
B -- C
|
|
||||||
```
|
|
||||||
|
|
||||||
Les enteines de chaques membre peut communiquer dirrectement avec celles des autres membres du réseau.
|
|
||||||
|
|
||||||
### Infrastructure
|
|
||||||
|
|
||||||
```
|
|
||||||
A
|
|
||||||
|
|
|
||||||
B --o-- C
|
|
||||||
^\_ point d'accès
|
|
||||||
```
|
|
||||||
|
|
||||||
Les membres du réseau sont tous connectés à un point d'accès.
|
|
||||||
|
|
||||||
## Utilisation des ondes
|
|
||||||
|
|
||||||
Comme la bande FM, les réseaux wifi sont divisées en canaux se chevauchant.
|
|
||||||
|
|
||||||
```
|
|
||||||
-------------------------------------------------
|
|
||||||
......1...... ........6..... .......11.....
|
|
||||||
......2....... .......7...... .....12......
|
|
||||||
.......3....... ......8....... .....13.....
|
|
||||||
.......4....... ......9.......
|
|
||||||
........5....... ....10.......
|
|
||||||
|
|
||||||
^^^^^^^^^^^^^\_ 22 Mhz
|
|
||||||
```
|
|
||||||
|
|
||||||
- 13 bandes
|
|
||||||
- 3 bandes distinctes
|
|
||||||
- 22 Mhz de longueur
|
|
||||||
- 2.4 Ghz
|
|
||||||
|
|
||||||
## Codages
|
|
||||||
|
|
||||||
- DSSS
|
|
||||||
- FHSS
|
|
||||||
- OFDM : Orthogonal Frequency Division Multiplexing
|
|
||||||
- OFDMA : Orthogonal Frequency Division Multiple Access
|
|
||||||
|
|
||||||
## Les couches 802.11
|
|
||||||
|
|
||||||
- Liaison
|
|
||||||
- LLC : 802.2
|
|
||||||
- MAC : 802.11
|
|
||||||
- Physique
|
|
||||||
- FHSS
|
|
||||||
- ...
|
|
||||||
- OFDMA
|
|
||||||
|
|
||||||
## Standards
|
|
||||||
|
|
||||||
| Nom | 802.11b | 802.11a | 802.11g | 802.11n | 802.11ac | 802.11ax |
|
|
||||||
|---------------|----------|---------|---------|----------|----------|--------------|
|
|
||||||
| Fréquences | 2.4 Ghz | 5 | 2.4 | 2.4 ou 5 | 5 | 2.4 ou 5 |
|
|
||||||
| Transfert max | 11 Mb | 54 | 54 | 150 | 3.4 Gb | 10.5 |
|
|
||||||
| Modulation | DSSS | OFDM | OFDM | OFDM | OFDM | OFDL / OFDMA |
|
|
||||||
| Portée | 35-140 m | 35-120 | 35-140 | 50-250 | 20-300 | 20-300 |
|
|
||||||
| année | 1999 | 1999 | 2003 | 2009 | 2013 | 2021 |
|
|
||||||
|
|
||||||
## Méthode d'accès au médium
|
|
||||||
|
|
||||||
CSMA/CD inapproprié
|
|
||||||
- dificile d'écouter le médium lors de la transmission
|
|
||||||
- 2 stations peuvent être visibles l'une de l'autre
|
|
||||||
|
|
||||||
CSMA/CA méthode adapté
|
|
||||||
- carrier sense multiple access
|
|
||||||
- collision avoidance : évitement des collisions
|
|
||||||
- méthode par compétition
|
|
||||||
|
|
||||||
### principe du CSMA/CA
|
|
||||||
|
|
||||||
1. Une station souhaitant émettre écoute si le médium est libre.
|
|
||||||
- si c'est le cas, elle attend pendant un temps fixe (DIFS) + temps aléatoire.
|
|
||||||
2. si le média est toujours libre, alors elle émet.
|
|
||||||
|
|
||||||
acquittement (ack) après un silence SIFS.
|
|
||||||
|
|
||||||
```
|
|
||||||
------------------------------
|
|
||||||
Source : .###..........
|
|
||||||
Destination : .....#........
|
|
||||||
Autre station : .......###....
|
|
||||||
^\_ ACK
|
|
||||||
```
|
|
||||||
|
|
||||||
|
|
@ -1,57 +0,0 @@
|
||||||
## Qu est-ce qu'une info ?
|
|
||||||
|
|
||||||
- Actif essentiel
|
|
||||||
- Stockée sous différentes formes (num, materiel, intangigle)
|
|
||||||
- Transmise par différents moyens
|
|
||||||
- Dépendant des tech de l'information
|
|
||||||
|
|
||||||
La sécurité de l'information, c'est garantir la disponibilité de l'information ; par l'application et le management de mesures de sécurité appropriées.
|
|
||||||
|
|
||||||
|
|
||||||
## Un ensemble de mesures de sécurité applicables.
|
|
||||||
|
|
||||||
- Management du risque
|
|
||||||
- Gérées à l'aide d'un SMSi:
|
|
||||||
- Politiques, Processus, procédures, structures organisationelles, logiciels et matériels
|
|
||||||
- mesures spécifiées, mises en oeuvre, surveillées, réexaminées et améliorées si nécessaires.
|
|
||||||
|
|
||||||
## Objectifs
|
|
||||||
|
|
||||||
3 objectifs premiers :
|
|
||||||
|
|
||||||
- disponibilité
|
|
||||||
- intégrité
|
|
||||||
- confidentialités
|
|
||||||
|
|
||||||
5 objectifs accessoires :
|
|
||||||
|
|
||||||
- Traçabilité : Garder des traces des évènements et des action
|
|
||||||
- non-répudiation : Permet de prouver qu'une personne ou entité eest à l'origine d'un évènement ou d'une action
|
|
||||||
- imputabilité : Responsabilité d'une entité par rapport à ses actions et décisions
|
|
||||||
- opposabilité : Possibilité d'opposer une action à son auteur devant un juge
|
|
||||||
- irréfutabilité / irréfragabilité : Après être passé devant un juge
|
|
||||||
|
|
||||||
## RASCI (fruit du rasciste)
|
|
||||||
|
|
||||||
- Responsible
|
|
||||||
- Accountable
|
|
||||||
- Support
|
|
||||||
- Consulted
|
|
||||||
- Informed
|
|
||||||
|
|
||||||
## Quel management ?
|
|
||||||
|
|
||||||
- sécurité du système en conception et
|
|
||||||
- s'assurer que les résultats des travaux d'ingéneierie de conception et d'intégration sont d'un niveau de sécurité suffisant ; et fournir toutes les informations nécessaires.
|
|
||||||
- Métiers
|
|
||||||
- gestion de la sécurité et pilotage des projets de sécurité
|
|
||||||
- conception
|
|
||||||
|
|
||||||
- sécurité de l'entreprise régulière
|
|
||||||
- s'assurer que les activités menées sont réalisées de manière sécurisée
|
|
||||||
|
|
||||||
## Cyber sécurité embarqué
|
|
||||||
|
|
||||||
Différences
|
|
||||||
- production pour une série
|
|
||||||
|
|
||||||
2
securite/vm/.gitignore
vendored
2
securite/vm/.gitignore
vendored
|
|
@ -1,2 +0,0 @@
|
||||||
/labtainer-vbox.ova
|
|
||||||
/labtainer
|
|
||||||
|
|
@ -1,4 +0,0 @@
|
||||||
#!/bin/sh
|
|
||||||
|
|
||||||
wget -O ./labtainer-vbox.ova "https://nps.box.com/shared/static/dn636n6h2d556nwqezx5w6cfc4cfeacl.ova"
|
|
||||||
vboxmanage import --basefolder=./labtainer labtainer-vbox.ova
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue