ਜਾਣ ਪਛਾਣ

I/O ਰਿਐਕਟਰ (ਸਿੰਗਲ ਥਰਿੱਡਡ ਘਟਨਾ ਲੂਪ) ਉੱਚ-ਲੋਡ ਸੌਫਟਵੇਅਰ ਲਿਖਣ ਲਈ ਇੱਕ ਪੈਟਰਨ ਹੈ, ਜੋ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰਸਿੱਧ ਹੱਲਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ:

• Node.js
• Tor
• ਪ੍ਰਸਾਰਣ
• Chromium
• ਯਾਦ ਕੀਤਾ
• ...

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ I/O ਰਿਐਕਟਰ ਦੇ ਅੰਦਰ ਅਤੇ ਬਾਹਰ ਦੇਖਾਂਗੇ ਅਤੇ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਕੋਡ ਦੀਆਂ 200 ਤੋਂ ਘੱਟ ਲਾਈਨਾਂ ਵਿੱਚ ਇੱਕ ਲਾਗੂਕਰਨ ਲਿਖਾਂਗੇ, ਅਤੇ 40 ਮਿਲੀਅਨ ਬੇਨਤੀਆਂ/ਮਿੰਟ ਤੋਂ ਵੱਧ ਇੱਕ ਸਧਾਰਨ HTTP ਸਰਵਰ ਪ੍ਰਕਿਰਿਆ ਬਣਾਵਾਂਗੇ।

ਮੁਖਬੰਧ

• ਲੇਖ I/O ਰਿਐਕਟਰ ਦੇ ਕੰਮਕਾਜ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਲਿਖਿਆ ਗਿਆ ਸੀ, ਅਤੇ ਇਸਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਜੋਖਮਾਂ ਨੂੰ ਸਮਝੋ।
• ਲੇਖ ਨੂੰ ਸਮਝਣ ਲਈ ਬੁਨਿਆਦੀ ਗਿਆਨ ਦੀ ਲੋੜ ਹੈ। ਸੀ ਭਾਸ਼ਾ ਅਤੇ ਨੈੱਟਵਰਕ ਐਪਲੀਕੇਸ਼ਨ ਡਿਵੈਲਪਮੈਂਟ ਵਿੱਚ ਕੁਝ ਅਨੁਭਵ।
• ਸਾਰੇ ਕੋਡ ਨੂੰ (ਸਾਵਧਾਨ: ਲੰਬੀ PDF) C11 ਸਟੈਂਡਰਡ ਤੱਕ Linux ਲਈ ਅਤੇ ਇਸ 'ਤੇ ਉਪਲਬਧ ਹੈ GitHub.

ਇਹ ਕਿਉਂ ਜ਼ਰੂਰੀ ਹੈ?

ਇੰਟਰਨੈੱਟ ਦੀ ਵਧਦੀ ਪ੍ਰਸਿੱਧੀ ਦੇ ਨਾਲ, ਵੈੱਬ ਸਰਵਰਾਂ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਕੁਨੈਕਸ਼ਨਾਂ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਪੈਣ ਲੱਗੀ, ਅਤੇ ਇਸ ਲਈ ਦੋ ਤਰੀਕੇ ਅਜ਼ਮਾਉਣੇ ਪਏ: ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ OS ਥਰਿੱਡਾਂ 'ਤੇ I/O ਨੂੰ ਬਲਾਕ ਕਰਨਾ ਅਤੇ I/O ਨੂੰ ਨਾ-ਬਲਾਕ ਕਰਨਾ। ਇੱਕ ਇਵੈਂਟ ਨੋਟੀਫਿਕੇਸ਼ਨ ਸਿਸਟਮ, ਜਿਸਨੂੰ "ਸਿਸਟਮ ਚੋਣਕਾਰ" ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ (ਈਪੋਲ/kqueue/ਆਈ.ਓ.ਸੀ.ਪੀ/ ਆਦਿ)।

ਪਹਿਲੀ ਪਹੁੰਚ ਵਿੱਚ ਹਰੇਕ ਆਉਣ ਵਾਲੇ ਕੁਨੈਕਸ਼ਨ ਲਈ ਇੱਕ ਨਵਾਂ OS ਥ੍ਰੈਡ ਬਣਾਉਣਾ ਸ਼ਾਮਲ ਹੈ। ਇਸਦਾ ਨੁਕਸਾਨ ਮਾੜੀ ਮਾਪਯੋਗਤਾ ਹੈ: ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੂੰ ਬਹੁਤ ਸਾਰੇ ਲਾਗੂ ਕਰਨੇ ਪੈਣਗੇ ਸੰਦਰਭ ਪਰਿਵਰਤਨ и ਸਿਸਟਮ ਕਾਲਾਂ. ਉਹ ਮਹਿੰਗੇ ਓਪਰੇਸ਼ਨ ਹਨ ਅਤੇ ਕੁਨੈਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਸੰਖਿਆ ਦੇ ਨਾਲ ਮੁਫਤ RAM ਦੀ ਘਾਟ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ।

ਸੋਧਿਆ ਹੋਇਆ ਸੰਸਕਰਣ ਹਾਈਲਾਈਟ ਕਰਦਾ ਹੈ ਥਰਿੱਡਾਂ ਦੀ ਸਥਿਰ ਸੰਖਿਆ (ਥ੍ਰੈੱਡ ਪੂਲ), ਇਸ ਤਰ੍ਹਾਂ ਸਿਸਟਮ ਨੂੰ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਅਧੂਰਾ ਛੱਡਣ ਤੋਂ ਰੋਕਦਾ ਹੈ, ਪਰ ਉਸੇ ਸਮੇਂ ਇੱਕ ਨਵੀਂ ਸਮੱਸਿਆ ਪੇਸ਼ ਕਰਦਾ ਹੈ: ਜੇਕਰ ਇੱਕ ਥਰਿੱਡ ਪੂਲ ਵਰਤਮਾਨ ਵਿੱਚ ਲੰਬੇ ਰੀਡ ਓਪਰੇਸ਼ਨ ਦੁਆਰਾ ਬਲੌਕ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਹੋਰ ਸਾਕਟ ਜੋ ਪਹਿਲਾਂ ਹੀ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਣਗੇ. ਅਜਿਹਾ ਕਰੋ

ਦੂਜੀ ਪਹੁੰਚ ਵਰਤਦਾ ਹੈ ਘਟਨਾ ਸੂਚਨਾ ਸਿਸਟਮ (ਸਿਸਟਮ ਚੋਣਕਾਰ) OS ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਲੇਖ I/O ਓਪਰੇਸ਼ਨਾਂ ਲਈ ਤਿਆਰੀ ਬਾਰੇ ਚੇਤਾਵਨੀਆਂ (ਘਟਨਾਵਾਂ, ਸੂਚਨਾਵਾਂ) ਦੇ ਅਧਾਰ ਤੇ, ਸਿਸਟਮ ਚੋਣਕਾਰ ਦੀ ਸਭ ਤੋਂ ਆਮ ਕਿਸਮ ਦੀ ਚਰਚਾ ਕਰਦਾ ਹੈ, ਨਾ ਕਿ ਉਹਨਾਂ ਦੇ ਮੁਕੰਮਲ ਹੋਣ ਬਾਰੇ ਸੂਚਨਾਵਾਂ. ਇਸਦੀ ਵਰਤੋਂ ਦੀ ਇੱਕ ਸਰਲ ਉਦਾਹਰਣ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਬਲਾਕ ਚਿੱਤਰ ਦੁਆਰਾ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:

ਇਹਨਾਂ ਪਹੁੰਚਾਂ ਵਿੱਚ ਅੰਤਰ ਇਸ ਪ੍ਰਕਾਰ ਹੈ:

• I/O ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਬਲੌਕ ਕਰਨਾ ਮੁਅੱਤਲ ਉਪਭੋਗਤਾ ਵਹਾਅ ਜਦ ਤੱਕਓਐਸ ਠੀਕ ਹੋਣ ਤੱਕ ਡੀਫ੍ਰੈਗਮੈਂਟਸ ਆਉਣ ਵਾਲਾ IP ਪੈਕੇਟ ਬਾਈਟ ਸਟ੍ਰੀਮ ਨੂੰ (TCP, ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨਾ) ਜਾਂ ਅੰਦਰੂਨੀ ਰਾਈਟ ਬਫਰਾਂ ਵਿੱਚ ਬਾਅਦ ਵਿੱਚ ਭੇਜਣ ਲਈ ਲੋੜੀਂਦੀ ਥਾਂ ਉਪਲਬਧ ਨਹੀਂ ਹੋਵੇਗੀ ਐਨ ਆਈ ਸੀ (ਡੇਟਾ ਭੇਜਣਾ)
• ਸਿਸਟਮ ਚੋਣਕਾਰ afikun asiko ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਓ.ਐਸ ਹੀ ਡੀਫ੍ਰੈਗਮੈਂਟ ਕੀਤੇ 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 (ਇੱਕ ਇਵੈਂਟ ਹੈਂਡਲਰ ਦਾ ਢਾਂਚਾ ਅਤੇ ਇਸਦੇ ਲਈ ਇੱਕ ਉਪਭੋਗਤਾ ਦਲੀਲ)।

ਰਿਐਕਟਰ ਅਤੇ ਕਾਲਬੈਕਡਾਟਾ ਦਿਖਾਓ

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

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

ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਅਸੀਂ ਹੈਂਡਲ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਸਮਰੱਥ ਬਣਾਇਆ ਹੈ ਅਧੂਰੀ ਕਿਸਮ ਸੂਚਕਾਂਕ ਦੇ ਅਨੁਸਾਰ. IN reactor.h ਅਸੀਂ ਢਾਂਚੇ ਦਾ ਐਲਾਨ ਕਰਦੇ ਹਾਂ reactorਅਤੇ ਅੰਦਰ reactor.c ਅਸੀਂ ਇਸਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ, ਇਸ ਤਰ੍ਹਾਂ ਉਪਭੋਗਤਾ ਨੂੰ ਇਸਦੇ ਖੇਤਰਾਂ ਨੂੰ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਬਦਲਣ ਤੋਂ ਰੋਕਦਾ ਹੈ। ਇਹ ਪੈਟਰਨ ਦੇ ਇੱਕ ਹੈ ਡਾਟਾ ਲੁਕਾਉਣਾ, ਜੋ ਸੰਖੇਪ ਰੂਪ ਵਿੱਚ C ਅਰਥ ਵਿਗਿਆਨ ਵਿੱਚ ਫਿੱਟ ਬੈਠਦਾ ਹੈ।

ਫੰਕਸ਼ਨ 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(), ਡਾਟਾ ਭੇਜਣ ਲਈ ਤਿਆਰ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ ਕਲਾਇੰਟ ਨੂੰ ਇੱਕ ਚਿੱਤਰ ਦੇ ਨਾਲ HTML ਵਾਲਾ ਇੱਕ HTTP ਜਵਾਬ ਭੇਜਦਾ ਹੈ ਅਤੇ ਫਿਰ ਇਵੈਂਟ ਹੈਂਡਲਰ ਨੂੰ ਵਾਪਸ ਵਿੱਚ ਬਦਲਦਾ ਹੈ 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 ਪ੍ਰੋਜੈਕਟ ਰੂਟ ਵਿੱਚ) ਅਤੇ ਸਵੈ-ਲਿਖਤ ਸਰਵਰ ਨੂੰ ਲਾਂਚ ਕਰੋ, ਖੋਲ੍ਹੋ http://127.0.0.1:18470 ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਅਤੇ ਦੇਖੋ ਕਿ ਅਸੀਂ ਕੀ ਉਮੀਦ ਕਰਦੇ ਹਾਂ:

ਪ੍ਰਦਰਸ਼ਨ ਮਾਪ

ਮੇਰੀ ਕਾਰ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਿਖਾਓ

$ 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 ਰਿਐਕਟਰ ਨੂੰ ਵੱਖਰੇ ਥ੍ਰੈਡਾਂ ਵਿੱਚ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਸਾਰੇ CPU ਕੋਰਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਆਓ ਇਸ ਪਹੁੰਚ ਨੂੰ ਅਮਲ ਵਿੱਚ ਲਿਆਈਏ:

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 ਗੁਣਾ ਵਧ ਗਈ ਹੈ! ਪਰ ਅਸੀਂ ਰਾਉਂਡ ਨੰਬਰ ਤੋਂ ਸਿਰਫ ~XNUMX ਮਿਲੀਅਨ ਘੱਟ ਸੀ, ਇਸ ਲਈ ਆਓ ਇਸਨੂੰ ਠੀਕ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ।

ਪਹਿਲਾਂ ਜਨਰੇਟ ਕੀਤੇ ਗਏ ਅੰਕੜਿਆਂ ਨੂੰ ਦੇਖੀਏ ਸੰਪੂਰਣ:

$ 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 ਐਫੀਨਿਟੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਨਾਲ ਸੰਕਲਨ -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 ਪ੍ਰੋਐਕਟਰ ਬਾਰੇ ਲੇਖ ਵਿੱਚ ਤੀਜੀ-ਧਿਰ ਦੇ ਭਾਗਾਂ ਦੇ ਨਾਲ ਟੈਸਟ ਕੀਤੇ ਜਾਣਗੇ।

I/O ਰਿਐਕਟਰ ਦੇ ਨੁਕਸਾਨ

ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣ ਦੀ ਲੋੜ ਹੈ ਕਿ I/O ਰਿਐਕਟਰ ਆਪਣੀਆਂ ਕਮੀਆਂ ਤੋਂ ਬਿਨਾਂ ਨਹੀਂ ਹੈ, ਅਰਥਾਤ:

• ਮਲਟੀ-ਥਰਿੱਡਡ ਵਾਤਾਵਰਣ ਵਿੱਚ ਇੱਕ I/O ਰਿਐਕਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਕੁਝ ਹੋਰ ਮੁਸ਼ਕਲ ਹੈ, ਕਿਉਂਕਿ ਤੁਹਾਨੂੰ ਹੱਥੀਂ ਪ੍ਰਵਾਹ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਪਏਗਾ।
• ਅਭਿਆਸ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ ਲੋਡ ਗੈਰ-ਯੂਨੀਫਾਰਮ ਹੁੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਇੱਕ ਥਰਿੱਡ ਲੌਗਿੰਗ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਕਿ ਦੂਜਾ ਕੰਮ ਵਿੱਚ ਰੁੱਝਿਆ ਹੁੰਦਾ ਹੈ।
• ਜੇਕਰ ਇੱਕ ਇਵੈਂਟ ਹੈਂਡਲਰ ਇੱਕ ਥਰਿੱਡ ਨੂੰ ਬਲੌਕ ਕਰਦਾ ਹੈ, ਤਾਂ ਸਿਸਟਮ ਚੋਣਕਾਰ ਖੁਦ ਵੀ ਬਲੌਕ ਕਰ ਦੇਵੇਗਾ, ਜਿਸ ਨਾਲ ਲੱਭਣ ਵਿੱਚ ਮੁਸ਼ਕਲ ਬੱਗ ਹੋ ਸਕਦੇ ਹਨ।

ਇਹਨਾਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ I/O ਪ੍ਰੋਐਕਟਰ, ਜਿਸ ਵਿੱਚ ਅਕਸਰ ਇੱਕ ਸ਼ਡਿਊਲਰ ਹੁੰਦਾ ਹੈ ਜੋ ਥਰਿੱਡਾਂ ਦੇ ਇੱਕ ਪੂਲ ਵਿੱਚ ਲੋਡ ਨੂੰ ਸਮਾਨ ਰੂਪ ਵਿੱਚ ਵੰਡਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਵਧੇਰੇ ਸੁਵਿਧਾਜਨਕ API ਵੀ ਹੈ। ਅਸੀਂ ਇਸ ਬਾਰੇ ਬਾਅਦ ਵਿੱਚ, ਮੇਰੇ ਦੂਜੇ ਲੇਖ ਵਿੱਚ ਗੱਲ ਕਰਾਂਗੇ.

ਸਿੱਟਾ

ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਸਿਧਾਂਤ ਤੋਂ ਸਿੱਧਾ ਪ੍ਰੋਫਾਈਲਰ ਐਗਜ਼ੌਸਟ ਤੱਕ ਸਾਡੀ ਯਾਤਰਾ ਖਤਮ ਹੋ ਗਈ ਹੈ।

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

DO новых встреч!

ਦਿਲਚਸਪ ਪ੍ਰੋਜੈਕਟ

• ਸੀ
  • libevent
  • ਉਦਵ
  • libuv
  • libevhtp
  • liburing
  • ਡੀ.ਪੀ.ਡੀ.ਕੇ.
  • ਨੈੱਟਮੈਪ
  • PF_RING
• ਜੰਗਾਲ
  • Mio
  • ਟੋਕਿਓ
  • smoltcp

ਮੈਨੂੰ ਹੋਰ ਕੀ ਪੜ੍ਹਨਾ ਚਾਹੀਦਾ ਹੈ?

• https://linux.die.net/man/7/socket
• https://stackoverflow.com/questions/1050222/what-is-the-difference-between-concurrency-and-parallelism
• http://www.kegel.com/c10k.html
• https://kernel.dk/io_uring.pdf
• https://aturon.github.io/blog/2016/09/07/futures-design/
• https://tokio.rs/blog/2019-10-scheduler/
• https://www.artima.com/articles/io_design_patterns.html
• https://habr.com/en/post/183832/

ਸਰੋਤ: www.habr.com