---
# System prepended metadata

title: SYD - TD1
tags: [TD, SYD]

---

# SYD - TD1
###### tags: `SYD` `TD`

## Qu'est-ce qu'un système distribué ?

C'est un système dans lequel les unités de calcul sont autonomes.

Il en existe 2 types : 
- Asynchrone (ex: internet car le réseau n'est pas synchronisé)
- Synchrone (ex: un PC car les transferts entre coeurs sont pilotés par une horloge)

## Un exemple d'application

``` java
package toto;

public class Partie {
    public static void main(String [] args){
        Jeux j = new Jeux();
        Tour t = j.joue(1);
    }
}

public class Jeux{
    public Tour joue(int i){
        return new Tour();
    }
}

public class Tour {}
```

Ici cette application s'exécute fonctions après fonctions. Imaginons maintenant que cette application soit composée de plusieurs milliers de lignes si bien qu'il faille répartir la charge sur plusieurs machines en simultané.

Pour faire cela, on doit utiliser l'api socket.

``` java
//attention ce code n'est pas fonctionnel (il faut convertir les transmissions en bytes, etc...) il sert juste à avoir une idée.

//partie serveur
ServerSocket blabla = new ServerSocket(1234);
DataInputStream is = new DataInputStream(s.getInputStream);
DataOutputStream os = new DataOutputStream(s.getOutputStream);

while(true){
Socket s = blabla.accept();
//puis ensuite notre code
String com = s.receive();
int arg = is.receive;
//process : je cherche la fonction correspondante à ma commande par ex: 'joue' puis de l'argument
if com.equals("joue"){
    os.send(new Jeux().joue(arg)); //le resultat de la commande
}
}

//partie client
Socket s = new Socket('192.168.1.18',1234);
//de base on met les input/output stream
InputStream is = s.getInputStream();
OutputStream os = s.getOutputStream();

//mais il vaut mieux utiliser les datainputstream car ça va mettre en forme le flux (pas besoin de convertir en bytes)
DataInputStream is = new DataInputStream(s.getInputStream);
DataOutputStream os = new DataOutputStream(s.getOutputStream);
//ou sinon on peut utiliser les printwriter ou encore ObjectInputStream

os.send('ma_commande_pour_lancer_le_jeu');
os.send('argument');
Tour t = is.receive();
```

## RPC

*Est-ce que je peux transformer une application en distribué de manière automatique ?*

Une fois qu'on a écrit la partie socket, on peut la transcrire dans beaucoup de codes différents, seule la signature des fonctions change. On peut alors automatiser en créant un générateur de code distribué, c'est à dire un compilateur spécifique (cf TP).





