3. Controllo degli errori

3a. Tutti i messaggi inviati sulla rete saranno inizialmente sottoposti a controllo degli errori in modo da aiutare a isolare i bug software e hardware.

3b. A ogni messaggio sarà associato un checksum, dipendente dall'ordine.

3b1. Il seguente algoritmo è uno di quelli che potrebbero essere usati:

3b1a. Un checksum di lunghezza 1 può essere formato sommando in serie i campi successivi della stringa da controllare e aggiungendo il bit di riporto nella posizione di bit più bassa della somma.

              +--------------+
              |              |
              +---FIELD 1----+

          ADD +--------------+
              |              |
              +----FIELD 2---+

            +-+--------------+
            | |              |
            +-+--------------+
              \
               \          +--+
          ADD   CARRY---> |  |
                          +--+

              +--------------+
              |              |
              +----RESULT----+

3b1a1. Questo processo è noto come folding.

3b1a2. Più campi possono essere sommati e sottoposti a folding in parallelo, se vengono piegati in modo appropriato dopo l'addizione.

              +---------+---------+---------+---------+
              | FIELD 4 | FIELD 3 | FIELD 2 | FIELD 1 |
              +---------+---------+---------+---------+

              +---------+---------+---------+---------+
              | FIELD 8 | FIELD 7 | FIELD 6 | FIELD 5 |
              +---------+---------+---------+---------+
            ADD
            +-+---------+---------+---------+---------+
            | |         |         |         |         |
            +-+---------+---------+---------+---------+
             |      |        |         |         |
             |      |        |         |         v
             |      |        |         |    +---------+
             |      |        |         |    |         |
             |      |        |         |    +---------+
             |      |        |         |
             |      |        |         \    +---------+
             |      |        |          `-> |         |
             |      |        |              +---------+
             |      |        |
             |      |        \              +---------+
             |      |         `-----------> |         |
             |      |                       +---------+
             |      |
             |      \                       +---------+
             |       `--------------------->|         |
             |                              +---------+
             |
             \                                    +---+
              `-----CARRY------------------------>|   |
                                                  +---+
                                  ADD
                                  +---------+---------+
                                  |         |         |
                                  +--CARRY--+---------+
                                       |
                                       \        +-----+
                                    ADD `-----> |     |
                                                +-----+

                                            +---------+
                                            |         |
                                            +-RESULT--+

3b1a2a. Con questo schema si assume che, se ci sono n campi, i riporti dai primi n-1 campi vengano automaticamente aggiunti nella posizione di ordine inferiore del campo immediatamente superiore, cosicché nel folding è sufficiente sommare gli [n] campi risultanti al riporto dell'n-esimo campo e poi aggiungere un riporto di dimensione appropriata da tale addizione (e ripetere il numero di volte desiderato per ottenere il risultato).

3b1a3. Un checksum calcolato in questo modo ha il vantaggio che le lunghezze di parola delle diverse macchine possono essere sfruttate ciascuna in modo ottimale:

3b1a3a. Se si sceglie una stringa di lunghezza adeguata per calcolare il checksum e si seleziona una lunghezza adeguata del campo checksum, la tecnica di checksum sarà relativamente ottimale per ciascuna delle macchine.

3b1a3a1. Lunghezza del campo: 288 bit (minimo comune denominatore di (24,32,36)

3b1a3a2. Lunghezza del checksum: 8 bit (dimensione di campo comoda per tutte le macchine)

3b1b. Se un messaggio è diviso in gruppi di campi e ciascun gruppo è sottoposto a checksum in questo modo, si può ottenere un checksum dipendente dall'ordine spostando il checksum di ciascun gruppo e sommandolo (successivamente) al checksum del gruppo successivo

3c. Sarà fornita una funzionalità che consente a due HOST di entrare in una modalità che richiede la verifica positiva di tutti i messaggi. Tale verifica viene inviata sul collegamento di controllo.