ਭਰੋਸੇਯੋਗ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਦੇ ਬੁਨਿਆਦੀ ਤੱਤ

ਜਿਨ੍ਹਾਂ ਨੂੰ ਭਾਲਦਾ ਹੈ ਨੈਟਵਰਕ ਅਤੇ ਪ੍ਰੋਟੋਕੋਲ ਨੂੰ ਸਮਝਣ ਲਈ ਸਮਰਪਿਤ.

ਸੰਖੇਪ ਵਿੱਚ

ਲੇਖ ਭਰੋਸੇਯੋਗ ਡੇਟਾ ਟ੍ਰਾਂਸਮਿਸ਼ਨ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ ਦੀ ਚਰਚਾ ਕਰਦਾ ਹੈ, ਉਦਾਹਰਣਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ Go, UDP ਅਤੇ TCP ਸਮੇਤ। ਦੇ ਅਧਾਰ ਤੇ ਵਾਰ, два, ਤਿੰਨ ਅਤੇ ਕਿਤਾਬਾਂ "ਕੰਪਿਊਟਰ ਨੈਟਵਰਕਸ. ਟਾਪ-ਡਾਊਨ ਅਪ੍ਰੋਚ", ਨਹੀਂ ਤਾਂ ਹਰ ਕੋਈ ਸਿਰਫ ਟੈਨੇਨਬੌਮ ਅਤੇ ਓਲੀਫੇਰੋਵ ਬਾਰੇ ਹੀ ਚਰਚਾ ਕਰ ਰਿਹਾ ਹੈ।

ਟ੍ਰਾਂਸਪੋਰਟ ਲੇਅਰ ਪ੍ਰੋਟੋਕੋਲ

ਵੱਖ-ਵੱਖ ਮੇਜ਼ਬਾਨਾਂ 'ਤੇ ਚੱਲ ਰਹੀਆਂ ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿਚਕਾਰ ਇੱਕ ਲਾਜ਼ੀਕਲ ਕਨੈਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਇੱਕ ਲਾਜ਼ੀਕਲ ਕੁਨੈਕਸ਼ਨ ਇੱਕ ਚੈਨਲ ਦੀ ਤਰ੍ਹਾਂ ਦਿਸਦਾ ਹੈ ਜੋ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਸਿੱਧਾ ਜੋੜਦਾ ਹੈ।

ਟ੍ਰਾਂਸਪੋਰਟ ਲੇਅਰ ਪ੍ਰੋਟੋਕੋਲ ਐਂਡ ਸਿਸਟਮ ਦੁਆਰਾ ਸਮਰਥਿਤ ਹਨ, ਪਰ ਨੈਟਵਰਕ ਰਾਊਟਰਾਂ ਦੁਆਰਾ ਨਹੀਂ (ਸਿਵਾਏ - DPI). ਭੇਜਣ ਵਾਲੇ ਪਾਸੇ, ਟ੍ਰਾਂਸਪੋਰਟ ਲੇਅਰ ਐਪਲੀਕੇਸ਼ਨ ਲੇਅਰ ਡੇਟਾ ਨੂੰ ਭੇਜਣ ਦੀ ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਪ੍ਰਾਪਤ ਹੋਣ ਵਾਲੇ ਟ੍ਰਾਂਸਪੋਰਟ ਲੇਅਰ ਪੈਕੇਟਾਂ ਵਿੱਚ ਬਦਲਦੀ ਹੈ ਜਿਸਨੂੰ ਖੰਡ ਕਹਿੰਦੇ ਹਨ।

ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਲੇਅਰ ਸੁਨੇਹਿਆਂ ਨੂੰ ਟੁਕੜਿਆਂ ਵਿੱਚ ਵੰਡ ਕੇ (ਜੇ ਲੋੜ ਹੋਵੇ) ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਵਿੱਚ ਇੱਕ ਟ੍ਰਾਂਸਪੋਰਟ ਲੇਅਰ ਹੈਡਰ ਜੋੜ ਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਟਰਾਂਸਪੋਰਟ ਲੇਅਰ ਫਿਰ ਖੰਡ ਨੂੰ ਭੇਜਣ ਵਾਲੇ ਦੀ ਨੈੱਟਵਰਕ ਲੇਅਰ ਵਿੱਚ ਭੇਜਦੀ ਹੈ, ਜਿੱਥੇ ਖੰਡ ਨੂੰ ਇੱਕ ਨੈੱਟਵਰਕ ਲੇਅਰ ਪੈਕੇਟ (ਡੇਟਾਗ੍ਰਾਮ) ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ। ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਿਰੇ 'ਤੇ, ਨੈੱਟਵਰਕ ਲੇਅਰ ਡੇਟਾਗ੍ਰਾਮ ਤੋਂ ਟ੍ਰਾਂਸਪੋਰਟ ਲੇਅਰ ਖੰਡ ਨੂੰ ਕੱਢਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਟ੍ਰਾਂਸਪੋਰਟ ਲੇਅਰ ਤੱਕ ਪਹੁੰਚਾਉਂਦੀ ਹੈ। ਅੱਗੇ, ਟਰਾਂਸਪੋਰਟ ਲੇਅਰ ਪ੍ਰਾਪਤ ਕੀਤੇ ਹਿੱਸੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦੀ ਹੈ ਤਾਂ ਜੋ ਇਸਦਾ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੀ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਉਪਲਬਧ ਹੋ ਸਕੇ।

ਭਰੋਸੇਯੋਗ ਡਾਟਾ ਸੰਚਾਰ ਦੇ ਅਸੂਲ

ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸੁਰੱਖਿਅਤ ਚੈਨਲ ਉੱਤੇ ਭਰੋਸੇਯੋਗ ਡਾਟਾ ਸੰਚਾਰ

ਸਧਾਰਨ ਕੇਸ. ਭੇਜਣ ਵਾਲੀ ਸਾਈਡ ਉੱਪਰਲੀ ਪਰਤ ਤੋਂ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ, ਇਸ ਨੂੰ ਰੱਖਣ ਵਾਲਾ ਇੱਕ ਪੈਕੇਟ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਸਨੂੰ ਚੈਨਲ ਨੂੰ ਭੇਜਦਾ ਹੈ।

ਸਰਵਰ

package main

import (
    "log"
    "net"
)

func main() {
    // IP-адрес сервера и порт
    serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000")
    if err != nil {
        log.Fatal(err)
    }

    // создаем сокет с портом
    serverConn, err := net.ListenUDP("udp", serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    // отложенное закрытие соединения
    defer serverConn.Close()

    // создаем буфер для данных
    buf := make([]byte, 1024)

    // ждем соединение
    for {
        // читаем запрос
        n, addr, err := serverConn.ReadFromUDP(buf)
        // передаем данные в ВЕРХНИЙ уровень: в нашем случае stdout
        println(string(buf[0:n]), " form ", addr.IP.String())
        if err != nil {
            log.Fatal(err)
        }
        // ответа нет, т.к. это UDP + надежный канал
    }
}

ਗਾਹਕ

package main

import (
    "fmt"
    "log"
    "net"
    "time"
)

func main() {
    // IP-адрес сервера и порт
    serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000")
    if err != nil {
        log.Fatal(err)
    }
    // локальный IP-адрес и порт
    localAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
    if err != nil {
        log.Fatal(err)
    }
    // установка соединения
    conn, err := net.DialUDP("udp", localAddr, serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    // отложенное закрытие соединения
    defer conn.Close()

    for {
        // получение данных от ВЕРХНЕГО уровня
        fmt.Print("Введите строчное предложение > ")
        var msg string
        _, err := fmt.Scanf("%s", &msg)
        if err != nil {
            log.Fatal(err)
        }
        // передается поток байт, а не строка
        buf := []byte(msg)
        // запись (передача) в соединение
        _, err = conn.Write(buf)
        if err != nil {
            log.Fatal(err)
        }
        // 1 секундочку
        time.Sleep(time.Second * 1)
    }
}

ਸੰਭਾਵਿਤ ਤਰੁੱਟੀਆਂ ਵਾਲੇ ਚੈਨਲ ਉੱਤੇ ਭਰੋਸੇਯੋਗ ਡਾਟਾ ਪ੍ਰਸਾਰਣ

ਅਗਲਾ ਕਦਮ ਇਹ ਮੰਨਣਾ ਹੈ ਕਿ ਸਾਰੇ ਪ੍ਰਸਾਰਿਤ ਪੈਕੇਟ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕੀਤੇ ਗਏ ਹਨ ਜਿਸ ਵਿੱਚ ਉਹ ਭੇਜੇ ਗਏ ਸਨ, ਪਰ ਉਹਨਾਂ ਵਿੱਚ ਬਿੱਟ ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਖਰਾਬ ਹੋ ਸਕਦੇ ਹਨ ਕਿ ਚੈਨਲ ਕਈ ਵਾਰੀ ਵਿਗਾੜਾਂ ਨਾਲ ਡੇਟਾ ਪ੍ਰਸਾਰਿਤ ਕਰਦਾ ਹੈ।

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਹੇਠ ਲਿਖੀਆਂ ਵਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ:

• ਗਲਤੀ ਖੋਜ;
• ਸੁਝਾਅ;
• ਮੁੜ ਪ੍ਰਸਾਰਣ.

ਭਰੋਸੇਮੰਦ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਪ੍ਰੋਟੋਕੋਲ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਟ੍ਰਾਂਸਮਿਸ਼ਨ ਨੂੰ ਕਈ ਵਾਰ ਦੁਹਰਾਉਣ ਲਈ ਸਮਾਨ ਵਿਧੀ ਹੁੰਦੀ ਹੈ, ਨੂੰ ਆਟੋਮੈਟਿਕ ਰੀਪੀਟ ਰੀਕੁਏਸਟ (ARQ) ਪ੍ਰੋਟੋਕੋਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਰਸੀਦਾਂ ਵਿੱਚ ਤਰੁੱਟੀਆਂ ਦੀ ਸੰਭਾਵਨਾ 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਮਹੱਤਵਪੂਰਣ ਹੈ, ਜਦੋਂ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੀ ਧਿਰ ਨੂੰ ਆਖਰੀ ਪੈਕੇਟ ਦੇ ਟ੍ਰਾਂਸਫਰ ਦੇ ਨਤੀਜਿਆਂ ਬਾਰੇ ਕੋਈ ਜਾਣਕਾਰੀ ਨਹੀਂ ਮਿਲੇਗੀ।
ਇਸ ਸਮੱਸਿਆ ਦਾ ਹੱਲ, TCP ਵਿੱਚ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਪੈਕੇਟ ਦੇ ਕ੍ਰਮ ਨੰਬਰ ਵਾਲੇ ਡੇਟਾ ਪੈਕੇਟ ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਖੇਤਰ ਜੋੜਨਾ ਹੈ।

ਪੈਕੇਟ ਵਿਗਾੜ ਅਤੇ ਨੁਕਸਾਨ ਦੇ ਅਧੀਨ ਇੱਕ ਅਵਿਸ਼ਵਾਸ਼ਯੋਗ ਚੈਨਲ ਉੱਤੇ ਭਰੋਸੇਯੋਗ ਡੇਟਾ ਪ੍ਰਸਾਰਣ

ਵਿਗਾੜ ਦੇ ਨਾਲ, ਬਦਕਿਸਮਤੀ ਨਾਲ, ਨੈਟਵਰਕ ਵਿੱਚ ਪੈਕੇਟ ਦਾ ਨੁਕਸਾਨ ਹੁੰਦਾ ਹੈ.
ਅਤੇ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਵਿਧੀ ਦੀ ਲੋੜ ਹੈ:

• ਪੈਕੇਟ ਦੇ ਨੁਕਸਾਨ ਦੇ ਤੱਥ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ;
• ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੀ ਪਾਰਟੀ ਨੂੰ ਗੁੰਮ ਹੋਏ ਪੈਕੇਟਾਂ ਦੀ ਮੁੜ ਡਿਲੀਵਰੀ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪੈਕੇਜ ਦੇ ਨੁਕਸਾਨ ਤੋਂ ਇਲਾਵਾ, ਰਸੀਦ ਦੇ ਨੁਕਸਾਨ ਦੀ ਸੰਭਾਵਨਾ ਪ੍ਰਦਾਨ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ ਜਾਂ, ਜੇ ਕੁਝ ਵੀ ਨਹੀਂ ਗੁਆਚਿਆ ਹੈ, ਤਾਂ ਇਸਦੀ ਡਿਲਿਵਰੀ ਮਹੱਤਵਪੂਰਣ ਦੇਰੀ ਨਾਲ. ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਇੱਕੋ ਗੱਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ: ਪੈਕੇਟ ਨੂੰ ਮੁੜ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਸਮੇਂ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ, ਇਹ ਵਿਧੀ ਕਾਉਂਟਡਾਉਨ ਟਾਈਮਰ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਉਡੀਕ ਅੰਤਰਾਲ ਦੇ ਅੰਤ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਇਸ ਲਈ ਪੈਕੇਜ ਵਿੱਚ ਸ਼ੁੱਧ TCPKeepAlive ਨੂੰ ਮੂਲ ਰੂਪ ਵਿੱਚ 15 ਸਕਿੰਟਾਂ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ:

// defaultTCPKeepAlive is a default constant value for TCPKeepAlive times
// See golang.org/issue/31510
const (
    defaultTCPKeepAlive = 15 * time.Second
)

ਭੇਜਣ ਵਾਲੇ ਪਾਸੇ ਨੂੰ ਹਰ ਵਾਰ ਜਦੋਂ ਇੱਕ ਪੈਕੇਟ ਸੰਚਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਪਹਿਲੀ ਅਤੇ ਦੂਜੀ ਵਾਰ) ਇੱਕ ਟਾਈਮਰ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਟਾਈਮਰ ਤੋਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਸੰਭਾਲਣਾ ਅਤੇ ਇਸਨੂੰ ਰੋਕਣਾ ਹੁੰਦਾ ਹੈ।

ਇਸ ਲਈ, ਅਸੀਂ ਭਰੋਸੇਯੋਗ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਪ੍ਰੋਟੋਕੋਲ ਦੇ ਮੁੱਖ ਸੰਕਲਪਾਂ ਤੋਂ ਜਾਣੂ ਹੋ ਗਏ ਹਾਂ:

• ਚੈੱਕਸਮ;
• ਪੈਕੇਜਾਂ ਦੀ ਕ੍ਰਮ ਸੰਖਿਆ;
• ਟਾਈਮਰ;
• ਸਕਾਰਾਤਮਕ ਅਤੇ ਨਕਾਰਾਤਮਕ ਰਸੀਦਾਂ.

ਪਰ ਇਹ ਸਭ ਕੁਝ ਨਹੀਂ ਹੈ!

ਪਾਈਪਲਾਈਨਿੰਗ ਦੇ ਨਾਲ ਭਰੋਸੇਯੋਗ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਪ੍ਰੋਟੋਕੋਲ

ਵੇਰੀਐਂਟ ਵਿੱਚ ਜਿਸ ਬਾਰੇ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਵਿਚਾਰ ਕਰ ਚੁੱਕੇ ਹਾਂ, ਭਰੋਸੇਯੋਗ ਡਿਲਿਵਰੀ ਪ੍ਰੋਟੋਕੋਲ ਬਹੁਤ ਅਕੁਸ਼ਲ ਹੈ। ਇਹ ਸੰਚਾਰ ਚੈਨਲ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਪ੍ਰਸਾਰਣ ਨੂੰ "ਹੌਲੀ" ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ RTT ਵਧਦਾ ਹੈ। ਇਸਦੀ ਕੁਸ਼ਲਤਾ ਨੂੰ ਵਧਾਉਣ ਅਤੇ ਸੰਚਾਰ ਚੈਨਲ ਦੀ ਸਮਰੱਥਾ ਦੀ ਬਿਹਤਰ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਪਾਈਪਲਾਈਨਿੰਗ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਪਾਈਪਲਾਈਨਿੰਗ ਦੀ ਵਰਤੋਂ ਇਸ ਵੱਲ ਲੈ ਜਾਂਦੀ ਹੈ:

• ਕ੍ਰਮ ਸੰਖਿਆਵਾਂ ਦੀ ਰੇਂਜ ਨੂੰ ਵਧਾਉਣਾ, ਕਿਉਂਕਿ ਸਾਰੇ ਭੇਜੇ ਗਏ ਪੈਕੇਟ (ਰੀਟ੍ਰਾਂਸਮਿਸ਼ਨ ਨੂੰ ਛੱਡ ਕੇ) ਵਿਲੱਖਣ ਤੌਰ 'ਤੇ ਪਛਾਣੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ;
• ਪ੍ਰਸਾਰਣ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਪਾਸੇ ਬਫਰਾਂ ਨੂੰ ਵਧਾਉਣ ਦੀ ਜ਼ਰੂਰਤ.

ਕ੍ਰਮ ਨੰਬਰ ਰੇਂਜ ਅਤੇ ਬਫਰ ਆਕਾਰ ਦੀਆਂ ਲੋੜਾਂ ਪੈਕੇਟ ਭ੍ਰਿਸ਼ਟਾਚਾਰ, ਨੁਕਸਾਨ ਅਤੇ ਦੇਰੀ ਦੇ ਜਵਾਬ ਵਿੱਚ ਪ੍ਰੋਟੋਕੋਲ ਦੁਆਰਾ ਕੀਤੀਆਂ ਕਾਰਵਾਈਆਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ। ਪਾਈਪਲਾਈਨਿੰਗ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਨ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ:

• N ਪੈਕੇਟ ਵਾਪਸ ਵਾਪਸ ਕਰੋ;
• ਚੋਣਵੇਂ ਦੁਹਰਾਓ.

N ਪੈਕੇਟ ਵਾਪਸ ਜਾਣਾ - ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਪ੍ਰੋਟੋਕੋਲ

ਭੇਜਣ ਵਾਲੇ ਨੂੰ ਤਿੰਨ ਕਿਸਮ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦਾ ਸਮਰਥਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:

• ਉੱਚ ਪੱਧਰੀ ਪ੍ਰੋਟੋਕੋਲ ਦੁਆਰਾ ਕਾਲ ਕਰੋ। ਜਦੋਂ ਡੇਟਾ ਭੇਜਣ ਵਾਲੇ ਫੰਕਸ਼ਨ ਨੂੰ "ਉੱਪਰ ਤੋਂ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਭੇਜਣ ਵਾਲਾ ਪੱਖ ਪਹਿਲਾਂ ਵਿੰਡੋ ਨੂੰ ਭਰਨ ਦੀ ਡਿਗਰੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ (ਅਰਥਾਤ, ਰਸੀਦਾਂ ਦੀ ਪ੍ਰਾਪਤੀ ਦੀ ਉਡੀਕ ਵਿੱਚ N ਭੇਜੇ ਗਏ ਸੁਨੇਹਿਆਂ ਦੀ ਮੌਜੂਦਗੀ)। ਜੇਕਰ ਵਿੰਡੋ ਖਾਲੀ ਹੈ, ਤਾਂ ਇੱਕ ਨਵਾਂ ਪੈਕੇਟ ਤਿਆਰ ਅਤੇ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਵੇਰੀਏਬਲ ਮੁੱਲ ਅੱਪਡੇਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਨਹੀਂ ਤਾਂ, ਭੇਜਣ ਵਾਲਾ ਪਾਸਾ ਉੱਪਰਲੀ ਪਰਤ ਨੂੰ ਡੇਟਾ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਇੱਕ ਸਪੱਸ਼ਟ ਸੰਕੇਤ ਹੈ ਕਿ ਵਿੰਡੋ ਭਰੀ ਹੋਈ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਉਪਰਲੀ ਪਰਤ ਕੁਝ ਸਮੇਂ ਬਾਅਦ ਦੁਬਾਰਾ ਡਾਟਾ ਸੰਚਾਰਿਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੇਗੀ। ਇੱਕ ਅਸਲ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ, ਭੇਜਣ ਵਾਲਾ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਡੇਟਾ ਨੂੰ ਬਫਰ ਕਰੇਗਾ (ਇਸ ਨੂੰ ਤੁਰੰਤ ਭੇਜਣ ਦੀ ਬਜਾਏ) ਜਾਂ ਇੱਕ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਵਿਧੀ (ਜਿਵੇਂ ਕਿ ਸੈਮਾਫੋਰ ਜਾਂ ਫਲੈਗ) ਹੋਵੇਗੀ ਜੋ ਉੱਪਰਲੀ ਪਰਤ ਨੂੰ ਭੇਜੋ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗੀ ਜਦੋਂ ਵਿੰਡੋ ਖਾਲੀ ਹੋਵੇ। .
• ਪੁਸ਼ਟੀ ਪ੍ਰਾਪਤ ਕਰ ਰਿਹਾ ਹੈ। ਪ੍ਰੋਟੋਕੋਲ ਵਿੱਚ, ਕ੍ਰਮ ਨੰਬਰ N ਵਾਲੇ ਇੱਕ ਪੈਕੇਟ ਲਈ, ਇੱਕ ਆਮ ਮਾਨਤਾ ਜਾਰੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਇਹ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ N ਤੋਂ ਪਹਿਲਾਂ ਵਾਲੇ ਕ੍ਰਮ ਨੰਬਰਾਂ ਵਾਲੇ ਸਾਰੇ ਪੈਕੇਟ ਸਫਲਤਾਪੂਰਵਕ ਪ੍ਰਾਪਤ ਹੋਏ ਸਨ।
• ਉਡੀਕ ਅੰਤਰਾਲ ਦੀ ਮਿਆਦ ਪੁੱਗ ਗਈ ਹੈ। ਪੈਕੇਟਾਂ ਅਤੇ ਰਸੀਦਾਂ ਦੇ ਨੁਕਸਾਨ ਅਤੇ ਦੇਰੀ ਦੇ ਤੱਥਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ, ਪ੍ਰੋਟੋਕੋਲ ਇੱਕ ਟਾਈਮਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਸਮਾਂ ਸਮਾਪਤੀ ਅੰਤਰਾਲ ਦੀ ਮਿਆਦ ਪੁੱਗ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਭੇਜਣ ਵਾਲੀ ਸਾਈਡ ਸਾਰੇ ਭੇਜੇ ਗਏ ਅਣਪਛਾਤੇ ਪੈਕੇਟਾਂ ਨੂੰ ਦੁਬਾਰਾ ਭੇਜਦੀ ਹੈ।

ਚੋਣਵੇਂ ਦੁਹਰਾਓ

ਜਦੋਂ ਵਿੰਡੋ ਦਾ ਆਕਾਰ ਅਤੇ ਥ੍ਰੁਪੁੱਟ-ਪ੍ਰਸਾਰ ਦੇਰੀ ਉਤਪਾਦ ਵੱਡਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਪੈਕੇਟ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਹੋ ਸਕਦੇ ਹਨ। ਅਜਿਹੀ ਸਥਿਤੀ ਵਿੱਚ, ਇੱਕ ਸਿੰਗਲ ਪੈਕੇਟ ਦੀ ਗਲਤੀ ਕਾਰਨ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਪੈਕੇਟਾਂ ਨੂੰ ਮੁੜ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਦੀ ਲੋੜ ਨਹੀਂ ਸੀ।

ਉਦਾਹਰਨ:

ਸਭ ਤੋਂ ਵਧੀਆ ਸਿਧਾਂਤਕ ਅਭਿਆਸਾਂ ਨੂੰ ਅਮਲੀ ਅਮਲ ਵਿੱਚ ਇਕੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ TCP. ਅਤੇ ਜੇ ਕੋਈ ਜਾਣਦਾ ਹੈ ਕਿ ਸਭ ਤੋਂ ਵਧੀਆ - ਸਵਾਗਤ.

ਸਰਵਰ

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "strings"
)

func main() {
    // создаем сокет с портом 
    ln, err := net.Listen("tcp", ":8081")
    if err != nil {
        log.Fatalln(err)
    }
    // ожидание вызова
    conn, _ := ln.Accept()

    for {
        // считывание данных
        msg, err := bufio.NewReader(conn).ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // вывод сообщения в stdout
        fmt.Print("Message Received:", string(msg))
        // перевод строки в верхний регистр
        newMsg := strings.ToUpper(msg)
        // отправка данных
        conn.Write([]byte(newMsg + "n"))
    }
}

ਗਾਹਕ

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "os"
)

func main() {
    // установка соединения
    conn, err := net.Dial("tcp", "127.0.0.1:8081")
    if err != nil {
        log.Fatalln(err)
    }

    for {
        // считывание данных с stdin
        reader := bufio.NewReader(os.Stdin)
        fmt.Print("Text to send: ")
        // построчно
        text, err := reader.ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // отправка
        fmt.Fprintf(conn, text+"n")
        // прием
        msg, err := bufio.NewReader(conn).ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // вывод полученного ответа
        fmt.Print("Msg from Server: " + msg)
    }
}

ਸਿੱਟਾ

ਭਰੋਸੇਯੋਗ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਅਤੇ ਵਰਤੋਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵਿਧੀ

ਮਕੈਨਿਜਮ
ਐਪਲੀਕੇਸ਼ਨ, ਟਿੱਪਣੀ

ਰਕਮ ਦੀ ਜਾਂਚ ਕਰੋ
ਇੱਕ ਪ੍ਰਸਾਰਿਤ ਪੈਕੇਟ ਵਿੱਚ ਬਿੱਟ ਗਲਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ

ਟਾਈਮਰ
ਸਮਾਂ ਸਮਾਪਤੀ ਅੰਤਰਾਲ ਨੂੰ ਗਿਣਦਾ ਹੈ ਅਤੇ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇਹ ਕਦੋਂ ਖਤਮ ਹੋ ਗਿਆ ਹੈ। ਬਾਅਦ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਉੱਚ ਪੱਧਰੀ ਸੰਭਾਵਨਾ ਦੇ ਨਾਲ ਪੈਕੇਟ ਜਾਂ ਇਸਦੀ ਰਸੀਦ ਪ੍ਰਸਾਰਣ ਦੌਰਾਨ ਗੁੰਮ ਹੋ ਜਾਂਦੀ ਹੈ। ਜੇ ਇੱਕ ਪੈਕੇਟ ਇੱਕ ਦੇਰੀ ਨਾਲ ਡਿਲੀਵਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਗੁੰਮ ਨਹੀਂ ਹੁੰਦਾ (ਸਮਾਂ ਸਮਾਪਤੀ ਅੰਤਰਾਲ ਦੀ ਸਮੇਂ ਤੋਂ ਪਹਿਲਾਂ ਸਮਾਪਤੀ), ਜਾਂ ਇੱਕ ਰਸੀਦ ਗੁੰਮ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਮੁੜ ਪ੍ਰਸਾਰਣ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਪਾਸੇ ਇੱਕ ਡੁਪਲੀਕੇਟ ਪੈਕੇਟ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ

ਕ੍ਰਮ ਸੰਖਿਆ
ਭੇਜਣ ਵਾਲੇ ਤੋਂ ਪ੍ਰਾਪਤਕਰਤਾ ਤੱਕ ਪ੍ਰਸਾਰਿਤ ਡੇਟਾ ਪੈਕੇਟਾਂ ਦੀ ਕ੍ਰਮਵਾਰ ਸੰਖਿਆ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਪ੍ਰਾਪਤ ਕੀਤੇ ਪੈਕੇਟਾਂ ਦੇ ਕ੍ਰਮ ਨੰਬਰਾਂ ਵਿੱਚ ਅੰਤਰ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਨੂੰ ਪੈਕੇਟ ਦੇ ਨੁਕਸਾਨ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ। ਇੱਕੋ ਪੈਕੇਟ ਕ੍ਰਮ ਨੰਬਰਾਂ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪੈਕੇਟ ਇੱਕ ਦੂਜੇ ਦੇ ਡੁਪਲੀਕੇਟ ਹਨ

ਪੁਸ਼ਟੀ
ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਿਰੇ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਭੇਜਣ ਵਾਲੇ ਅੰਤ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਸੰਬੰਧਿਤ ਪੈਕੇਟ ਜਾਂ ਪੈਕਟਾਂ ਦਾ ਸਮੂਹ ਸਫਲਤਾਪੂਰਵਕ ਪ੍ਰਾਪਤ ਹੋ ਗਿਆ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਰਸੀਦ ਵਿੱਚ ਸਫਲਤਾਪੂਰਵਕ ਪ੍ਰਾਪਤ ਹੋਏ ਪੈਕੇਟਾਂ ਦੇ ਕ੍ਰਮ ਨੰਬਰ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਪ੍ਰੋਟੋਕੋਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਵਿਅਕਤੀਗਤ ਅਤੇ ਸਮੂਹ ਪੁਸ਼ਟੀਕਰਨਾਂ ਨੂੰ ਵੱਖ ਕੀਤਾ ਜਾਂਦਾ ਹੈ

ਨਕਾਰਾਤਮਕ ਪੁਸ਼ਟੀ
ਪ੍ਰਾਪਤਕਰਤਾ ਦੁਆਰਾ ਭੇਜਣ ਵਾਲੇ ਨੂੰ ਸੂਚਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਪੈਕੇਟ ਗਲਤ ਢੰਗ ਨਾਲ ਪ੍ਰਾਪਤ ਹੋਇਆ ਸੀ। ਇੱਕ ਨਕਾਰਾਤਮਕ ਰਸੀਦ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਪੈਕੇਟ ਦਾ ਕ੍ਰਮ ਨੰਬਰ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਜੋ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰਾਪਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ

ਵਿੰਡੋ, ਕਨਵੇਅਰਾਈਜ਼ੇਸ਼ਨ
ਕ੍ਰਮ ਨੰਬਰਾਂ ਦੀ ਰੇਂਜ ਨੂੰ ਸੀਮਤ ਕਰੋ ਜੋ ਪੈਕੇਟਾਂ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਮਲਟੀਕਾਸਟ ਅਤੇ ਹੈਂਡਸ਼ੇਕ ਮਾਨਤਾਵਾਂ ਦੀ ਉਡੀਕ ਕਰਨ ਦੇ ਮੁਕਾਬਲੇ ਪ੍ਰੋਟੋਕੋਲ ਥ੍ਰੁਪੁੱਟ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਵਧਾ ਸਕਦੇ ਹਨ। ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖਾਂਗੇ, ਵਿੰਡੋ ਦੇ ਆਕਾਰ ਦੀ ਗਣਨਾ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਿਰੇ ਦੀ ਰਿਸੈਪਸ਼ਨ ਅਤੇ ਬਫਰਿੰਗ ਸਮਰੱਥਾਵਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਨੈੱਟਵਰਕ ਲੋਡ ਪੱਧਰ ਦੇ ਆਧਾਰ 'ਤੇ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਨੈੱਟਵਰਕਿੰਗ ਲਈ ਗੋ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਹੋਰ ਉਦਾਹਰਣਾਂ

В ਰਿਪੋਜ਼ਟਰੀਆਂ.

ਸਰੋਤ: www.habr.com