សេចក្តីណែនាំ

រ៉េអាក់ទ័រ I/O (ខ្សែតែមួយ រង្វិលជុំព្រឹត្តិការណ៍) គឺជាគំរូសម្រាប់សរសេរកម្មវិធីដែលមានបន្ទុកខ្ពស់ ប្រើក្នុងដំណោះស្រាយពេញនិយមជាច្រើន៖

នៅក្នុងអត្ថបទនេះ យើងនឹងពិនិត្យមើលផ្នែកខាងក្នុង និងខាងក្រៅនៃរ៉េអាក់ទ័រ I/O និងរបៀបដែលវាដំណើរការ សរសេរការអនុវត្តន៍ក្នុងកូដតិចជាង 200 បន្ទាត់ និងបង្កើតដំណើរការម៉ាស៊ីនមេ HTTP សាមញ្ញជាង 40 លានសំណើ/នាទី។

បុព្វកថា

អត្ថបទនេះត្រូវបានសរសេរដើម្បីជួយឱ្យយល់អំពីមុខងាររបស់រ៉េអាក់ទ័រ I/O ហើយដូច្នេះយល់អំពីហានិភ័យនៅពេលប្រើវា។
ចំណេះដឹងអំពីមូលដ្ឋានគឺត្រូវបានទាមទារដើម្បីយល់ពីអត្ថបទ។ ភាសា C និងបទពិសោធន៍ខ្លះៗក្នុងការអភិវឌ្ឍន៍កម្មវិធីបណ្តាញ។
កូដទាំងអស់ត្រូវបានសរសេរជាភាសា C យ៉ាងតឹងរឹងយោងទៅតាម (ប្រយ័ត្ន៖ PDF វែង) ស្តង់ដារ C11 សម្រាប់លីនុច និងមាននៅលើ GitHub.

ហេតុអ្វីចាំបាច់ម៉្លេះ?

ជាមួយនឹងការកើនឡើងនៃប្រជាប្រិយភាពនៃអ៊ិនធឺណិត ម៉ាស៊ីនមេបណ្តាញចាប់ផ្តើមត្រូវការដើម្បីគ្រប់គ្រងការតភ្ជាប់មួយចំនួនធំក្នុងពេលដំណាលគ្នា ដូច្នេះវិធីសាស្រ្តពីរត្រូវបានសាកល្បង៖ ការទប់ស្កាត់ I/O នៅលើ OS មួយចំនួនធំ និងការមិនទប់ស្កាត់ I/O រួមបញ្ចូលគ្នាជាមួយ ប្រព័ន្ធជូនដំណឹងព្រឹត្តិការណ៍ ហៅផងដែរថា "កម្មវិធីជ្រើសរើសប្រព័ន្ធ" (epol/kqueue/IOCP/ ល) ។

វិធីសាស្រ្តដំបូងពាក់ព័ន្ធនឹងការបង្កើតខ្សែស្រឡាយ OS ថ្មីសម្រាប់ការតភ្ជាប់ចូលនីមួយៗ។ គុណវិបត្តិរបស់វាគឺការធ្វើមាត្រដ្ឋានមិនល្អ: ប្រព័ន្ធប្រតិបត្តិការនឹងត្រូវអនុវត្តជាច្រើន។ ការផ្លាស់ប្តូរបរិបទ и ការហៅតាមប្រព័ន្ធ. ពួកវាជាប្រតិបត្តិការថ្លៃ ហើយអាចនាំឱ្យខ្វះ RAM ឥតគិតថ្លៃ ជាមួយនឹងចំនួនការតភ្ជាប់ដ៏គួរឱ្យចាប់អារម្មណ៍។

កំណែដែលបានកែប្រែបានបន្លិច ចំនួនថេរនៃខ្សែស្រឡាយ (thread pool) ដោយហេតុនេះការពារប្រព័ន្ធពីការលុបចោលការប្រតិបត្តិ ប៉ុន្តែនៅពេលជាមួយគ្នានេះ បង្ហាញពីបញ្ហាថ្មីមួយ៖ ប្រសិនបើបណ្តុំខ្សែស្រឡាយបច្ចុប្បន្នត្រូវបានរារាំងដោយប្រតិបត្តិការអានយូរ នោះរន្ធផ្សេងទៀតដែលអាចទទួលទិន្នន័យរួចហើយនឹងមិនអាចដំណើរការបានទេ។ ធ្វើអញ្ចឹង។

វិធីសាស្រ្តទីពីរប្រើ ប្រព័ន្ធជូនដំណឹងព្រឹត្តិការណ៍ (ឧបករណ៍ជ្រើសរើសប្រព័ន្ធ) ដែលផ្តល់ដោយ OS ។ អត្ថបទនេះពិភាក្សាអំពីប្រភេទឧបករណ៍ជ្រើសរើសប្រព័ន្ធទូទៅបំផុត ដោយផ្អែកលើការជូនដំណឹង (ព្រឹត្តិការណ៍ ការជូនដំណឹង) អំពីការត្រៀមខ្លួនសម្រាប់ប្រតិបត្តិការ I/O ជាជាងនៅលើ ការជូនដំណឹងអំពីការបញ្ចប់របស់ពួកគេ។. ឧទាហរណ៍សាមញ្ញនៃការប្រើប្រាស់របស់វាអាចត្រូវបានតំណាងដោយដ្យាក្រាមប្លុកខាងក្រោម៖

ភាពខុសគ្នារវាងវិធីសាស្រ្តទាំងនេះមានដូចខាងក្រោម៖

រារាំងប្រតិបត្តិការ I/O ផ្អាក លំហូរអ្នកប្រើប្រាស់ រហូតដល់រហូតដល់ OS ត្រឹមត្រូវ។ defragments ចូល កញ្ចប់ IP ទៅស្ទ្រីមបៃ (TCPទទួលទិន្នន័យ) ឬវានឹងមិនមានកន្លែងទំនេរគ្រប់គ្រាន់នៅក្នុងសតិបណ្ដោះអាសន្ននៃការសរសេរផ្ទៃក្នុងសម្រាប់ការផ្ញើជាបន្តបន្ទាប់តាមរយៈ NIC (បញ្ជូនទិន្នន័យ) ។
ឧបករណ៍ជ្រើសរើសប្រព័ន្ធ ហួសពេល ជូនដំណឹងដល់កម្មវិធីថា OS រួចទៅហើយ កញ្ចប់ IP ដែលត្រូវបាន defragmented (TCP, ការទទួលទិន្នន័យ) ឬទំហំគ្រប់គ្រាន់នៅក្នុងសតិបណ្ដោះអាសន្នខាងក្នុង រួចទៅហើយ អាចប្រើបាន (បញ្ជូនទិន្នន័យ) ។

សរុបមក ការរក្សាទុកនូវ OS សម្រាប់ I/O នីមួយៗ គឺជាការខ្ជះខ្ជាយថាមពលកុំព្យូទ័រ ពីព្រោះតាមពិត ខ្សែស្រលាយមិនដំណើរការដែលមានប្រយោជន៍ទេ (ហេតុនេះពាក្យ "កម្មវិធីរំខាន") កម្មវិធីជ្រើសរើសប្រព័ន្ធដោះស្រាយបញ្ហានេះ ដែលអនុញ្ញាតឱ្យកម្មវិធីអ្នកប្រើប្រាស់ប្រើប្រាស់ធនធាន CPU កាន់តែសន្សំសំចៃ។

ម៉ូដែលរ៉េអាក់ទ័រ I/O

រ៉េអាក់ទ័រ I/O ដើរតួជាស្រទាប់មួយរវាងឧបករណ៍ជ្រើសរើសប្រព័ន្ធ និងលេខកូដអ្នកប្រើប្រាស់។ គោលការណ៍នៃប្រតិបត្តិការរបស់វាត្រូវបានពិពណ៌នាដោយដ្យាក្រាមប្លុកខាងក្រោម៖

ខ្ញុំសូមរំលឹកអ្នកថាព្រឹត្តិការណ៍មួយគឺជាការជូនដំណឹងដែលរន្ធជាក់លាក់មួយអាចអនុវត្តប្រតិបត្តិការ I/O ដែលមិនរារាំង។
កម្មវិធីដោះស្រាយព្រឹត្តិការណ៍គឺជាមុខងារមួយដែលត្រូវបានហៅដោយរ៉េអាក់ទ័រ I/O នៅពេលដែលព្រឹត្តិការណ៍ត្រូវបានទទួល ដែលបន្ទាប់មកធ្វើប្រតិបត្តិការ I/O ដែលមិនរារាំង។

វាជារឿងសំខាន់ក្នុងការកត់សម្គាល់ថា រ៉េអាក់ទ័រ I/O គឺតាមនិយមន័យ single-threaded ប៉ុន្តែគ្មានអ្វីដែលរារាំងគោលគំនិតនេះពីការប្រើប្រាស់នៅក្នុងបរិយាកាសពហុខ្សែស្រឡាយក្នុងសមាមាត្រនៃ 1 thread: រ៉េអាក់ទ័រ 1 ដោយហេតុនេះអាចកែច្នៃស្នូលស៊ីភីយូទាំងអស់។

Реализация

យើងនឹងដាក់ចំណុចប្រទាក់សាធារណៈនៅក្នុងឯកសារមួយ។ 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 reactor មាន អ្នកពិពណ៌នាឯកសារ អ្នកជ្រើសរើស epol и តារាង hash GHashTableដែលគូសផែនទីរន្ធនីមួយៗទៅ CallbackData (រចនាសម្ព័ន្ធរបស់អ្នកដោះស្រាយព្រឹត្តិការណ៍ និងអាគុយម៉ង់អ្នកប្រើប្រាស់សម្រាប់វា)។

បង្ហាញ Reactor និង CallbackData

struct reactor {
    int epoll_fd;
    GHashTable *table; // (int, CallbackData)
};

typedef struct {
    Callback callback;
    void *arg;
} CallbackData;

សូមចំណាំថាយើងបានបើកសមត្ថភាពក្នុងការដោះស្រាយ ប្រភេទមិនពេញលេញ នេះបើយោងតាមសន្ទស្សន៍។ IN reactor.h យើងប្រកាសរចនាសម្ព័ន្ធ reactorនិងក្នុង។ reactor.c យើងកំណត់វា ដោយហេតុនេះការពារអ្នកប្រើប្រាស់ពីការផ្លាស់ប្តូរវាលរបស់វា។ នេះគឺជាគំរូមួយក្នុងចំណោមគំរូ លាក់ទិន្នន័យដែលសមយ៉ាងខ្លីទៅក្នុង C semantics ។

អនុគមន៍ reactor_register, reactor_deregister и reactor_reregister ធ្វើបច្ចុប្បន្នភាពបញ្ជីរន្ធដែលចាប់អារម្មណ៍ និងអ្នកដោះស្រាយព្រឹត្តិការណ៍ដែលត្រូវគ្នានៅក្នុងកម្មវិធីជ្រើសរើសប្រព័ន្ធ និងតារាងសញ្ញា។

បង្ហាញមុខងារចុះឈ្មោះ

#define REACTOR_CTL(reactor, op, fd, interest)                                 
    if (epoll_ctl(reactor->epoll_fd, op, fd,                                   
                  &(struct epoll_event){.events = interest,                    
                                        .data = {.fd = fd}}) == -1) {          
        perror("epoll_ctl");                                                   
        return -1;                                                             
    }

int reactor_register(const Reactor *reactor, int fd, uint32_t interest,
                     Callback callback, void *callback_arg) {
    REACTOR_CTL(reactor, EPOLL_CTL_ADD, fd, interest)
    g_hash_table_insert(reactor->table, int_in_heap(fd),
                        callback_data_new(callback, callback_arg));
    return 0;
}

int reactor_deregister(const Reactor *reactor, int fd) {
    REACTOR_CTL(reactor, EPOLL_CTL_DEL, fd, 0)
    g_hash_table_remove(reactor->table, &fd);
    return 0;
}

int reactor_reregister(const Reactor *reactor, int fd, uint32_t interest,
                       Callback callback, void *callback_arg) {
    REACTOR_CTL(reactor, EPOLL_CTL_MOD, fd, interest)
    g_hash_table_insert(reactor->table, int_in_heap(fd),
                        callback_data_new(callback, callback_arg));
    return 0;
}

បន្ទាប់ពីរ៉េអាក់ទ័រ 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ផ្ញើ និងទទួលសារក្នុងទម្រង់ដែលបានបញ្ជាក់ ការបញ្ជាក់.

ទម្រង់ស្នើសុំ

<КОМАНДА> <URI> <ВЕРСИЯ HTTP>CRLF
<ЗАГОЛОВОК 1>CRLF
<ЗАГОЛОВОК 2>CRLF
<ЗАГОЛОВОК N>CRLF CRLF
<ДАННЫЕ>

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 ឬទម្រង់ផ្សេងទៀត។

ទម្រង់ឆ្លើយតប

<ВЕРСИЯ HTTP> <КОД СТАТУСА> <ОПИСАНИЕ СТАТУСА>CRLF
<ЗАГОЛОВОК 1>CRLF
<ЗАГОЛОВОК 2>CRLF
<ЗАГОЛОВОК N>CRLF CRLF
<ДАННЫЕ>

<КОД СТАТУСА> គឺជាលេខដែលតំណាងឱ្យលទ្ធផលនៃប្រតិបត្តិការ។ ម៉ាស៊ីនមេរបស់យើងនឹងត្រឡប់ស្ថានភាព 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:

static noreturn void fail(const char *format, ...) {
    va_list args;
    va_start(args, format);
    vfprintf(stderr, format, args);
    va_end(args);
    fprintf(stderr, ": %sn", strerror(errno));
    exit(EXIT_FAILURE);
}

មុខងារ new_server() ត្រឡប់ឯកសារពិពណ៌នានៃរន្ធ "ម៉ាស៊ីនមេ" ដែលបង្កើតឡើងដោយការហៅតាមប្រព័ន្ធ socket(), bind() и listen() និងមានសមត្ថភាពទទួលយកការតភ្ជាប់ចូលក្នុងទម្រង់មិនបិទ។

បង្ហាញមុខងារ new_server()

static int new_server(bool reuse_port) {
    int fd;
    SAFE_CALL((fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP)),
              -1);

    if (reuse_port) {
        SAFE_CALL(
            setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &(int){1}, sizeof(int)),
            -1);
    }

    struct sockaddr_in addr = {.sin_family = AF_INET,
                               .sin_port = htons(SERVER_PORT),
                               .sin_addr = {.s_addr = inet_addr(SERVER_IPV4)},
                               .sin_zero = {0}};

    SAFE_CALL(bind(fd, (struct sockaddr *)&addr, sizeof(addr)), -1);
    SAFE_CALL(listen(fd, SERVER_BACKLOG), -1);
    return fd;
}

ចំណាំថារន្ធត្រូវបានបង្កើតដំបូងក្នុងរបៀបមិនទប់ស្កាត់ដោយប្រើទង់ SOCK_NONBLOCKដូច្នេះនៅក្នុងមុខងារ on_accept() (អានបន្ថែម) ការហៅតាមប្រព័ន្ធ accept() មិនបានបញ្ឈប់ការប្រតិបត្តិខ្សែស្រឡាយទេ។
ប្រសិនបើមាន reuse_port ស្មើ trueបន្ទាប់មកមុខងារនេះនឹងកំណត់រចនាសម្ព័ន្ធរន្ធជាមួយនឹងជម្រើស SO_REUSEPORT ឆ្លងកាត់។ setsockopt()ដើម្បីប្រើច្រកដូចគ្នានៅក្នុងបរិយាកាសពហុខ្សែ (សូមមើលផ្នែក "ម៉ាស៊ីនមេពហុខ្សែ") ។

កម្មវិធីគ្រប់គ្រងព្រឹត្តិការណ៍ on_accept() ហៅបន្ទាប់ពី OS បង្កើតព្រឹត្តិការណ៍មួយ។ EPOLLINក្នុងករណីនេះមានន័យថាការតភ្ជាប់ថ្មីអាចទទួលយកបាន។ on_accept() ទទួលយកការតភ្ជាប់ថ្មី ប្ដូរវាទៅរបៀបមិនទប់ស្កាត់ ហើយចុះឈ្មោះជាមួយកម្មវិធីដោះស្រាយព្រឹត្តិការណ៍ on_recv() នៅក្នុងរ៉េអាក់ទ័រ I/O ។

បង្ហាញមុខងារ on_accept()

static void on_accept(void *arg, int fd, uint32_t events) {
    int incoming_conn;
    SAFE_CALL((incoming_conn = accept(fd, NULL, NULL)), -1);
    set_nonblocking(incoming_conn);
    SAFE_CALL(reactor_register(reactor, incoming_conn, EPOLLIN, on_recv,
                               request_buffer_new()),
              -1);
}

កម្មវិធីគ្រប់គ្រងព្រឹត្តិការណ៍ 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()រួចរាល់ក្នុងការផ្ញើទិន្នន័យ។ មុខងារនេះផ្ញើការឆ្លើយតប HTTP ដែលមានរូបភាព HTML ទៅកាន់ម៉ាស៊ីនភ្ញៀវ ហើយបន្ទាប់មកផ្លាស់ប្តូរកម្មវិធីដោះស្រាយព្រឹត្តិការណ៍ត្រឡប់ទៅវិញ។ on_recv().

បង្ហាញមុខងារ on_send()

static void on_send(void *arg, int fd, uint32_t events) {
    const char *content = "<img "
                          "src="https://habrastorage.org/webt/oh/wl/23/"
                          "ohwl23va3b-dioerobq_mbx4xaw.jpeg">";
    char response[1024];
    sprintf(response,
            "HTTP/1.1 200 OK" CRLF "Content-Length: %zd" CRLF "Content-Type: "
            "text/html" DOUBLE_CRLF "%s",
            strlen(content), content);

    SAFE_CALL(send(fd, response, strlen(response), 0), -1);
    SAFE_CALL(reactor_reregister(reactor, fd, EPOLLIN, on_recv, arg), -1);
}

ហើយចុងក្រោយនៅក្នុងឯកសារ http_server.c, នៅក្នុងមុខងារ main() យើងបង្កើតរ៉េអាក់ទ័រ I/O ដោយប្រើ reactor_new()បង្កើតរន្ធម៉ាស៊ីនមេ ហើយចុះឈ្មោះវា ចាប់ផ្តើមរ៉េអាក់ទ័រដោយប្រើ reactor_run() សម្រាប់មួយនាទីពិតប្រាកដ ហើយបន្ទាប់មកយើងបញ្ចេញធនធាន និងចេញពីកម្មវិធី។

បង្ហាញ http_server.c

#include "reactor.h"

static Reactor *reactor;

#include "common.h"

int main(void) {
    SAFE_CALL((reactor = reactor_new()), NULL);
    SAFE_CALL(
        reactor_register(reactor, new_server(false), EPOLLIN, on_accept, NULL),
        -1);
    SAFE_CALL(reactor_run(reactor, SERVER_TIMEOUT_MILLIS), -1);
    SAFE_CALL(reactor_destroy(reactor), -1);
}

សូមពិនិត្យមើលថាអ្វីៗដំណើរការដូចការរំពឹងទុក។ ការចងក្រង (chmod a+x compile.sh && ./compile.sh នៅក្នុងគម្រោង root) ហើយបើកដំណើរការម៉ាស៊ីនមេដែលសរសេរដោយខ្លួនឯងបើក http://127.0.0.1:18470 នៅក្នុង browser ហើយមើលអ្វីដែលយើងរំពឹងទុក៖

ការវាស់វែងការអនុវត្ត

បង្ហាញលក្ខណៈបច្ចេកទេសរថយន្តរបស់ខ្ញុំ

$ screenfetch
 MMMMMMMMMMMMMMMMMMMMMMMMMmds+.        OS: Mint 19.1 tessa
 MMm----::-://////////////oymNMd+`     Kernel: x86_64 Linux 4.15.0-20-generic
 MMd      /++                -sNMd:    Uptime: 2h 34m
 MMNso/`  dMM    `.::-. .-::.` .hMN:   Packages: 2217
 ddddMMh  dMM   :hNMNMNhNMNMNh: `NMm   Shell: bash 4.4.20
     NMm  dMM  .NMN/-+MMM+-/NMN` dMM   Resolution: 1920x1080
     NMm  dMM  -MMm  `MMM   dMM. dMM   DE: Cinnamon 4.0.10
     NMm  dMM  -MMm  `MMM   dMM. dMM   WM: Muffin
     NMm  dMM  .mmd  `mmm   yMM. dMM   WM Theme: Mint-Y-Dark (Mint-Y)
     NMm  dMM`  ..`   ...   ydm. dMM   GTK Theme: Mint-Y [GTK2/3]
     hMM- +MMd/-------...-:sdds  dMM   Icon Theme: Mint-Y
     -NMm- :hNMNNNmdddddddddy/`  dMM   Font: Noto Sans 9
      -dMNs-``-::::-------.``    dMM   CPU: Intel Core i7-6700 @ 8x 4GHz [52.0°C]
       `/dMNmy+/:-------------:/yMMM   GPU: NV136
          ./ydNMMMMMMMMMMMMMMMMMMMMM   RAM: 2544MiB / 7926MiB
             .MMMMMMMMMMMMMMMMMMM

ចូរវាស់ស្ទង់ដំណើរការនៃម៉ាស៊ីនមេដែលមានខ្សែតែមួយ។ តោះបើកស្ថានីយពីរ៖ ក្នុងមួយយើងនឹងដំណើរការ ./http_serverនៅក្នុងផ្សេងគ្នា - ស្នាម. បន្ទាប់ពីមួយនាទី ស្ថិតិខាងក្រោមនឹងត្រូវបានបង្ហាញនៅក្នុងស្ថានីយទីពីរ៖

$ wrk -c100 -d1m -t8 http://127.0.0.1:18470 -H "Host: 127.0.0.1:18470" -H "Accept-Language: en-US,en;q=0.5" -H "Connection: keep-alive"
Running 1m test @ http://127.0.0.1:18470
  8 threads and 100 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   493.52us   76.70us  17.31ms   89.57%
    Req/Sec    24.37k     1.81k   29.34k    68.13%
  11657769 requests in 1.00m, 1.60GB read
Requests/sec: 193974.70
Transfer/sec:     27.19MB

ម៉ាស៊ីនមេដែលមានខ្សែតែមួយរបស់យើងអាចដំណើរការសំណើជាង 11 លានក្នុងមួយនាទីដែលមានប្រភពមកពី 100 ការតភ្ជាប់។ មិនមែនជាលទ្ធផលអាក្រក់ទេ ប៉ុន្តែតើវាអាចកែលម្អបានទេ?

ម៉ាស៊ីនមេពហុខ្សែ

ដូចដែលបានរៀបរាប់ខាងលើ រ៉េអាក់ទ័រ I/O អាចត្រូវបានបង្កើតជាខ្សែស្រឡាយដាច់ដោយឡែក ដោយប្រើប្រាស់ស្នូលស៊ីភីយូទាំងអស់។ ចូរយើងអនុវត្តវិធីសាស្រ្តនេះ៖

បង្ហាញ http_server_multithreaded.c

#include "reactor.h"

static Reactor *reactor;
#pragma omp threadprivate(reactor)

#include "common.h"

int main(void) {
#pragma omp parallel
    {
        SAFE_CALL((reactor = reactor_new()), NULL);
        SAFE_CALL(reactor_register(reactor, new_server(true), EPOLLIN,
                                   on_accept, NULL),
                  -1);
        SAFE_CALL(reactor_run(reactor, SERVER_TIMEOUT_MILLIS), -1);
        SAFE_CALL(reactor_destroy(reactor), -1);
    }
}

ឥឡូវនេះជារៀងរាល់ខ្សែ ជាម្ចាស់របស់ខ្លួន រ៉េអាក់ទ័រ៖

static Reactor *reactor;
#pragma omp threadprivate(reactor)

សូមចំណាំថាអាគុយម៉ង់មុខងារ new_server() អ្នកតស៊ូមតិ true. នេះមានន័យថាយើងផ្តល់ជម្រើសទៅរន្ធម៉ាស៊ីនមេ SO_REUSEPORTដើម្បីប្រើវានៅក្នុងបរិយាកាសពហុខ្សែ។ អ្នកអាចអានព័ត៌មានលម្អិតបន្ថែម នៅទីនេះ.

ការរត់លើកទីពីរ

ឥឡូវនេះយើងវាស់ស្ទង់ដំណើរការរបស់ម៉ាស៊ីនមេដែលមានខ្សែច្រើន៖

$ wrk -c100 -d1m -t8 http://127.0.0.1:18470 -H "Host: 127.0.0.1:18470" -H "Accept-Language: en-US,en;q=0.5" -H "Connection: keep-alive"
Running 1m test @ http://127.0.0.1:18470
  8 threads and 100 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     1.14ms    2.53ms  40.73ms   89.98%
    Req/Sec    79.98k    18.07k  154.64k    78.65%
  38208400 requests in 1.00m, 5.23GB read
Requests/sec: 635876.41
Transfer/sec:     89.14MB

ចំនួនសំណើដែលបានដំណើរការក្នុងរយៈពេល 1 នាទីបានកើនឡើង ~ 3.28 ដង! ប៉ុន្តែយើងមានចំនួនតិចជាង ២ លាននាក់ប៉ុណ្ណោះ ដូច្នេះយើងព្យាយាមដោះស្រាយបញ្ហានោះ។

ជាដំបូងសូមក្រឡេកមើលស្ថិតិដែលបានបង្កើត ល្អ:

$ sudo perf stat -B -e task-clock,context-switches,cpu-migrations,page-faults,cycles,instructions,branches,branch-misses,cache-misses ./http_server_multithreaded

 Performance counter stats for './http_server_multithreaded':

     242446,314933      task-clock (msec)         #    4,000 CPUs utilized          
         1 813 074      context-switches          #    0,007 M/sec                  
             4 689      cpu-migrations            #    0,019 K/sec                  
               254      page-faults               #    0,001 K/sec                  
   895 324 830 170      cycles                    #    3,693 GHz                    
   621 378 066 808      instructions              #    0,69  insn per cycle         
   119 926 709 370      branches                  #  494,653 M/sec                  
     3 227 095 669      branch-misses             #    2,69% of all branches        
           808 664      cache-misses                                                

      60,604330670 seconds time elapsed

ការប្រើប្រាស់ CPU Affinity, ការចងក្រងជាមួយ -march=native, ភីអរការកើនឡើងនៃចំនួនទស្សនា ឃ្លាំងសម្ងាត់, កើនឡើង MAX_EVENTS និងប្រើប្រាស់ EPOLLET មិនបានផ្តល់នូវការកើនឡើងគួរឱ្យកត់សម្គាល់នៅក្នុងការអនុវត្ត។ ប៉ុន្តែតើមានអ្វីកើតឡើងប្រសិនបើអ្នកបង្កើនចំនួននៃការតភ្ជាប់ក្នុងពេលដំណាលគ្នា?

ស្ថិតិសម្រាប់ការតភ្ជាប់ដំណាលគ្នា 352៖

$ wrk -c352 -d1m -t8 http://127.0.0.1:18470 -H "Host: 127.0.0.1:18470" -H "Accept-Language: en-US,en;q=0.5" -H "Connection: keep-alive"
Running 1m test @ http://127.0.0.1:18470
  8 threads and 352 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     2.12ms    3.79ms  68.23ms   87.49%
    Req/Sec    83.78k    12.69k  169.81k    83.59%
  40006142 requests in 1.00m, 5.48GB read
Requests/sec: 665789.26
Transfer/sec:     93.34MB

លទ្ធផលដែលចង់បានត្រូវបានទទួល ហើយជាមួយវាក្រាហ្វគួរឱ្យចាប់អារម្មណ៍បង្ហាញពីការពឹងផ្អែកនៃចំនួនសំណើដែលបានដំណើរការក្នុងរយៈពេល 1 នាទីលើចំនួននៃការតភ្ជាប់៖

យើងឃើញថាបន្ទាប់ពីការភ្ជាប់ពីរបីរយចំនួននៃសំណើដែលបានដំណើរការសម្រាប់ម៉ាស៊ីនមេទាំងពីរធ្លាក់ចុះយ៉ាងខ្លាំង (នៅក្នុងកំណែពហុខ្សែនេះគឺគួរឱ្យកត់សម្គាល់ជាង)។ តើវាទាក់ទងនឹងការអនុវត្តជង់លីនុច TCP/IP ដែរឬទេ? មានអារម្មណ៍សេរីក្នុងការសរសេរការសន្មត់របស់អ្នកអំពីឥរិយាបថនេះនៃក្រាហ្វ និងការបង្កើនប្រសិទ្ធភាពសម្រាប់ជម្រើសខ្សែច្រើន និងខ្សែតែមួយនៅក្នុងមតិយោបល់។

តើធ្វើដូចម្តេច បានកត់សម្គាល់ នៅក្នុងសេចក្តីអធិប្បាយ ការធ្វើតេស្តដំណើរការនេះមិនបង្ហាញពីឥរិយាបថរបស់រ៉េអាក់ទ័រ I/O នៅក្រោមបន្ទុកពិតប្រាកដទេ ព្រោះស្ទើរតែគ្រប់ពេលម៉ាស៊ីនមេធ្វើអន្តរកម្មជាមួយមូលដ្ឋានទិន្នន័យ កំណត់ហេតុលទ្ធផល ប្រើគ្រីបគ្រីបជាមួយ TLS បាន ល ជាលទ្ធផលដែលបន្ទុកក្លាយទៅជាមិនស្មើគ្នា (ថាមវន្ត)។ ការធ្វើតេស្តរួមគ្នាជាមួយសមាសធាតុភាគីទីបីនឹងត្រូវបានអនុវត្តនៅក្នុងអត្ថបទអំពី I/O proactor ។

គុណវិបត្តិនៃរ៉េអាក់ទ័រ I/O

អ្នកត្រូវយល់ថា រ៉េអាក់ទ័រ I/O មិនមែនដោយគ្មានគុណវិបត្តិរបស់វាទេ ពោលគឺ៖

ការប្រើប្រាស់រ៉េអាក់ទ័រ I/O នៅក្នុងបរិយាកាសពហុខ្សែគឺពិបាកជាងបន្តិច ពីព្រោះ អ្នកនឹងត្រូវគ្រប់គ្រងលំហូរដោយដៃ។
ការអនុវត្តបង្ហាញថាក្នុងករណីភាគច្រើនការផ្ទុកមិនស្មើគ្នាដែលអាចនាំឱ្យមានការកាប់ឈើមួយខ្សែខណៈពេលដែលមួយទៀតរវល់ជាមួយការងារ។
ប្រសិនបើអ្នកដោះស្រាយព្រឹត្តិការណ៍មួយរារាំងខ្សែស្រឡាយ នោះអ្នកជ្រើសរើសប្រព័ន្ធខ្លួនឯងក៏នឹងទប់ស្កាត់ផងដែរ ដែលអាចនាំឱ្យពិបាកស្វែងរកកំហុស។

ដោះស្រាយបញ្ហាទាំងនេះ ភ្នាក់ងារ I/Oដែលជារឿយៗមានកម្មវិធីកំណត់ពេលដែលចែកចាយបន្ទុកស្មើៗគ្នាទៅកាន់បណ្តុំនៃខ្សែស្រឡាយ ហើយក៏មាន API ងាយស្រួលជាងផងដែរ។ យើងនឹងនិយាយអំពីវានៅពេលក្រោយនៅក្នុងអត្ថបទផ្សេងទៀតរបស់ខ្ញុំ។

សេចក្តីសន្និដ្ឋាន

នេះគឺជាកន្លែងដែលការធ្វើដំណើររបស់យើងពីទ្រឹស្ដីត្រង់ចូលទៅក្នុងបំពង់ផ្សែង profiler បានបញ្ចប់។

អ្នកមិនគួរពឹងផ្អែកលើរឿងនេះទេ ព្រោះមានវិធីសាស្រ្តគួរឱ្យចាប់អារម្មណ៍ដូចគ្នាជាច្រើនទៀតក្នុងការសរសេរកម្មវិធីបណ្តាញជាមួយនឹងកម្រិតភាពងាយស្រួល និងល្បឿនខុសៗគ្នា។ គួរឱ្យចាប់អារម្មណ៍, នៅក្នុងគំនិតរបស់ខ្ញុំ, តំណភ្ជាប់ត្រូវបានផ្តល់ឱ្យខាងក្រោម។

រហូតដល់ពេលក្រោយ!

គម្រោងគួរឱ្យចាប់អារម្មណ៍

តើត្រូវអានអ្វីទៀត?

ប្រភព: www.habr.com

រ៉េអាក់ទ័រ Bare-C I/O មានលក្ខណៈពិសេសពេញលេញ