ఈ కథనంలో, మేము I/O రియాక్టర్ యొక్క ఇన్లు మరియు అవుట్లను మరియు అది ఎలా పని చేస్తుందో పరిశీలిస్తాము, 200 లైన్ల కంటే తక్కువ కోడ్లో అమలును వ్రాసి, 40 మిలియన్ అభ్యర్థనలు/నిమిషానికి సాధారణ HTTP సర్వర్ ప్రక్రియను చేస్తాము.
ముందుమాట
I/O రియాక్టర్ యొక్క పనితీరును అర్థం చేసుకోవడంలో సహాయపడటానికి వ్యాసం వ్రాయబడింది మరియు దానిని ఉపయోగించినప్పుడు వచ్చే నష్టాలను అర్థం చేసుకోవచ్చు.
వ్యాసాన్ని అర్థం చేసుకోవడానికి ప్రాథమిక విషయాలపై అవగాహన అవసరం. సి భాష మరియు నెట్వర్క్ అప్లికేషన్ డెవలప్మెంట్లో కొంత అనుభవం.
అన్ని కోడ్ ఖచ్చితంగా C భాషలో వ్రాయబడింది (జాగ్రత్త: దీర్ఘ PDF) C11 ప్రమాణానికి Linux కోసం మరియు అందుబాటులో ఉంది గ్యాలరీలు.
ఇది ఎందుకు అవసరం?
ఇంటర్నెట్ యొక్క పెరుగుతున్న జనాదరణతో, వెబ్ సర్వర్లు పెద్ద సంఖ్యలో కనెక్షన్లను ఏకకాలంలో నిర్వహించాల్సిన అవసరం ఏర్పడింది మరియు అందువల్ల రెండు విధానాలు ప్రయత్నించబడ్డాయి: పెద్ద సంఖ్యలో OS థ్రెడ్లలో I/Oని నిరోధించడం మరియు I/Oని నిరోధించకపోవడం ఈవెంట్ నోటిఫికేషన్ సిస్టమ్, దీనిని “సిస్టమ్ సెలెక్టర్” అని కూడా పిలుస్తారు (ఈపోల్/kqueue/IOCP/ etc).
ప్రతి ఇన్కమింగ్ కనెక్షన్ కోసం కొత్త OS థ్రెడ్ను సృష్టించడం మొదటి విధానం. దీని ప్రతికూలత పేలవమైన స్కేలబిలిటీ: ఆపరేటింగ్ సిస్టమ్ చాలా అమలు చేయవలసి ఉంటుంది సందర్భ పరివర్తనలు и సిస్టమ్ కాల్స్. అవి ఖరీదైన కార్యకలాపాలు మరియు ఆకట్టుకునే కనెక్షన్లతో ఉచిత RAM లేకపోవడానికి దారితీయవచ్చు.
సవరించిన సంస్కరణ ముఖ్యాంశాలు థ్రెడ్ల స్థిర సంఖ్య (థ్రెడ్ పూల్), తద్వారా సిస్టమ్ అమలును నిలిపివేయకుండా నిరోధిస్తుంది, కానీ అదే సమయంలో కొత్త సమస్యను పరిచయం చేస్తోంది: థ్రెడ్ పూల్ ప్రస్తుతం సుదీర్ఘ రీడ్ ఆపరేషన్ల ద్వారా బ్లాక్ చేయబడితే, ఇప్పటికే డేటాను స్వీకరించగలిగే ఇతర సాకెట్లు చేయలేవు ఆలా చెయ్యి.
రెండవ విధానం ఉపయోగిస్తుంది ఈవెంట్ నోటిఫికేషన్ సిస్టమ్ (సిస్టమ్ సెలెక్టర్) OS ద్వారా అందించబడింది. ఈ కథనం I/O ఆపరేషన్ల కోసం సంసిద్ధత గురించి హెచ్చరికల (ఈవెంట్లు, నోటిఫికేషన్లు) ఆధారంగా కాకుండా, సిస్టమ్ సెలెక్టర్ యొక్క అత్యంత సాధారణ రకాన్ని చర్చిస్తుంది వాటి పూర్తి గురించి నోటిఫికేషన్లు. దాని ఉపయోగం యొక్క సరళీకృత ఉదాహరణ క్రింది బ్లాక్ రేఖాచిత్రం ద్వారా సూచించబడుతుంది:
ఈ విధానాల మధ్య వ్యత్యాసం క్రింది విధంగా ఉంది:
I/O కార్యకలాపాలను నిరోధించడం సస్పెండ్ వినియోగదారు ప్రవాహం వరకుOS సరిగ్గా ఉండే వరకు defragments ఇన్కమింగ్ IP ప్యాకెట్లు బైట్ స్ట్రీమ్కు (TCP, డేటాను స్వీకరించడం) లేదా దీని ద్వారా తదుపరి పంపడానికి అంతర్గత వ్రాత బఫర్లలో తగినంత స్థలం అందుబాటులో ఉండదు NIC (డేటా పంపడం).
సిస్టమ్ సెలెక్టర్ కాలక్రమేణా OS అని ప్రోగ్రామ్ను తెలియజేస్తుంది ఇప్పటికే defragmented IP ప్యాకెట్లు (TCP, డేటా రిసెప్షన్) లేదా అంతర్గత వ్రాత బఫర్లలో తగినంత స్థలం ఇప్పటికే అందుబాటులో (డేటా పంపడం).
సంగ్రహంగా చెప్పాలంటే, ప్రతి I/O కోసం OS థ్రెడ్ను రిజర్వ్ చేయడం అనేది కంప్యూటింగ్ శక్తిని వృధా చేస్తుంది, ఎందుకంటే వాస్తవానికి, థ్రెడ్లు ఉపయోగకరమైన పనిని చేయడం లేదు (అందుకే ఈ పదం "సాఫ్ట్వేర్ అంతరాయం") సిస్టమ్ సెలెక్టర్ ఈ సమస్యను పరిష్కరిస్తుంది, వినియోగదారు ప్రోగ్రామ్ CPU వనరులను మరింత ఆర్థికంగా ఉపయోగించడానికి అనుమతిస్తుంది.
I/O రియాక్టర్ మోడల్
I/O రియాక్టర్ సిస్టమ్ సెలెక్టర్ మరియు యూజర్ కోడ్ మధ్య పొరగా పనిచేస్తుంది. దాని ఆపరేషన్ సూత్రం క్రింది బ్లాక్ రేఖాచిత్రం ద్వారా వివరించబడింది:
ఈవెంట్ అనేది ఒక నిర్దిష్ట సాకెట్ నాన్-బ్లాకింగ్ I/O ఆపరేషన్ చేయగలదని నోటిఫికేషన్ అని నేను మీకు గుర్తు చేస్తున్నాను.
ఈవెంట్ హ్యాండ్లర్ అనేది ఒక ఈవెంట్ను స్వీకరించినప్పుడు I/O రియాక్టర్ ద్వారా పిలువబడే ఒక ఫంక్షన్, ఇది నాన్-బ్లాకింగ్ I/O ఆపరేషన్ని చేస్తుంది.
I/O రియాక్టర్ నిర్వచనం ప్రకారం సింగిల్-థ్రెడ్ అని గమనించడం ముఖ్యం, అయితే 1 థ్రెడ్: 1 రియాక్టర్ నిష్పత్తిలో బహుళ-థ్రెడ్ వాతావరణంలో కాన్సెప్ట్ను ఉపయోగించకుండా ఆపడం ఏమీ లేదు, తద్వారా అన్ని CPU కోర్లను రీసైక్లింగ్ చేస్తుంది.
అమలు
మేము పబ్లిక్ ఇంటర్ఫేస్ను ఫైల్లో ఉంచుతాము reactor.h, మరియు అమలు - లో reactor.c. reactor.h కింది ప్రకటనలను కలిగి ఉంటుంది:
reactor.hలో డిక్లరేషన్లను చూపించు
typedef struct reactor Reactor;
/*
* Указатель на функцию, которая будет вызываться I/O реактором при поступлении
* события от системного селектора.
*/
typedef void (*Callback)(void *arg, int fd, uint32_t events);
/*
* Возвращает `NULL` в случае ошибки, не-`NULL` указатель на `Reactor` в
* противном случае.
*/
Reactor *reactor_new(void);
/*
* Освобождает системный селектор, все зарегистрированные сокеты в данный момент
* времени и сам I/O реактор.
*
* Следующие функции возвращают -1 в случае ошибки, 0 в случае успеха.
*/
int reactor_destroy(Reactor *reactor);
int reactor_register(const Reactor *reactor, int fd, uint32_t interest,
Callback callback, void *callback_arg);
int reactor_deregister(const Reactor *reactor, int fd);
int reactor_reregister(const Reactor *reactor, int fd, uint32_t interest,
Callback callback, void *callback_arg);
/*
* Запускает цикл событий с тайм-аутом `timeout`.
*
* Эта функция передаст управление вызывающему коду если отведённое время вышло
* или/и при отсутствии зарегистрированных сокетов.
*/
int reactor_run(const Reactor *reactor, time_t timeout);
I/O రియాక్టర్ నిర్మాణం వీటిని కలిగి ఉంటుంది ఫైల్ డిస్క్రిప్టర్ సెలెక్టర్ ఈపోల్ и హాష్ పట్టికలుGHashTable, ఇది ప్రతి సాకెట్ను మ్యాప్ చేస్తుంది CallbackData (ఈవెంట్ హ్యాండ్లర్ యొక్క నిర్మాణం మరియు దాని కోసం వినియోగదారు వాదన).
మేము నిర్వహించగల సామర్థ్యాన్ని ప్రారంభించామని దయచేసి గమనించండి అసంపూర్ణ రకం సూచిక ప్రకారం. IN reactor.h మేము నిర్మాణాన్ని ప్రకటిస్తాము reactor, మరియు లో reactor.c మేము దానిని నిర్వచించాము, తద్వారా వినియోగదారు దాని ఫీల్డ్లను స్పష్టంగా మార్చకుండా నిరోధిస్తాము. ఇది నమూనాలలో ఒకటి డేటాను దాచడం, ఇది క్లుప్తంగా సి సెమాంటిక్స్కి సరిపోతుంది.
విధులు reactor_register, reactor_deregister и reactor_reregister సిస్టమ్ ఎంపిక సాధనం మరియు హాష్ పట్టికలో ఆసక్తి సాకెట్లు మరియు సంబంధిత ఈవెంట్ హ్యాండ్లర్ల జాబితాను నవీకరించండి.
I/O రియాక్టర్ డిస్క్రిప్టర్తో ఈవెంట్ను అడ్డగించిన తర్వాత fd, ఇది సంబంధిత ఈవెంట్ హ్యాండ్లర్ను పిలుస్తుంది, దానికి అది పాస్ అవుతుంది fd, బిట్ ముసుగు సృష్టించిన ఈవెంట్లు మరియు వినియోగదారు పాయింటర్ void.
reactor_run() ఫంక్షన్ని చూపించు
int reactor_run(const Reactor *reactor, time_t timeout) {
int result;
struct epoll_event *events;
if ((events = calloc(MAX_EVENTS, sizeof(*events))) == NULL)
abort();
time_t start = time(NULL);
while (true) {
time_t passed = time(NULL) - start;
int nfds =
epoll_wait(reactor->epoll_fd, events, MAX_EVENTS, timeout - passed);
switch (nfds) {
// Ошибка
case -1:
perror("epoll_wait");
result = -1;
goto cleanup;
// Время вышло
case 0:
result = 0;
goto cleanup;
// Успешная операция
default:
// Вызвать обработчиков событий
for (int i = 0; i < nfds; i++) {
int fd = events[i].data.fd;
CallbackData *callback =
g_hash_table_lookup(reactor->table, &fd);
callback->callback(callback->arg, fd, events[i].events);
}
}
}
cleanup:
free(events);
return result;
}
సంగ్రహంగా చెప్పాలంటే, వినియోగదారు కోడ్లోని ఫంక్షన్ కాల్ల గొలుసు క్రింది రూపాన్ని తీసుకుంటుంది:
ఒకే థ్రెడ్ సర్వర్
అధిక లోడ్లో ఉన్న I/O రియాక్టర్ను పరీక్షించడానికి, మేము చిత్రంతో ఏదైనా అభ్యర్థనకు ప్రతిస్పందించే సాధారణ HTTP వెబ్ సర్వర్ని వ్రాస్తాము.
HTTP ప్రోటోకాల్కు శీఘ్ర సూచన
HTTP - ఇది ప్రోటోకాల్ అప్లికేషన్ స్థాయి, సర్వర్-బ్రౌజర్ పరస్పర చర్య కోసం ప్రధానంగా ఉపయోగించబడుతుంది.
HTTPని సులభంగా ఉపయోగించవచ్చు రవాణా ప్రోటోకాల్ TCP, పేర్కొన్న ఫార్మాట్లో సందేశాలను పంపడం మరియు స్వీకరించడం వివరణ.
CRLF రెండు అక్షరాల క్రమం: r и n, అభ్యర్థన, శీర్షికలు మరియు డేటా యొక్క మొదటి పంక్తిని వేరు చేయడం.
<КОМАНДА> - ఒకటి CONNECT, DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT, TRACE. బ్రౌజర్ మా సర్వర్కు ఆదేశాన్ని పంపుతుంది GET, అంటే "ఫైల్ యొక్క కంటెంట్లను నాకు పంపు."
<URI> - ఏకరీతి వనరు ఐడెంటిఫైయర్. ఉదాహరణకు, URI = అయితే /index.html, ఆపై క్లయింట్ సైట్ యొక్క ప్రధాన పేజీని అభ్యర్థిస్తుంది.
<ВЕРСИЯ HTTP> — ఫార్మాట్లో HTTP ప్రోటోకాల్ వెర్షన్ HTTP/X.Y. నేడు అత్యంత సాధారణంగా ఉపయోగించే వెర్షన్ HTTP/1.1.
<ЗАГОЛОВОК N> ఫార్మాట్లో కీలక-విలువ జత <КЛЮЧ>: <ЗНАЧЕНИЕ>, తదుపరి విశ్లేషణ కోసం సర్వర్కు పంపబడింది.
<ДАННЫЕ> - ఆపరేషన్ చేయడానికి సర్వర్కు అవసరమైన డేటా. తరచుగా ఇది సులభం JSON లేదా ఏదైనా ఇతర ఫార్మాట్.
<КОД СТАТУСА> ఆపరేషన్ ఫలితాన్ని సూచించే సంఖ్య. మా సర్వర్ ఎల్లప్పుడూ స్థితి 200 (విజయవంతమైన ఆపరేషన్) అందిస్తుంది.
<ОПИСАНИЕ СТАТУСА> - స్థితి కోడ్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యం. స్థితి కోడ్ 200 కోసం ఇది OK.
<ЗАГОЛОВОК N> — అభ్యర్థనలో ఉన్న అదే ఫార్మాట్ యొక్క శీర్షిక. మేము శీర్షికలను తిరిగి ఇస్తాము Content-Length (ఫైల్ పరిమాణం) మరియు Content-Type: text/html (రిటర్న్ డేటా రకం).
<ДАННЫЕ> - వినియోగదారు అభ్యర్థించిన డేటా. మా విషయంలో, ఇది ఇమేజ్కి మార్గం HTML.
ఫైలు http_server.c (సింగిల్ థ్రెడ్ సర్వర్) ఫైల్ను కలిగి ఉంటుంది common.h, ఇది క్రింది ఫంక్షన్ ప్రోటోటైప్లను కలిగి ఉంటుంది:
ఫంక్షన్ ప్రోటోటైప్లను common.hలో చూపించు
/*
* Обработчик событий, который вызовется после того, как сокет будет
* готов принять новое соединение.
*/
static void on_accept(void *arg, int fd, uint32_t events);
/*
* Обработчик событий, который вызовется после того, как сокет будет
* готов отправить HTTP ответ.
*/
static void on_send(void *arg, int fd, uint32_t events);
/*
* Обработчик событий, который вызовется после того, как сокет будет
* готов принять часть HTTP запроса.
*/
static void on_recv(void *arg, int fd, uint32_t events);
/*
* Переводит входящее соединение в неблокирующий режим.
*/
static void set_nonblocking(int fd);
/*
* Печатает переданные аргументы в stderr и выходит из процесса с
* кодом `EXIT_FAILURE`.
*/
static noreturn void fail(const char *format, ...);
/*
* Возвращает файловый дескриптор сокета, способного принимать новые
* TCP соединения.
*/
static int new_server(bool reuse_port);
ఫంక్షనల్ మాక్రో కూడా వివరించబడింది SAFE_CALL() మరియు ఫంక్షన్ నిర్వచించబడింది fail(). మాక్రో వ్యక్తీకరణ యొక్క విలువను లోపంతో పోల్చి చూస్తుంది మరియు షరతు నిజమైతే, ఫంక్షన్ని పిలుస్తుంది fail():
#define SAFE_CALL(call, error)
do {
if ((call) == error) {
fail("%s", #call);
}
} while (false)
ఫంక్షన్ fail() టెర్మినల్కు పాస్ చేసిన ఆర్గ్యుమెంట్లను ప్రింట్ చేస్తుంది (వంటి printf()) మరియు కోడ్తో ప్రోగ్రామ్ను ముగిస్తుంది EXIT_FAILURE:
ఫంక్షన్ new_server() సిస్టమ్ కాల్ల ద్వారా సృష్టించబడిన "సర్వర్" సాకెట్ యొక్క ఫైల్ డిస్క్రిప్టర్ను అందిస్తుంది socket(), bind() и listen() మరియు నాన్-బ్లాకింగ్ మోడ్లో ఇన్కమింగ్ కనెక్షన్లను ఆమోదించగల సామర్థ్యం.
సాకెట్ ప్రారంభంలో ఫ్లాగ్ ఉపయోగించి నాన్-బ్లాకింగ్ మోడ్లో సృష్టించబడిందని గమనించండి SOCK_NONBLOCKకాబట్టి ఫంక్షన్ లో on_accept() (మరింత చదవండి) సిస్టమ్ కాల్ accept() థ్రెడ్ అమలును ఆపలేదు.
ఉంటే reuse_port సమానముగా true, అప్పుడు ఈ ఫంక్షన్ ఎంపికతో సాకెట్ను కాన్ఫిగర్ చేస్తుంది SO_REUSEPORT ద్వారా setsockopt()బహుళ-థ్రెడ్ వాతావరణంలో ఒకే పోర్ట్ను ఉపయోగించడానికి (“మల్టీ-థ్రెడ్ సర్వర్” విభాగం చూడండి).
ఈవెంట్ హ్యాండ్లర్ on_accept() OS ఒక ఈవెంట్ను రూపొందించిన తర్వాత కాల్ చేయబడుతుంది EPOLLIN, ఈ సందర్భంలో కొత్త కనెక్షన్ని అంగీకరించవచ్చు. on_accept() కొత్త కనెక్షన్ని అంగీకరిస్తుంది, దానిని నాన్-బ్లాకింగ్ మోడ్కి మారుస్తుంది మరియు ఈవెంట్ హ్యాండ్లర్తో నమోదు చేస్తుంది on_recv() I/O రియాక్టర్లో.
ఈవెంట్ హ్యాండ్లర్ on_recv() OS ఒక ఈవెంట్ను రూపొందించిన తర్వాత కాల్ చేయబడుతుంది EPOLLIN, ఈ సందర్భంలో కనెక్షన్ నమోదు చేయబడిందని అర్థం on_accept(), డేటాను స్వీకరించడానికి సిద్ధంగా ఉంది.
on_recv() HTTP అభ్యర్థన పూర్తిగా స్వీకరించబడే వరకు కనెక్షన్ నుండి డేటాను రీడ్ చేస్తుంది, ఆపై అది హ్యాండ్లర్ను నమోదు చేస్తుంది on_send() HTTP ప్రతిస్పందనను పంపడానికి. క్లయింట్ కనెక్షన్ను విచ్ఛిన్నం చేసినట్లయితే, సాకెట్ నమోదు తీసివేయబడుతుంది మరియు ఉపయోగించి మూసివేయబడుతుంది close().
ఫంక్షన్ on_recv()ని చూపు
static void on_recv(void *arg, int fd, uint32_t events) {
RequestBuffer *buffer = arg;
// Принимаем входные данные до тех пор, что recv возвратит 0 или ошибку
ssize_t nread;
while ((nread = recv(fd, buffer->data + buffer->size,
REQUEST_BUFFER_CAPACITY - buffer->size, 0)) > 0)
buffer->size += nread;
// Клиент оборвал соединение
if (nread == 0) {
SAFE_CALL(reactor_deregister(reactor, fd), -1);
SAFE_CALL(close(fd), -1);
request_buffer_destroy(buffer);
return;
}
// read вернул ошибку, отличную от ошибки, при которой вызов заблокирует
// поток
if (errno != EAGAIN && errno != EWOULDBLOCK) {
request_buffer_destroy(buffer);
fail("read");
}
// Получен полный HTTP запрос от клиента. Теперь регистрируем обработчика
// событий для отправки данных
if (request_buffer_is_complete(buffer)) {
request_buffer_clear(buffer);
SAFE_CALL(reactor_reregister(reactor, fd, EPOLLOUT, on_send, buffer),
-1);
}
}
ఈవెంట్ హ్యాండ్లర్ on_send() OS ఒక ఈవెంట్ను రూపొందించిన తర్వాత కాల్ చేయబడుతుంది EPOLLOUT, కనెక్షన్ రిజిస్టర్ చేయబడిందని అర్థం on_recv(), డేటా పంపడానికి సిద్ధంగా ఉంది. ఈ ఫంక్షన్ క్లయింట్కు ఇమేజ్తో కూడిన HTMLని కలిగి ఉన్న HTTP ప్రతిస్పందనను పంపుతుంది మరియు ఈవెంట్ హ్యాండ్లర్ను తిరిగి మారుస్తుంది on_recv().
చివరకు, ఫైల్లో http_server.c, ఫంక్షన్ లో main() మేము ఉపయోగించి I/O రియాక్టర్ని సృష్టిస్తాము reactor_new(), సర్వర్ సాకెట్ను సృష్టించి, దానిని నమోదు చేయండి, ఉపయోగించి రియాక్టర్ను ప్రారంభించండి reactor_run() సరిగ్గా ఒక నిమిషం పాటు, ఆపై మేము వనరులను విడుదల చేస్తాము మరియు ప్రోగ్రామ్ నుండి నిష్క్రమిస్తాము.
అంతా అనుకున్నట్లు పని చేస్తుందో లేదో తనిఖీ చేద్దాం. కంపైలింగ్ (chmod a+x compile.sh && ./compile.sh ప్రాజెక్ట్ రూట్లో) మరియు స్వీయ-వ్రాత సర్వర్ను ప్రారంభించండి, తెరవండి http://127.0.0.1:18470 బ్రౌజర్లో మరియు మేము ఆశించిన వాటిని చూడండి:
సింగిల్-థ్రెడ్ సర్వర్ పనితీరును కొలుద్దాం. రెండు టెర్మినల్లను తెరుద్దాం: ఒకదానిలో మేము అమలు చేస్తాము ./http_server, వేరే లో - పని. ఒక నిమిషం తర్వాత, కింది గణాంకాలు రెండవ టెర్మినల్లో ప్రదర్శించబడతాయి:
దయచేసి ఫంక్షన్ వాదనను గమనించండి new_server() నిలుస్తుంది true. దీని అర్థం మేము సర్వర్ సాకెట్కు ఎంపికను కేటాయిస్తాము SO_REUSEPORTబహుళ-థ్రెడ్ వాతావరణంలో దీన్ని ఉపయోగించడానికి. మీరు మరిన్ని వివరాలను చదువుకోవచ్చు ఇక్కడ.
1 నిమిషంలో ప్రాసెస్ చేయబడిన అభ్యర్థనల సంఖ్య ~3.28 రెట్లు పెరిగింది! కానీ మేము రౌండ్ నంబర్ కంటే ~XNUMX మిలియన్లు మాత్రమే తక్కువగా ఉన్నాము, కాబట్టి దాన్ని పరిష్కరించడానికి ప్రయత్నిద్దాం.
CPU అనుబంధాన్ని ఉపయోగించడం, తో సంకలనం -march=native, PGO, హిట్ల సంఖ్య పెరుగుదల కాష్, పెంచు MAX_EVENTS మరియు ఉపయోగించండి EPOLLET పనితీరులో గణనీయమైన పెరుగుదలను ఇవ్వలేదు. మీరు ఏకకాల కనెక్షన్ల సంఖ్యను పెంచినట్లయితే ఏమి జరుగుతుంది?
కావలసిన ఫలితం పొందబడింది మరియు దానితో కనెక్షన్ల సంఖ్యపై 1 నిమిషంలో ప్రాసెస్ చేయబడిన అభ్యర్థనల సంఖ్యపై ఆధారపడటాన్ని చూపే ఆసక్తికరమైన గ్రాఫ్:
రెండు వందల కనెక్షన్ల తర్వాత, రెండు సర్వర్ల కోసం ప్రాసెస్ చేయబడిన అభ్యర్థనల సంఖ్య బాగా పడిపోతుందని మేము చూస్తాము (మల్టీ-థ్రెడ్ వెర్షన్లో ఇది మరింత గుర్తించదగినది). ఇది Linux TCP/IP స్టాక్ అమలుకు సంబంధించినదా? గ్రాఫ్ యొక్క ఈ ప్రవర్తన మరియు బహుళ-థ్రెడ్ మరియు సింగిల్-థ్రెడ్ ఎంపికల కోసం ఆప్టిమైజేషన్ల గురించి మీ అంచనాలను వ్యాఖ్యలలో వ్రాయడానికి సంకోచించకండి.
ఎలా గమనించారు వ్యాఖ్యలలో, ఈ పనితీరు పరీక్ష I/O రియాక్టర్ యొక్క ప్రవర్తనను నిజమైన లోడ్లలో చూపదు, ఎందుకంటే సర్వర్ డేటాబేస్తో పరస్పర చర్య చేస్తుంది, లాగ్లను అవుట్పుట్ చేస్తుంది, దీనితో క్రిప్టోగ్రఫీని ఉపయోగిస్తుంది TLS మొదలైనవి, దీని ఫలితంగా లోడ్ ఏకరీతి (డైనమిక్) అవుతుంది. I/O ప్రోయాక్టర్ గురించిన కథనంలో థర్డ్-పార్టీ కాంపోనెంట్లతో పాటు పరీక్షలు నిర్వహించబడతాయి.
I/O రియాక్టర్ యొక్క ప్రతికూలతలు
I/O రియాక్టర్ దాని లోపాలు లేకుండా లేదని మీరు అర్థం చేసుకోవాలి, అవి:
బహుళ-థ్రెడ్ వాతావరణంలో I/O రియాక్టర్ను ఉపయోగించడం కొంత కష్టం, ఎందుకంటే మీరు ప్రవాహాలను మానవీయంగా నిర్వహించవలసి ఉంటుంది.
చాలా సందర్భాలలో లోడ్ ఏకరీతిగా ఉండదని ప్రాక్టీస్ చూపిస్తుంది, ఇది ఒక థ్రెడ్ లాగింగ్కు దారి తీస్తుంది, మరొకటి పనిలో బిజీగా ఉంటుంది.
ఒక ఈవెంట్ హ్యాండ్లర్ థ్రెడ్ను బ్లాక్ చేస్తే, సిస్టమ్ సెలెక్టర్ కూడా బ్లాక్ చేస్తుంది, ఇది కష్టమైన బగ్లకు దారి తీస్తుంది.
ఈ సమస్యలను పరిష్కరిస్తుంది I/O ప్రోయాక్టర్, ఇది తరచుగా థ్రెడ్ల పూల్కు లోడ్ను సమానంగా పంపిణీ చేసే షెడ్యూలర్ను కలిగి ఉంటుంది మరియు మరింత సౌకర్యవంతమైన APIని కూడా కలిగి ఉంటుంది. మేము దాని గురించి తరువాత, నా ఇతర వ్యాసంలో మాట్లాడుతాము.
తీర్మానం
సిద్ధాంతం నుండి నేరుగా ప్రొఫైలర్ ఎగ్జాస్ట్లోకి మా ప్రయాణం ఇక్కడే ముగిసింది.
మీరు దీని గురించి ఆలోచించకూడదు, ఎందుకంటే వివిధ స్థాయిల సౌలభ్యం మరియు వేగంతో నెట్వర్క్ సాఫ్ట్వేర్ను వ్రాయడానికి అనేక ఇతర సమానమైన ఆసక్తికరమైన విధానాలు ఉన్నాయి. ఆసక్తికరమైన, నా అభిప్రాయం ప్రకారం, లింక్లు క్రింద ఇవ్వబడ్డాయి.