How to define the Object structure of redis

Introduction to Redis’s two-layer data structure

One of the reasons for the high performance of redis is that each of its data structures is specially designed , and are supported by one or more data structures, relying on these flexible data structures to improve the performance of reading and writing. The data structure of Redis can be discussed from two different perspectives

• The first level is from the user's perspective. This level is also the calling interface that Redis exposes to the outside world, such as : string, list, hash, set, sorted set.

• The second level is from the perspective of internal implementation, which belongs to the lower level implementation, such as: dict, sds, ziplist, quicklist, skiplist, intset.

Internal implementation of Redis data structure

From the perspective of a Redis user, a Redis node contains multiple databases (non-cluster The default is 16 in mode, and it can only be 1 in cluster mode), and a database maintains the mapping relationship from key space to object space. The key of this mapping relationship is of string type, and the value can be of multiple data types, such as: string, list, hash, set, sorted set, etc. The type of key is always string, however value may be of multiple types.

From the perspective of Redis's internal implementation, the mapping relationship within the database is maintained using a dict. It is enough for the key of dict to be expressed in a fixed data structure, which is dynamic string sds. The value is more complicated. In order to store different types of values ​​in the same dict, a common data structure is needed. This common data structure is robj, and its full name is redisObject.

For example:

• If value is a list, then its internal storage structure is a quicklist.

• Generally, if value is a string, its internal storage structure is usually sds. But if the value of the string type value is a number, Redis will internally convert it into a long type for storage, thereby reducing memory usage.

So, a robj can represent not only an sds, but also a quicklist, and even a long type.

redisObject structure

The definition of redisObject is as follows:

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* lru time (relative to server.lruclock) */
    int refcount;
    void *ptr;} robj;

A robj contains the following 5 fields:

• type: object data type. Occupies 4 bits. There are 5 possible values: OBJ_STRING, OBJ_LIST, OBJ_SET, OBJ_ZSET,
  OBJ_HASH, which respectively correspond to the 5 data structures exposed by Redis.

• encoding: The internal representation of the object (can also be called encoding), occupies 4 bits, and has 10 possible values.

• lru: Used for LRU replacement algorithm, accounting for 24 bits.

• refcount: Reference count. It allows robj objects to be shared under certain circumstances.

• ptr: data pointer. Points to the real data. For example, a robj representing a string, its ptr may point to an sds structure; a robj representing a list, its ptr may point to a quicklist.

What needs to be carefully examined here is the encoding field. The same type may also correspond to different encodings, which means that the same data type may have different internal representations. Different internal representations will have different memory usage and search performance.

When type = OBJ_STRING, it means that this robj stores a string. At this time, the encoding can be one of the following three types:

• OBJ_ENCODING_RAW: string uses native representation, that is, sds.

• OBJ_ENCODING_INT: string is represented by numbers, which is actually a long type.

• OBJ_ENCODING_EMBSTR: string is represented by a special embedded sds.

When type = OBJ_HASH, it means that this robj stores a hash. At this time, the encoding can be one of the following two:

• OBJ_ENCODING_HT: hash is represented by a dict.

• OBJ_ENCODING_ZIPLIST: hash is represented by a ziplist.

The ten values ​​of encoding are as follows:

• OBJ_ENCODING_RAW: The most native representation. This encoding value only applies to string type (represented by sds).

• OBJ_ENCODING_INT: Expressed as a number. It is actually represented by long.

• OBJ_ENCODING_HT: expressed as dict.

• "OBJ_ENCODING_ZIPMAP" is an outdated representation that is no longer in use.. It is only available in versions smaller than Redis 2.6.

• OBJ_ENCODING_LINKEDLIST: It is also an old representation and is no longer used.

• OBJ_ENCODING_ZIPLIST: expressed as ziplist.

• OBJ_ENCODING_INTSET: Expressed as intset. Used for set data structures.

• The object encoding represented in skiplist form is OBJ_ENCODING_SKIPLIST. Used for sorted set data structure.

• OBJ_ENCODING_EMBSTR: Represented as a special embedded sds.

• OBJ_ENCODING_QUICKLIST: expressed as quicklist. Used for list data structures.

The role of redisObject

The role of redisObject is as follows:

• redisObjec is the link between two A bridge between levels of data structures.

• Provides a unified representation for multiple data types.

• Allows the same type of data to use different internal representations, thereby saving memory as much as possible in some cases.

• Supports object sharing and reference counting. When an object is shared, only one memory copy is occupied, further saving memory.

The above is the detailed content of How to define the Object structure of redis. For more information, please follow other related articles on the PHP Chinese website!