ವಿಶ್ವಾಸಾರ್ಹ ಡೇಟಾ ವರ್ಗಾವಣೆಯ ಮೂಲಭೂತ ಅಂಶಗಳು

ಯಾರು ಅವರಿಗೆ ಹುಡುಕುತ್ತದೆ ನೆಟ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಪ್ರೋಟೋಕಾಲ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಮರ್ಪಿತವಾಗಿದೆ.

ಸಂಕ್ಷಿಪ್ತವಾಗಿ

ಈ ಲೇಖನವು ವಿಶ್ವಾಸಾರ್ಹ ದತ್ತಾಂಶ ಪ್ರಸರಣದ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಚರ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಉದಾಹರಣೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ Go, UDP ಮತ್ತು TCP ಸೇರಿದಂತೆ. ಆಧರಿಸಿದೆ ಬಾರಿ, два, ಮೂರು ಮತ್ತು "ಕಂಪ್ಯೂಟರ್ ನೆಟ್‌ವರ್ಕ್ಸ್. ಎ ಟಾಪ್-ಡೌನ್ ಅಪ್ರೋಚ್" ಪುಸ್ತಕ, ಇಲ್ಲದಿದ್ದರೆ ಎಲ್ಲರೂ ಟ್ಯಾನೆನ್‌ಬಾಮ್ ಮತ್ತು ಒಲಿಫೆರೋವ್ ಬಗ್ಗೆ ಮಾತ್ರ ಚರ್ಚಿಸುತ್ತಾರೆ.

ಸಾರಿಗೆ ಪದರ ಪ್ರೋಟೋಕಾಲ್

ವಿಭಿನ್ನ ಹೋಸ್ಟ್‌ಗಳಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ತಾರ್ಕಿಕ ಸಂಪರ್ಕವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ನೇರವಾಗಿ ಸಂಪರ್ಕಿಸುವ ಚಾನಲ್‌ನಂತೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ತಾರ್ಕಿಕ ಸಂಪರ್ಕವು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ಸಾರಿಗೆ ಪದರ ಪ್ರೋಟೋಕಾಲ್‌ಗಳು ಅಂತಿಮ ವ್ಯವಸ್ಥೆಗಳಿಂದ ಬೆಂಬಲಿಸಲಾಗುತ್ತದೆ ಆದರೆ ನೆಟ್‌ವರ್ಕ್ ರೂಟರ್‌ಗಳಿಂದ ಅಲ್ಲ (ಹೊರತುಪಡಿಸಿ - ಡಿಪಿಐ). ಕಳುಹಿಸುವವರ ಬದಿಯಲ್ಲಿ, ಸಾರಿಗೆ ಪದರವು ರವಾನಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಕ್ರಿಯೆಯಿಂದ ಸ್ವೀಕರಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ಪದರದ ಡೇಟಾವನ್ನು ವಿಭಾಗಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುವ ಸಾರಿಗೆ ಪದರ ಪ್ಯಾಕೆಟ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.

(ಅಗತ್ಯವಿದ್ದರೆ) ಅಪ್ಲಿಕೇಶನ್ ಲೇಯರ್ ಸಂದೇಶಗಳನ್ನು ತುಣುಕುಗಳಾಗಿ ವಿಭಜಿಸುವ ಮೂಲಕ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದಕ್ಕೂ ಸಾರಿಗೆ ಲೇಯರ್ ಹೆಡರ್ ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.

ನಂತರ ಸಾರಿಗೆ ಪದರವು ವಿಭಾಗವನ್ನು ಕಳುಹಿಸುವವರ ನೆಟ್‌ವರ್ಕ್ ಪದರಕ್ಕೆ ರವಾನಿಸುತ್ತದೆ, ಅಲ್ಲಿ ವಿಭಾಗವನ್ನು ನೆಟ್‌ವರ್ಕ್ ಲೇಯರ್ ಪ್ಯಾಕೆಟ್ (ಡೇಟಾಗ್ರಾಮ್) ನಲ್ಲಿ ಸುತ್ತುವರಿಯಲಾಗುತ್ತದೆ ಮತ್ತು ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಸ್ವೀಕರಿಸುವ ತುದಿಯಲ್ಲಿ, ನೆಟ್‌ವರ್ಕ್ ಪದರವು ಡೇಟಾಗ್ರಾಮ್‌ನಿಂದ ಸಾರಿಗೆ ಪದರದ ವಿಭಾಗವನ್ನು ಹೊರತೆಗೆದು ಅದನ್ನು ಸಾರಿಗೆ ಪದರಕ್ಕೆ ರವಾನಿಸುತ್ತದೆ. ನಂತರ ಸಾರಿಗೆ ಪದರವು ಸ್ವೀಕರಿಸಿದ ವಿಭಾಗವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಇದರಿಂದ ಅದರ ಡೇಟಾ ಸ್ವೀಕರಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಲಭ್ಯವಾಗುತ್ತದೆ.

ಸುರಕ್ಷಿತ ದತ್ತಾಂಶ ಪ್ರಸರಣದ ತತ್ವಗಳು

ಸಂಪೂರ್ಣ ಸುರಕ್ಷಿತ ಚಾನಲ್ ಮೂಲಕ ವಿಶ್ವಾಸಾರ್ಹ ಡೇಟಾ ಪ್ರಸರಣ.

ಸರಳವಾದ ಪ್ರಕರಣ: ಕಳುಹಿಸುವ ಭಾಗವು ಮೇಲಿನ ಪದರದಿಂದ ಡೇಟಾವನ್ನು ಸರಳವಾಗಿ ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅದನ್ನು ಒಳಗೊಂಡಿರುವ ಪ್ಯಾಕೆಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಚಾನಲ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ.

ಸರ್ವರ್

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
)

ಪ್ರತಿ ಬಾರಿ ಪ್ಯಾಕೆಟ್ ರವಾನೆಯಾದಾಗ (ಮೊದಲ ಬಾರಿ ಮತ್ತು ಎರಡನೇ ಬಾರಿ) ಟ್ರಾನ್ಸ್‌ಮಿಟಿಂಗ್ ಸೈಡ್ ಟೈಮರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು, ಟೈಮರ್‌ನಿಂದ ಅಡಚಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕು ಮತ್ತು ಅದನ್ನು ನಿಲ್ಲಿಸಬೇಕು.

ಆದ್ದರಿಂದ, ವಿಶ್ವಾಸಾರ್ಹ ದತ್ತಾಂಶ ಪ್ರಸರಣ ಪ್ರೋಟೋಕಾಲ್‌ಗಳ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳೊಂದಿಗೆ ನಾವು ಪರಿಚಿತರಾಗಿದ್ದೇವೆ:

• ಚೆಕ್ಸಮ್‌ಗಳು;
• ಪ್ಯಾಕೇಜುಗಳ ಸರಣಿ ಸಂಖ್ಯೆಗಳು;
• ಟೈಮರ್‌ಗಳು;
• ಧನಾತ್ಮಕ ಮತ್ತು ಋಣಾತ್ಮಕ ಸ್ವೀಕೃತಿಗಳು.

ಆದರೆ ಅಷ್ಟೆ ಅಲ್ಲ!

ಪೈಪ್‌ಲೈನಿಂಗ್‌ನೊಂದಿಗೆ ವಿಶ್ವಾಸಾರ್ಹ ಡೇಟಾ ವರ್ಗಾವಣೆ ಪ್ರೋಟೋಕಾಲ್

ನಾವು ಈಗಾಗಲೇ ಪರಿಗಣಿಸಿರುವ ರೂಪಾಂತರದಲ್ಲಿ, ವಿಶ್ವಾಸಾರ್ಹ ವಿತರಣಾ ಪ್ರೋಟೋಕಾಲ್ ತುಂಬಾ ಅಸಮರ್ಥವಾಗಿದೆ. ಆರ್‌ಟಿಟಿ ಹೆಚ್ಚಾದಾಗ ಸಂವಹನ ಚಾನಲ್ ಒದಗಿಸಿದ ಪ್ರಸರಣವನ್ನು ಅದು "ನಿಧಾನಗೊಳಿಸಲು" ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಅದರ ದಕ್ಷತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಮತ್ತು ಸಂವಹನ ಚಾನಲ್‌ನ ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಅನ್ನು ಉತ್ತಮವಾಗಿ ಬಳಸಿಕೊಳ್ಳಲು, ಪೈಪ್‌ಲೈನಿಂಗ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಪೈಪ್‌ಲೈನಿಂಗ್ ಬಳಕೆಯು ಈ ಕೆಳಗಿನ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ:

• ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೆಚ್ಚಿಸುವುದು, ಏಕೆಂದರೆ ಎಲ್ಲಾ ಕಳುಹಿಸಿದ ಪ್ಯಾಕೆಟ್‌ಗಳು (ಮರು ಪ್ರಸರಣಗಳನ್ನು ಹೊರತುಪಡಿಸಿ) ಅನನ್ಯವಾಗಿ ಗುರುತಿಸಬಹುದಾದಂತಿರಬೇಕು;
• ಪ್ರಸರಣ ಮತ್ತು ಸ್ವೀಕರಿಸುವ ಬದಿಗಳಲ್ಲಿ ಬಫರ್‌ಗಳನ್ನು ಹೆಚ್ಚಿಸುವ ಅಗತ್ಯತೆ.

ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗಳ ವ್ಯಾಪ್ತಿ ಮತ್ತು ಬಫರ್ ಗಾತ್ರಗಳ ಅವಶ್ಯಕತೆಗಳು ಪ್ಯಾಕೆಟ್ ಭ್ರಷ್ಟಾಚಾರ, ನಷ್ಟ ಮತ್ತು ವಿಳಂಬಕ್ಕೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ ಪ್ರೋಟೋಕಾಲ್ ತೆಗೆದುಕೊಳ್ಳುವ ಕ್ರಮಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಪೈಪ್‌ಲೈನಿಂಗ್ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡು ದೋಷ ತಿದ್ದುಪಡಿ ವಿಧಾನಗಳಿವೆ:

• 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)
    }
}

ತೀರ್ಮಾನಕ್ಕೆ

ವಿಶ್ವಾಸಾರ್ಹ ದತ್ತಾಂಶ ಪ್ರಸರಣ ಮತ್ತು ಬಳಕೆಯನ್ನು ಖಚಿತಪಡಿಸುವ ಕಾರ್ಯವಿಧಾನಗಳು

ಕಾರ್ಯವಿಧಾನ
ಅರ್ಜಿ, ಕಾಮೆಂಟ್

ಮೊತ್ತವನ್ನು ಪರಿಶೀಲಿಸಿ
ರವಾನೆಯಾದ ಪ್ಯಾಕೆಟ್‌ನಲ್ಲಿ ಬಿಟ್ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಟೈಮರ್
ಸಮಯ ಮೀರಿದ ಮಧ್ಯಂತರವನ್ನು ಎಣಿಸುವುದು ಮತ್ತು ಅದರ ಮುಕ್ತಾಯವನ್ನು ಸೂಚಿಸುವುದು. ಎರಡನೆಯದು ಎಂದರೆ ಹೆಚ್ಚಿನ ಮಟ್ಟದ ಸಂಭವನೀಯತೆಯೊಂದಿಗೆ ಪ್ಯಾಕೆಟ್ ಅಥವಾ ಅದರ ರಶೀದಿ ಪ್ರಸರಣದ ಸಮಯದಲ್ಲಿ ಕಳೆದುಹೋಗಿದೆ. ಪ್ಯಾಕೆಟ್ ಅನ್ನು ವಿಳಂಬದೊಂದಿಗೆ ತಲುಪಿಸಿದರೆ, ಆದರೆ ಕಳೆದುಹೋಗದಿದ್ದರೆ (ಸಮಯ ಮೀರಿದ ಮಧ್ಯಂತರದ ಅಕಾಲಿಕ ಮುಕ್ತಾಯ), ಅಥವಾ ರಶೀದಿ ಕಳೆದುಹೋದರೆ, ಮರು ಪ್ರಸರಣವು ಸ್ವೀಕರಿಸುವ ಬದಿಯಲ್ಲಿ ಪ್ಯಾಕೆಟ್‌ನ ನಕಲುಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಕ್ರಮ ಸಂಖ್ಯೆ
ಕಳುಹಿಸುವವರಿಂದ ಸ್ವೀಕರಿಸುವವರಿಗೆ ರವಾನಿಸಲಾದ ಡೇಟಾ ಪ್ಯಾಕೆಟ್‌ಗಳನ್ನು ಅನುಕ್ರಮ ಸಂಖ್ಯೆ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. ಸ್ವೀಕರಿಸಿದ ಪ್ಯಾಕೆಟ್‌ಗಳ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗಳಲ್ಲಿನ ಅಂತರವು ಸ್ವೀಕರಿಸುವವರಿಗೆ ಪ್ಯಾಕೆಟ್ ನಷ್ಟವನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಪ್ಯಾಕೆಟ್‌ಗಳ ಒಂದೇ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗಳು ಪ್ಯಾಕೆಟ್‌ಗಳು ಪರಸ್ಪರ ನಕಲುಗಳಾಗಿವೆ ಎಂದರ್ಥ.

ದೃಢೀಕರಣ
ಸ್ವೀಕರಿಸುವ ಪಕ್ಷದಿಂದ ರಚಿಸಲ್ಪಟ್ಟಿದೆ ಮತ್ತು ಅನುಗುಣವಾದ ಪ್ಯಾಕೆಟ್ ಅಥವಾ ಪ್ಯಾಕೆಟ್‌ಗಳ ಗುಂಪನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸ್ವೀಕರಿಸಲಾಗಿದೆ ಎಂದು ರವಾನಿಸುವ ಪಕ್ಷಕ್ಕೆ ಸೂಚಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಸ್ವೀಕೃತಿಯು ಯಶಸ್ವಿಯಾಗಿ ಸ್ವೀಕರಿಸಿದ ಪ್ಯಾಕೆಟ್‌ಗಳ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಅವಲಂಬಿಸಿ, ವೈಯಕ್ತಿಕ ಮತ್ತು ಗುಂಪು ಸ್ವೀಕೃತಿಗಳ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.

ನಕಾರಾತ್ಮಕ ದೃಢೀಕರಣ
ಪ್ಯಾಕೆಟ್ ಸರಿಯಾಗಿ ಸ್ವೀಕರಿಸಲ್ಪಟ್ಟಿಲ್ಲ ಎಂದು ಕಳುಹಿಸುವವರಿಗೆ ತಿಳಿಸಲು ಸ್ವೀಕರಿಸುವವರು ಬಳಸುತ್ತಾರೆ. ನಕಾರಾತ್ಮಕ ಸ್ವೀಕೃತಿಯು ಸಾಮಾನ್ಯವಾಗಿ ಸರಿಯಾಗಿ ಸ್ವೀಕರಿಸದ ಪ್ಯಾಕೆಟ್‌ನ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಕಿಟಕಿ, ಪೈಪ್‌ಲೈನ್
ಪ್ಯಾಕೆಟ್‌ಗಳನ್ನು ರವಾನಿಸಲು ಬಳಸಬಹುದಾದ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ಮಿತಿಗೊಳಿಸಿ. ಮಲ್ಟಿಕಾಸ್ಟ್ ಮತ್ತು ಹ್ಯಾಂಡ್‌ಶೇಕ್ ಪ್ರೋಟೋಕಾಲ್‌ಗಳು ACK-ವೇಟಿಂಗ್ ಮೋಡ್‌ಗೆ ಹೋಲಿಸಿದರೆ ಥ್ರೋಪುಟ್ ಅನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚಿಸಬಹುದು. ನಾವು ನೋಡಲಿರುವಂತೆ, ಸ್ವೀಕರಿಸುವ ತುದಿಯ ಸ್ವೀಕರಿಸುವ ಮತ್ತು ಬಫರಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳು ಹಾಗೂ ನೆಟ್‌ವರ್ಕ್ ಲೋಡ್ ಅನ್ನು ಆಧರಿಸಿ ವಿಂಡೋ ಗಾತ್ರವನ್ನು ಲೆಕ್ಕಹಾಕಬಹುದು.

ಇನ್ನಷ್ಟು ಗೋ ನೆಟ್‌ವರ್ಕಿಂಗ್ ಉದಾಹರಣೆಗಳು

В ಭಂಡಾರಗಳು.

ಮೂಲ: www.habr.com