Redis数据结构的实现

青旅半醒 2022-09-02 03:50 125阅读 0赞

## Redis数据结构的实现 ##

### 一、String（simple dynamic string SDS 简单动态字符串） ###

Redis默认并未直接使用C字符串(C字符串仅仅作为字符串字面量，用在一些无需对字符串进行修改的地方，如打印日志)。而是以Struct的形式构造了一个SDS的抽象类型。当Redis需要一个可以被修改的字符串时，就会使用SDS来表示。在Redis数据库里，包含字符串值的键值对都是由SDS实现的(Redis中所有的键都是由字符串对象实现的即底层是由SDS实现，Redis中所有的值对象中包含的字符串对象底层也是由SDS实现)。

#### 1、**数据结构** ####

![Redisç®€å•åŠ¨æ€å—ç¬¦ä¸²][Redis]

struct sdshdr{
        
        //int 记录buf数组中未使用字节的数量 如上图free为0代表未使用字节的数量为0
        int free;
        //int 记录buf数组中已使用字节的数量即sds的长度 如上图len为5代表未使用字节的数量为5
        int len;
        //字节数组用于保存字符串 sds遵循了c字符串以空字符结尾的惯例目的是为了重用c字符串函数库里的函数
        char buf[];
    }c

#### **2、SDS与C字符串的区别（优势）** ####

##### （1）常数级复杂度获取字符串的长度 #####

在c字符串中如何要获取一个字符串的长度，需要使用strlen（）函数去获取，而这个方法获取长度的实现是去遍历整个字符串进行计数，知道遇到末尾的空字符，时间复杂度为O（n）；

在SDS的数据结构中维护了一个len的整数值，记录了该字符串的长度，使得其对字符串长度的查询的时间复杂度降低了O(1)的常数级； ![SDSä¸ŽCå—ç¬¦ä¸²][SDS_C]

##### （2）杜绝缓存区的溢出 #####

拼接字符串函数：char \* strcat(char \*dest, char \*src);

因为c字符串不记录自身的长度，所以strcat（）假定用户在执行这个函数时，已经为dest分配了足够的内存，

但如果假设不成立，dest没有足够的内存，那么就会造成缓冲区溢出的结果，如下面的例子，将溢出部分的内容直接给替换了，造成了数据的污染；

![Cå—ç¬¦ä¸²å†å˜æº¢å‡º][C]

但是在SDS中由于保存了对应len长度和free的一个空闲字符长度，所以在拼接时，会先对其检查剩余空间是否符合要求，会不会造成溢出的现象，如何会造成溢出，那么会自动对其先进行空间大小的拓展，之后再进行拼接；

##### （3）减少修改字符串时带来的内存重分配次数 #####

这一点和上面说到时很相像的，只是上面的更多的结果（拓展空间），这里更多的是解释拓展的规则；

在c语言中，字符串拼接时需要考虑缓冲区溢出的问题，在字符串缩短的时候，需要去考虑内存空间的释放，否则将会造成内存泄露；

而Redis常被用于高性能的场合，如果每次修改字符串都要进行内存重分配，无疑是巨大的性能损失。而Redis的SDS提供了两种空间分配策略来解决这个问题。

**空间预分配**

*  如果修改后len长度将小于1M,这时分配给free的大小和len一样,例如修改过后为10字节, 那么给free也是10字节，buf实际长度变成了10+10+1 = 21byte；
 *  如果修改后len长度将大于等于1M,这时分配给free的长度为1M,例如修改过后为30M,那么给free是1M.buf实际长度变成了30M+1M+1byte；

![img][]

**惰性空间释放**

惰性空间释放用于字符串缩短的操作。当字符串缩短是，程序并不是立即使用内存重分配来回收缩短出来的字节，而是使用free属性记录起来，并等待将来使用。

Redis通过空间预分配和惰性空间释放策略在字符串操作中一定程度上减少了内存重分配的次数。但这种策略同样会造成一定的内存浪费，因此Redis SDS API提供相应的API让我们在有需要的时候真正的释放SDS的未使用空间。

![Redis æƒ°æ€§ç©ºé—´é‡Šæ”¾][Redis 1]

##### （4）二进制安全 #####

C字符串中的字符必须符合某种编码（比如ASCII），并且除了字符串的末尾之外，字符串里面不能包含空字符，否则最先被程序读入的空字符将被误认为是字符串结尾，这些限制使得C字符串只能保存文本数据，而不能保存像图片、音频、视频、压缩文件这样的二进制数据。如果有一种使用空字符来分割多个单词的特殊数据格式，就不能用C字符串来表示，如"Redis\\0String"，C字符串的函数会把’\\0’当做结束符来处理，而忽略到后面的"String"。而SDS的buf字节数组不是在保存字符，而是一系列二进制数组，SDS API都会以二进制的方式来处理buf数组里的数据，使用len属性的值而不是空字符来判断字符串是否结束。

### 二、链表 ###

在Resdi中使用的链表结构为双向无环链表；

#### 1、**数据结构** ####

![listç»“æž„][list]

typedef struct listNode
    {
         
    	// 前置节点 
    	struct listNode *prev; 
    	// 后置节点 
    	struct listNode *next; 
    	// 节点的值 
    	void *value; 
    } listNode;

typedef struct list{
        
        //表头节点
        listNode *head;
        //表尾节点
        listNode *tail;
        //链表所包含的节点数量
        unsigned long len;
        //节点值复制函数
        void *(*dup)(void *ptr);
        //节点值释放函数
        void *(*free)(void *ptr);
        //节点值对比函数
        int (*match)(void *ptr,void *key);
    }list;

### 三、字典 ###

Redis的字典使用哈希表作为底层实现；

#### 1、数据结构 ####

![img][img 1]

typedef struct dict{
        
             //类型特定函数
             dictYType *type;
             //私有数据
             void *privdata;
             //哈希表-见2.1.2
             dictht ht[2];
             //rehash 索引 当rehash不在进行时 值为-1
             int trehashidx; 
    }dict;

type属性和privdata属性是针对不同类型的键值对，为创建多态字典而设置的。

*  type属性是一个指向dictType结构的指针，每个dictType用于操作特定类型键值对的函数，Redis会为用途不同的字典设置不同的类型特定函数。
 *  privdata属性则保存了需要传给给那些类型特定函数的可选参数。
 *  ht属性是一个包含两个项的数组，数组中的每个项都是一个dictht哈希表， 一般情况下，字典只使用ht\[0\] 哈希表, ht\[1\]哈希表只会对ht\[0\]哈希表进行rehash时使用。
 *  rehashidx记录了rehash目前的进度，如果目前没有进行rehash，值为-1。

typedef struct dictType
    {
        
             //计算哈希值的函数 
             unsigned int  (*hashFunction) (const void *key);
             //复制键的函数
             void *(*keyDup) (void *privdata,const void *key);
             //复制值的函数
             void *(*keyDup) (void *privdata,const void *obj);
              //复制值的函数
             void *(*keyCompare) (void *privdata,const void *key1, const void *key2);
             //销毁键的函数
             void (*keyDestructor) (void *privdata, void *key);
             //销毁值的函数
             void (*keyDestructor) (void *privdata, void *obj);
    }dictType;

typedef struct dictht
    {
        
             //哈希表数组，C语言中，*号是为了表明该变量为指针，有几个* 号就相当于是几级指针，这里是二级指针，理解为指向指针的指针
             dictEntry **table;
             //哈希表大小
             unsigned long size;
             //哈希表大小掩码，用于计算索引值
             unsigned long sizemask;
             //该哈希已有节点的数量
             unsigned long used;
    }dictht;

*  table属性是一个数组，数组中的每个元素都是一个指向dict.h/dictEntry结构的指针，每个dictEntry结构保存着一个键值对
 *  size属性记录了哈希表的大小，也是table数组的大小
 *  used属性则记录哈希表目前已有节点(键值对)的数量
 *  sizemask属性的值总是等于 size-1(从0开始)，这个属性和哈希值一起决定一个键应该被放到table数组的哪个索引上面（索引下标值）。

//哈希表节点定义dictEntry结构表示，每个dictEntry结构都保存着一个键值对。
    typedef struct dictEntry
    {
        
             //键
             void *key;
             //值
             union{
        
               void *val;
                uint64_tu64;
                int64_ts64;
                }v;
             // 指向下个哈希表节点，形成链表
             struct dictEntry *next;
    }dictEntry;

key属性保存着键值中的键，而v属性则保存着键值对中的值，其中键值(v属性)可以是一个指针，或uint64\_t整数，或int64\_t整数。 next属性是指向另一个哈希表节点的指针，这个指针可以将多个哈希值相同的键值对连接在一起，解决键冲突问题。

#### 2、rehash ####

随着操作的进行，散列表中保存的键值对会也会不断地增加或减少，为了保证负载因子维持在一个合理的范围，当散列表内的键值对过多或过少时，内需要定期进行rehash，以提升性能或节省内存。Redis的rehash的步骤如下:

![img][img 2]

（1）为字典的ht\[1\]散列表分配空间，这个空间的大小取决于要执行的操作以及ht\[0\]当前包含的键值对数量(即:ht\[0\].used的属性值)

*  扩展操作：ht\[1\]的大小为 第一个大于等于ht\[0\].used\*2的2的n次方幂。如:ht\[0\].used=3则ht\[1\]的大小为8，ht\[0\].used=4则ht\[1\]的大小为8。
 *  收缩操作: ht\[1\]的大小为 第一个大于等于ht\[0\].used的2的n次方幂。

![img][img 3]

（2）将保存在ht\[0\]中的键值对重新计算键的散列值和索引值，然后放到ht\[1\]指定的位置上。

![img][img 4]

（3）将ht\[0\]包含的所有键值对都迁移到了ht\[1\]之后，释放ht\[0\],将ht\[1\]设置为ht\[0\],并创建一个新的ht\[1\]哈希表为下一次rehash做准备。

![img][img 5]

**rehash操作需要满足以下条件:**

1.  服务器目前没有执行BGSAVE(rdb持久化)命令或者BGREWRITEAOF(AOF文件重写)命令，并且散列表的负载因子大于等于1。
2.  服务器目前正在执行BGSAVE命令或者BGREWRITEAOF命令，并且负载因子大于等于5。
3.  当负载因子小于0.1时，程序自动开始执行收缩操作。

Redis这么做的目的是基于操作系统创建子进程后写时复制技术，避免不必要的写入操作。(有关BGSAVE、BGREWRITEAOF以及写时复制会在后续持久化一文详细介绍)。

#### 3、 渐进式 rehash ####

对于rehash我们思考一个问题如果散列表当前大小为 1GB，要想扩容为原来的两倍大小，那就需要对 1GB 的数据重新计算哈希值，并且从原来的散列表搬移到新的散列表。这种情况听着就很耗时，而生产环境中甚至会更大。为了解决一次性扩容耗时过多的情况，可以将扩容操作穿插在插入操作的过程中，分批完成。当负载因子触达阈值之后，只申请新空间，但并不将老的数据搬移到新散列表中。当有新数据要插入时，将新数据插入新散列表中，并且从老的散列表中拿出一个数据放入到新散列表。每次插入一个数据到散列表，都重复上面的过程。经过多次插入操作之后，老的散列表中的数据就一点一点全部搬移到新散列表中了。这样没有了集中的一次一次性数据搬移，插入操作就都变得很快了。

Redis为了解决这个问题采用渐进式rehash方式。以下是Redis渐进式rehash的详细步骤:

1.  为 `ht[1]` 分配空间， 让字典同时持有 `ht[0]` 和 `ht[1]` 两个哈希表。
2.  在字典中维持一个索引计数器变量 `rehashidx` ， 并将它的值设置为 `0` ，表示 rehash 工作正式开始。
3.  在 rehash 进行期间， 每次对字典执行添加、删除、查找或者更新操作时， 程序除了执行指定的操作以外， 还会顺带将 `ht[0]` 哈希表在 `rehashidx` 索引上的所有键值对 rehash 到 `ht[1]` ， 当 rehash 工作完成之后， 程序将 `rehashidx` 属性的值增一。
4.  随着字典操作的不断执行， 最终在某个时间点上， `ht[0]` 的所有键值对都会被 rehash 至 `ht[1]` ， 这时程序将 `rehashidx` 属性的值设为 `-1` ， 表示 rehash 操作已完成。

\*\*说明: \*\*

**1.因为在进行渐进式 rehash 的过程中，字典会同时使用 `ht[0]` 和 `ht[1]` 两个哈希表，所以在渐进式 rehash 进行期间，字典的删除（delete）、查找（find）、更新（update）等操作会在两个哈希表上进行。**

**2. 在渐进式 rehash 执行期间，新添加到字典的键值对一律会被保存到 `ht[1]` 里面，而 `ht[0]` 则不再进行任何添加操作：这一措施保证了 `ht[0]` 包含的键值对数量会只减不增，并随着 rehash 操作的执行而最终变成空表。**

### 四、跳跃表 ###

#### 1、简介： ####

对于一个单链表来讲，即便链表中存储的数据是有序的，如果我们要想在其中查找某个数据，也只能从头到尾遍历链表。这样查找效率就会很低，时间复杂度会很高，是 O(n)。

![单链表][e3f75eda38009dc89f2a5aac7287469f.png]

如果我们想要提高其查找效率，可以考虑在链表上建索引的方式。每两个结点提取一个结点到上一级，我们把抽出来的那一级叫作索引。![一层跳跃表][1e235d7d3bc4144823e22f7f96e639b6.png]

这个时候，我们假设要查找节点8，我们可以先在索引层遍历，当遍历到索引层中值为 7 的结点时，发现下一个节点是9，那么要查找的节点8肯定就在这两个节点之间。我们下降到链表层继续遍历就找到了8这个节点。原先我们在单链表中找到8这个节点要遍历8个节点，而现在有了一级索引后只需要遍历五个节点。

从这个例子里，我们看出，加来一层索引之后，查找一个结点需要遍的结点个数减少了，也就是说查找效率提高了，同理再加一级索引。

![二层跳跃表][4de4fc664f3158cda4b55b3c30ae556c.png]

从图中我们可以看出，查找效率又有提升。在例子中我们的数据很少，当有大量的数据时，我们可以增加多级索引，其查找效率可以得到明显提升。

![跳跃表][0cf68efb0796b18871e5d6dff939d32e.png]

**像这种链表加多级索引的结构，就是跳跃表！**

#### 2、数据结构 ####

![Redisè·³è·ƒè¡¨][Redis 2]

typedef struct zskiplist{
        
        //表头节点和表尾节点
        struct skiplistNode *header,*tail;
        //表中节点的数量
        unsigned int length;
        //表中层数最大的节点的层数
        int level;
    }

typedef struct zskiplistNode{
        
        //后退指针
        struct zskiplistNode *backward;
        //分值
        double scire;
        //成员对象
        robj *obj;
        //层
        struct zskiplistNode{
        
            //前进指针
            struct zskiplistNode *forward;
            //跨度
            unsigned int span;
        }level[];
    }zskiplistNode;

*  header:指向跳跃表的表头节点，通过这个指针程序定位表头节点的时间复杂度就为O(1)
 *  tail:指向跳跃表的表尾节点,通过这个指针程序定位表尾节点的时间复杂度就为O(1)
 *  level:记录目前跳跃表内,层数最大的那个节点的层数(表头节点的层数不计算在内)，通过这个属性可以再O(1)的时间复杂度内获取层高最好的节点的层数。
 *  length:记录跳跃表的长度,也即是,跳跃表目前包含节点的数量(表头节点不计算在内)，通过这个属性，程序可以再O(1)的时间复杂度内返回跳跃表的长度。
    
    结构右方的是四个 zskiplistNode结构,该结构包含以下属性
 *  层(level):
    
    节点中用1、2、L3等字样标记节点的各个层,L1代表第一层,L代表第二层,以此类推。
    
    每个层都带有两个属性:前进指针和跨度。前进指针用于访问位于表尾方向的其他节点,而跨度则记录了前进指针所指向节点和当前节点的距离(跨度越大、距离越远)。在上图中,连线上带有数字的箭头就代表前进指针,而那个数字就是跨度。当程序从表头向表尾进行遍历时,访问会沿着层的前进指针进行。
    
    每次创建一个新跳跃表节点的时候,程序都根据幂次定律(powerlaw,越大的数出现的概率越小)随机生成一个介于1和32之间的值作为level数组的大小,这个大小就是层的“高度”。
 *  后退(backward)指针：
    
    节点中用BW字样标记节点的后退指针,它指向位于当前节点的前一个节点。后退指针在程序从表尾向表头遍历时使用。与前进指针所不同的是每个节点只有一个后退指针，因此每次只能后退一个节点。
 *  分值(score):
    
    各个节点中的1.0、2.0和3.0是节点所保存的分值。在跳跃表中,节点按各自所保存的分值从小到大排列。
 *  成员对象(oj):
    
    各个节点中的o1、o2和o3是节点所保存的成员对象。在同一个跳跃表中,各个节点保存的成员对象必须是唯一的,但是多个节点保存的分值却可以是相同的:分值相同的节点将按照成员对象在字典序中的大小来进行排序,成员对象较小的节点会排在前面(靠近表头的方向),而成员对象较大的节点则会排在后面(靠近表尾的方向)。

### 五、整数集合 ###

整数集合(intset)并不是一个基础的数据结构，而是Redis自己设计的一种存储结构，是集合键的底层实现之一,当一个集合只包含整数值元素,并且这个集合的元素数量不多时, Redis i就会使用整数集合作为集合键的底层实现。

整数集合(intset)是Redis用于保存整数值的集合抽象数据结构,它可以保存类型为int16\_t、int32\_t或者int64\_t的整数值,并且保证集合中不会出现重复元素。

#### 1、数据结构 ####

![int16\_t][int16_t]

//每个intset结构表示一个整数集合
    typedef struct intset{
        
        //编码方式
        uint32_t encoding;
        //集合中包含的元素数量
        uint32_t length;
        //保存元素的数组
        int8_t contents[];
    } intset;

*  contents数组是整数集合的底层实现，整数集合的每个元素都是 contents数组的个数组项(item),各个项在数组中按值的大小从小到大有序地排列,并且数组中不包含任何重复项。
 *  length属性记录了数组的长度。
 *  intset结构将contents属性声明为int8\_t类型的数组,但实际上 contents数组并不保存任何int8t类型的值, contents数组的真正类型取决于encoding属性的值。encoding属性的值为INTSET\_ENC\_INT16则数组就是uint16\_t类型，数组中的每一个元素都是int16\_t类型的整数值(-32768——32767)，encoding属性的值为INTSET\_ENC\_INT32则数组就是uint32\_t类型，数组中的每一个元素都是int16\_t类型的整数值(-2147483648——2147483647)。

#### 2、升级机制 ####

正如上面所提到的问题，每当我们要将一个新元素添加到整数集合里面,并且新元素的类型比整数集合现有所有元素的类型都要长时,整数集合需要先进行升级,然后才能将新元素添加到整数集合里面。升级整数集合并添加新元素主要分三步来进行。

1.  根据新元素的类型,扩展整数集合底层数组的空间大小,并为新元素分配空间。
2.  将底层数组现有的所有元素都转换成与新元素相同的类型,并将类型转换后的元素放置到正确的位上,而且在放置元素的过程中,需要继续维持底层数组的有序性质不变。
3.  将新元素添加到底层数组里面。

![img][img 6]

#### 3、降级 ####

整数集合不支持降级操作,一旦对数组进行了升级,编码就会一直保持升级后的状态。也就是说一旦我们向一个int16\_t的整数集合内添加了一个int32\_t的元素后，整数集合将升级到int32\_t类型。即使后续的操作中我们删除了这个元素，整数集合还是会保持int32\_t类型的状态。

### 六、压缩列表 ###

听到“压缩”两个字，直观的反应就是节省内存。之所以说这种存储结构节省内存,是相较于数组的存储思路而言的。我们知道,数组要求每个元素的大小相同,如果我们要存储不同长度的字符串,那我们就需要用最大长度的字符串大小作为元素的大小(假设是20个字节)。存储小于 20 个字节长度的字符串的时候，便会浪费部分存储空间。

![img][img 7]

数组的优势占用一片连续的空间可以很好的利用CPU缓存访问数据。如果我们想要保留这种优势，又想节省存储空间我们可以对数组进行压缩。

![img][img 8]

但是这样有一个问题，我们在遍历它的时候由于不知道每个元素的大小是多少，因此也就无法计算出下一个节点的具体位置。这个时候我们可以给每个节点增加一个lenght的属性。

![img][img 9]

如此。我们在遍历节点的之后就知道每个节点的长度(占用内存的大小)，就可以很容易计算出下一个节点再内存中的位置。这种结构就像一个简单的压缩列表了。

#### 1、数据结构 ####

![img][img 10]

![img][img 11]

如上图，展示了一个总长为80字节，包含3个节点的压缩列表。如果我们有一个指向压缩列表起始地址的指针p，那么表为节点的地址就是P+60。

![img][img 12]

节点的 previous\_entry\_length属性以字节为单位,记录了压缩列表中前一个节点的长度。 previous\_entry\_length属性的长度可以是1字节或者5字节。

*  如果前一节点的长度小于254字节,那么 previous\_entry\_length属性的长度为1字节，前一节点的长度就保存在这一个字节里面。
 *  如果前一节点的长度大于等于254字节,那么 previous\_entry\_length属性的长度为5字节:其中属性的第一字节会被设置为0xFE(十进制值254),而之后的四个字节则用于保存前一节点的长度.
    
    节点的encoding属性记录了节点的content属性所保存数据的类型以及长度。
 *  一字节、两字节或者五字节长,值的最高位为00、01或者10的是字节数组编码这种编码表示节点的 content属性保存着字节数组,数组的长度由编码除去最高两位之后的其他位记录。
 *  一字节长,值的最高位以11开头的是整数编码:这种编码表示节点的content属性保存着整数值,整数值的类型和长度由编码除去最高两位之后的其他位记录。
    
    节点的content属性负责保存节点的值,节点值可以是一个字节数组或者整数,值的类型和长度由节点的encoding属性决定。
    
    示例：

![img][img 13]

*  编码的最高两位00表示节点保存的是一个字节数组。
 *  编码的后六位001011记录了字节数组的长度11。
 *  content属性保存着节点的值"hello world"。
 *  编码11000000表示节点保存的是一个int16\_t类型的整数值;
 *  content属性保存着节点的值10086

参考链接：https://www.cnblogs.com/hunternet/p/11306690.html系列博文

参考书籍：Redis设计与实现 黄健宏

[Redis]: /images/20220829/af678f2cfc59437583c3fd0e68a7c62c.png
[SDS_C]: /images/20220829/4904d279f7e7464a843e7a0a09f22ef4.png
[C]: /images/20220829/713cce33270a461391adaa2c1ee1d794.png
[img]: /images/20220829/bb96c62ae10046cd83dd3dd90dce5168.png
[Redis 1]: /images/20220829/ba94b402a59a47ecb87ffe7c89897afa.png
[list]: /images/20220829/98365694ecfa4157bda8df54f249b64e.png
[img 1]: /images/20220829/6af854fb672f484fb028bf8a8909e263.png
[img 2]: /images/20220829/c6129a8af31e4b148913f0ed15b1e38e.png
[img 3]: /images/20220829/86a44f39ee224c0883eca747d39b69f0.png
[img 4]: /images/20220829/f114eed818c64601a3de78fa316d3037.png
[img 5]: /images/20220829/7f4f7ccc8f16498f8cec8fdb19eb01c2.png
[e3f75eda38009dc89f2a5aac7287469f.png]: /images/20220829/ae3f3e0c68e6445f9950ca8603e769b6.png
[1e235d7d3bc4144823e22f7f96e639b6.png]: /images/20220829/91943b9e79f34b47996fa8a21180faf8.png
[4de4fc664f3158cda4b55b3c30ae556c.png]: /images/20220829/1ed59c78df8c403f8f9fffdfdd37fe2a.png
[0cf68efb0796b18871e5d6dff939d32e.png]: /images/20220829/0b09c94c44744ff8ac35bf7f6c4609a1.png
[Redis 2]: /images/20220829/5fabfe3a33ed489290c21bc3849f7721.png
[int16_t]: /images/20220829/dc4acad2c77b4d7c9ea58acc8e37d3a6.png
[img 6]: /images/20220829/25e615f756334b7cb71694382d36fd53.png
[img 7]: /images/20220829/45cf913cfa5541aabd46013b2b27cca3.png
[img 8]: /images/20220829/2e321a552eba4b4ebccf3ef578b399cf.png
[img 9]: /images/20220829/14db6886a758461890a52fa61a9c44c5.png
[img 10]: /images/20220829/edb15e61aa4d44acb596e3c80e6a39e4.png
[img 11]: /images/20220829/22440a1ac4e8437d8459e9798f1f3166.png
[img 12]: /images/20220829/d744e37effb14aa99ac6e5ef22626c3c.png
[img 13]: /images/20220829/ac39ef1dcb024293adf44c3d8ecc099b.png