[database learning] redis parser & single thread & Model

@[toc]

Redis High performance parser of the Protocol

although redis The protocol is easy to read and implement , But it can be implemented with performance similar to binary Protocol .
Resp Use prefix length to transmit large amount of data , So it doesn't need to scan the load to find JSON Special characters like , There is no need to reference the load that needs to be sent to the server .
Batch and multi batch lengths can be processed using code , These codes perform a single operation on each character , And scan at the same time CR character , For example, the following C Code ：
Resp Use prefix length to transmit multiple lines of data , So it doesn't need to scan the load to find JSON Special characters like , There is no need to reference the load that needs to be sent to the server .
You can handle multiple lines and multiple line lengths with code . This code performs a single operation on each character , And scan at the same time CR character .

#include <stdio.h>int main(void) {    unsigned char *p = "$123\r\n";    int len = 0;    p++;    while(*p != '\r') {        len = (len*10)+(*p - '0');        p++;    }    /* Now p points at '\r', and the len is in bulk_len. */    printf("%d\n", len);    return 0;}

Identify the first CR after , You can skip it and the following LF, Without any treatment . then , Large volumes of data can be read using a single read operation that does not check the payload in any way . Last , remainder Cr and LF Characters will be discarded without any processing .
Redis The performance of the protocol is equivalent to that of the binary Protocol . what's more , It is easy to implement in most high-level languages , Thus reducing the number of errors in the client software .

C Language implementation , although C be conducive to redis Performance of , But language is not the core factor .
Pure memory input / Output . Compared with other disk based databases ,redis The pure memory operation of has natural performance advantages .
Input / Output multiplexing , be based on epoll/select/kqueue Equal input / Output multiplexing technology , Achieve high throughput network input / Output .
In the single threaded model , A thread cannot use more than one kernel , But on the other hand , It avoids the overhead of synchronization mechanisms such as frequent context switching and locking of multiple threads .

Single thread

about DB,CPU Usually not a bottleneck , Because most requests are not CPU intensive , It is i/o intensive . about redis, If you don't think about rdb/aof And so on ,redis Is a complete pure memory operation , Very fast execution . therefore , This part of the operation is usually not a performance bottleneck .redis The real performance bottleneck is the network i/o, That is, the network transmission delay between the client and the server . therefore ,redis Select single thread i/o Multiplexing to realize its core network model .

Avoid too much context switching overhead

In multithreading scheduling , Need to be in CPU Switch thread context between , Context switching involves a series of register replacements , Such as program counter 、 Stack pointer and program status word 、 Program stack reset , even to the extent that CPU Cache and TLB Quick table replacement . If you switch between multiple threads in a process , The effect is better , Because multiple threads in a single process share the process address space , therefore , The thread context is much smaller than the process context . If it's cross process scheduling , You need to switch the entire process address space .
If it's a single thread , You can avoid the overhead of frequent thread switching in the process , Because the program always runs in a single thread in the process , And there is no scenario of multi-threaded switching .

The expected multithreaded programming is compared with the actual multithreaded programming ：

A network model

Redis Agreement passed TCP, Client and Redis Instance maintains duplex connection , As shown in the figure below ：

Serialization implementation

The implementation of serialization is relatively simple . After executing the previous command , The same connection sends a second request . As shown in the figure below ：

Single connection throughput = 1 / (2* Network delay + Server processing time + Client processing time )

redis Processing time for a single request （10 Microsecond ） Often than LAN Small delay 1 An order of magnitude . therefore , In serial mode , A single connection waits the most time on the network , The processing power of the server is not fully utilized .