വിശ്വസനീയമായ ഡാറ്റ കൈമാറ്റത്തിന്റെ അടിസ്ഥാനങ്ങൾ

ഉള്ളവരോട് അന്വേഷിക്കുന്നു നെറ്റ്‌വർക്കുകളും പ്രോട്ടോക്കോളുകളും മനസ്സിലാക്കാൻ സമർപ്പിച്ചിരിക്കുന്നു.

ചുരുക്കത്തിൽ

വിശ്വസനീയമായ ഡാറ്റാ ട്രാൻസ്മിഷൻ്റെ അടിസ്ഥാനകാര്യങ്ങൾ ലേഖനം ചർച്ചചെയ്യുന്നു, ഉദാഹരണങ്ങൾ നടപ്പിലാക്കുന്നു 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) പ്രോട്ടോക്കോളുകൾ എന്ന് വിളിക്കുന്നു.
കൂടാതെ, അവസാന പാക്കറ്റിൻ്റെ കൈമാറ്റത്തിൻ്റെ ഫലങ്ങളെക്കുറിച്ച് സ്വീകരിക്കുന്ന പാർട്ടിക്ക് ഒരു വിവരവും ലഭിക്കാത്തപ്പോൾ, രസീതുകളിലെ പിശകുകളുടെ സാധ്യത പരിഗണിക്കുന്നത് മൂല്യവത്താണ്.
ഈ പ്രശ്നത്തിനുള്ള പരിഹാരം, ടിസിപിയിലും ഉപയോഗിക്കുന്നു, പാക്കറ്റിൻ്റെ സീക്വൻസ് നമ്പർ അടങ്ങിയ ഡാറ്റ പാക്കറ്റിലേക്ക് ഒരു പുതിയ ഫീൽഡ് ചേർക്കുക എന്നതാണ്.

പാക്കറ്റ് വളച്ചൊടിക്കലിനും നഷ്ടത്തിനും വിധേയമായ ഒരു വിശ്വസനീയമല്ലാത്ത ചാനലിലൂടെ വിശ്വസനീയമായ ഡാറ്റാ ട്രാൻസ്മിഷൻ

വികലതയ്‌ക്കൊപ്പം, നിർഭാഗ്യവശാൽ, നെറ്റ്‌വർക്കിൽ പാക്കറ്റ് നഷ്‌ടമുണ്ട്.
ഈ പ്രശ്നം പരിഹരിക്കുന്നതിന്, മെക്കാനിസങ്ങൾ ആവശ്യമാണ്:

• പാക്കറ്റ് നഷ്ടത്തിൻ്റെ വസ്തുത നിർണ്ണയിക്കുന്നു;
• നഷ്ടപ്പെട്ട പാക്കറ്റുകൾ സ്വീകരിക്കുന്ന കക്ഷിക്ക് വീണ്ടും വിതരണം ചെയ്യുക.

കൂടാതെ, പാക്കേജിൻ്റെ നഷ്ടത്തിന് പുറമേ, രസീത് നഷ്ടപ്പെടാനുള്ള സാധ്യതയോ അല്ലെങ്കിൽ ഒന്നും നഷ്ടപ്പെട്ടില്ലെങ്കിൽ, കാര്യമായ കാലതാമസത്തോടെ ഡെലിവറി ചെയ്യേണ്ടതോ ആവശ്യമാണ്. എല്ലാ സാഹചര്യങ്ങളിലും, ഒരേ കാര്യം ചെയ്യുന്നു: പാക്കറ്റ് വീണ്ടും കൈമാറ്റം ചെയ്യപ്പെടുന്നു. സമയം നിയന്ത്രിക്കുന്നതിന്, ഈ സംവിധാനം ഒരു കൗണ്ട്ഡൗൺ ടൈമർ ഉപയോഗിക്കുന്നു, ഇത് കാത്തിരിപ്പ് ഇടവേളയുടെ അവസാനം നിർണ്ണയിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. അങ്ങനെ പാക്കേജിൽ വല 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)
    }
}

തീരുമാനം

വിശ്വസനീയമായ ഡാറ്റ കൈമാറ്റവും ഉപയോഗവും ഉറപ്പാക്കുന്നതിനുള്ള സംവിധാനങ്ങൾ

യന്ത്രം
അപേക്ഷ, അഭിപ്രായം

തുക പരിശോധിക്കുക
ട്രാൻസ്മിറ്റ് ചെയ്ത പാക്കറ്റിൽ ബിറ്റ് പിശകുകൾ കണ്ടെത്താൻ ഉപയോഗിക്കുന്നു

ടൈമർ
കാലഹരണപ്പെട്ട ഇടവേള കണക്കാക്കുകയും അത് എപ്പോൾ കാലഹരണപ്പെട്ടുവെന്ന് സൂചിപ്പിക്കുകയും ചെയ്യുന്നു. രണ്ടാമത്തേത് അർത്ഥമാക്കുന്നത് ഉയർന്ന തോതിലുള്ള സംഭാവ്യതയോടെ പാക്കറ്റ് അല്ലെങ്കിൽ അതിൻ്റെ രസീത് ട്രാൻസ്മിഷൻ സമയത്ത് നഷ്ടപ്പെടും എന്നാണ്. ഒരു പാക്കറ്റ് കാലതാമസത്തോടെ ഡെലിവറി ചെയ്യപ്പെടുകയാണെങ്കിൽ, അത് നഷ്‌ടമായില്ലെങ്കിൽ (കാലഹരണപ്പെട്ട ഇടവേളയുടെ അകാല കാലഹരണപ്പെടൽ), അല്ലെങ്കിൽ ഒരു രസീത് നഷ്‌ടപ്പെടുകയാണെങ്കിൽ, റീട്രാൻസ്മിഷൻ സ്വീകരിക്കുന്ന ഭാഗത്ത് ഒരു ഡ്യൂപ്ലിക്കേറ്റ് പാക്കറ്റിലേക്ക് നയിക്കുന്നു

സീരിയൽ നമ്പർ
അയച്ചയാളിൽ നിന്ന് സ്വീകർത്താവിലേക്ക് കൈമാറുന്ന ഡാറ്റാ പാക്കറ്റുകളുടെ തുടർച്ചയായ നമ്പറിംഗിനായി ഉപയോഗിക്കുന്നു. ലഭിച്ച പാക്കറ്റുകളുടെ സീക്വൻസ് നമ്പറുകളിലെ വിടവുകൾ പാക്കറ്റ് നഷ്ടം കണ്ടെത്താൻ റിസീവറിനെ അനുവദിക്കുന്നു. ഒരേ പാക്കറ്റ് സീക്വൻസ് നമ്പറുകൾ അർത്ഥമാക്കുന്നത് പാക്കറ്റുകൾ പരസ്പരം ഡ്യൂപ്ലിക്കേറ്റുകളാണെന്നാണ്

സ്ഥിരീകരണം
സ്വീകരിക്കുന്ന അവസാനം സൃഷ്ടിച്ചത്, അനുബന്ധ പാക്കറ്റ് അല്ലെങ്കിൽ പാക്കറ്റുകളുടെ ഗ്രൂപ്പ് വിജയകരമായി ലഭിച്ചുവെന്ന് അയയ്ക്കുന്ന അവസാനത്തിലേക്ക് സൂചിപ്പിക്കുന്നു. സാധാരണയായി അക്‌നോളജ്‌മെൻ്റിൽ വിജയകരമായി ലഭിച്ച പാക്കറ്റുകളുടെ സീക്വൻസ് നമ്പറുകൾ അടങ്ങിയിരിക്കുന്നു. പ്രോട്ടോക്കോൾ അനുസരിച്ച്, വ്യക്തിഗത, ഗ്രൂപ്പ് സ്ഥിരീകരണങ്ങൾ വേർതിരിച്ചിരിക്കുന്നു

നെഗറ്റീവ് സ്ഥിരീകരണം
പാക്കറ്റ് തെറ്റായി ലഭിച്ചതായി അയച്ചയാളെ അറിയിക്കാൻ സ്വീകർത്താവ് ഉപയോഗിക്കുന്നു. ഒരു നെഗറ്റീവ് അക്‌നോളജ്‌മെൻ്റിൽ സാധാരണയായി ശരിയായി ലഭിക്കാത്ത പാക്കറ്റിൻ്റെ സീക്വൻസ് നമ്പർ ഉൾപ്പെടുന്നു

വിൻഡോ, കൺവെയറൈസേഷൻ
പാക്കറ്റുകൾ കൈമാറാൻ ഉപയോഗിക്കാവുന്ന സീക്വൻസ് നമ്പറുകളുടെ പരിധി പരിമിതപ്പെടുത്തുക. അംഗീകാരങ്ങൾക്കായി കാത്തിരിക്കുന്നതിനെ അപേക്ഷിച്ച് മൾട്ടികാസ്റ്റിനും ഹാൻഡ്‌ഷേക്കിനും പ്രോട്ടോക്കോൾ ത്രൂപുട്ട് ഗണ്യമായി വർദ്ധിപ്പിക്കാൻ കഴിയും. നമ്മൾ കാണുന്നതുപോലെ, സ്വീകരിക്കുന്ന അവസാനത്തിൻ്റെ റിസപ്ഷനും ബഫറിംഗ് കഴിവുകളും നെറ്റ്‌വർക്ക് ലോഡ് ലെവലും അടിസ്ഥാനമാക്കി വിൻഡോ വലുപ്പം കണക്കാക്കാം.

നെറ്റ്‌വർക്കിംഗിനായി Go ഉപയോഗിക്കുന്നതിൻ്റെ കൂടുതൽ ഉദാഹരണങ്ങൾ

В ശേഖരങ്ങൾ.

അവലംബം: www.habr.com