sparkline

　　微线图，即用一个一个信息点形成的图，类似于折线图。在表示时延的时候，就可以用微线图的形式来表示。

示例：

　　微线图中的信息点可以有两种形式：”_-`” 和 “_o#”

　　两种情况最后形成的微线图分别如下所示：

　　可以看到，用一个一个的信息点，非常形象明了的形成了所需的折线图

sparkline的实现

　　sparkline中每个信息点的定义为：

struct sample {
    double value;
    char *label;
};

　　value为该点的值

　　label为名称

　　而最终的微线图就是通过这样的信息点序列来实现的　　

struct sequence {
    int length;
    int labels;
    struct sample *samples;
    double min, max;
};

• length：序列中的样点数
• labels：序列中所有有标签的样点数
• samples：数组，为组成微线图的样点集
• min：所有样点中的最小值
• max：所有样点中的最大值

创建一个微线图序列

struct sequence *createSparklineSequence(void) {
    struct sequence *seq = zmalloc(sizeof(*seq));
    seq->length = 0;
    seq->samples = NULL;
    return seq;
}

向微线图中加入一个样点

void sparklineSequenceAddSample(struct sequence *seq, double value, char *label) {
    label = (label == NULL || label[0] == ‘\0‘) ? NULL : zstrdup(label);
    if (seq->length == 0) {
        seq->min = seq->max = value;
    } else {  //更新最小值和最大值
        if (value < seq->min) seq->min = value;
        else if (value > seq->max) seq->max = value;
    }
    seq->samples = zrealloc(seq->samples,sizeof(struct sample)*(seq->length+1));
    seq->samples[seq->length].value = value; //将样点加入到样点集中
    seq->samples[seq->length].label = label;
    seq->length++;
    if (label) seq->labels++;
}

　　样点是按照一定顺序加入到序列集中的，因此最终形成的微线图中所有样点的x坐标都是按照先后顺序来依次递增的。

画图

sds sparklineRender(sds output, struct sequence *seq, int columns, int rows, int flags) {
    int j;

    for (j = 0; j < seq->length; j += columns) {
        int sublen = (seq->length-j) < columns ? (seq->length-j) : columns;

        if (j != 0) output = sdscatlen(output,"\n",1);
        output = sparklineRenderRange(output, seq, rows, j, sublen, flags);
    }
    return output;
}

　　最终所有的样点是通过调用函数将每个样点转换为ASCII码形式，来形成最终的折线图的。

　　通过参数columns和rows限定了最后输出的图形的行数和列数，通过参数flags来选择每个信息点的表示方式。

　　当seq中样点数不大于限定的列数时，只需执行一次sparklineRenderRange（）就可以将序列中每个样点都转换为字符串的形式。

　　最后将输出的折线图按照字符串的形式存储在output中。 　　

//将seq中的seq->samples[offset,offset+len)的样点转换成rows行字符串的形式，存储在output中
sds sparklineRenderRange(sds output, struct sequence *seq, int rows, int offset, int len, int flags) {
    int j;
    double relmax = seq->max - seq->min; //最大相对值
    int steps = charset_len*rows; //最终的行数
    int row = 0;
    char *chars = zmalloc(len);  //len列
    int loop = 1;
    int opt_fill = flags & SPARKLINE_FILL;
    int opt_log = flags & SPARKLINE_LOG_SCALE;

    if (opt_log) {
        relmax = log(relmax+1);
    } else if (relmax == 0) {
        relmax = 1;
    }

    while(loop) {
        loop = 0;
        memset(chars,‘ ‘,len);
        for (j = 0; j < len; j++) {
            struct sample *s = &seq->samples[j+offset];
            double relval = s->value - seq->min; //每个样点的相对值
            int step;

            if (opt_log) relval = log(relval+1);
            step = (int) (relval*steps)/relmax;
            if (step < 0) step = 0;
            if (step >= steps) step = steps-1;

            if (row < rows) {
                int charidx = step-((rows-row-1)*charset_len);
                loop = 1;
                if (charidx >= 0 && charidx < charset_len) { //将数字转换为ASCII码
                    chars[j] = opt_fill ? charset_fill[charidx] :charset[charidx];
                } else if(opt_fill && charidx >= charset_len) {
                    chars[j] = ‘|‘;
                }
            } else {  //对于大于row的行，不处理样点，只处理label
                /* ......  */
            }
        }
        if (loop) {
            row++;
            output = sdscatlen(output,chars,len);
            output = sdscatlen(output,"\n",1);
        }
    }
    zfree(chars);
    return output;
}

　　这样就将一系列的样点值转换成ASCII码的字符串形式了

本文所引用的源码全部来自Redis3.0.7版本

redis学习参考资料：

https://github.com/huangz1990/redis-3.0-annotated

Redis 设计与实现（第二版）