Detailed explanation of Object in redis learning skills

This article brings you relevant knowledge about Redis, which mainly introduces related issues about Object, including two-layer data structure, internal implementation of data structure, Object structure, etc. Let’s take a look at the relevant content below. I hope it will be helpful to everyone.

Recommended learning: Redis video tutorial

Introduction to Redis’s two-tier data structure

One of the reasons for the high performance of redis is that each of its data structures is specially designed and supported by one or more data structures. It relies on these flexible data structures to improve the performance of reading and writing. performance. If you want to understand the data structure of redis, you can discuss it from two different levels:

• The first level is from the user's perspective, and this level is also what Redis exposes to External calling interface, 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. We can see that the type of key is fixed to string, while the possible types of value are multiple.

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.

• If value is a string, then its internal storage structure is usually an 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. In fact, only the string type will use this encoding value (expressed as sds).

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

• OBJ_ENCODING_HT: expressed as dict.

• OBJ_ENCODING_ZIPMAP: It is an old representation and is no longer used. 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.

• OBJ_ENCODING_SKIPLIST: expressed as 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.

Recommended learning: Redis video tutorial

The above is the detailed content of Detailed explanation of Object in redis learning skills. For more information, please follow other related articles on the PHP Chinese website!