[Qemu OpenChannelSSD] feature I/

除了最基本的I/O via ppa-address以外，liblightnvm还包了一些其他的IO方式，如vblk，lba等.

(vblk与lba似乎实现都还有些不完整或没有完全测试)

1

Intro

vblk: 把底下的若干个nvm_addr封装成一个虚拟的块（virtual block），用户可以针对这个虚拟块进行：

1. 擦除(擦除属于这个块的所有addr)
2. 从这个块的某个偏移处读/写若干字节(必须对齐)

• 从nvm_vblk_alloc_line可以看出: vblk->nblks的单位是2个block.

• vblk I/O 用到的一些设置， 在open一个设备的时候进行的预设.(可以看出一个lun上的plane数只能是1，2，4)

nvm_dev.c:
line 219:
static int dev_attr_fill(struct nvm_dev *dev)
{
    ...
    
    /* Derive a default plane mode */
    switch(geo->nplanes) {
        case 4:
            dev->pmode = NVM_FLAG_PMODE_QUAD;
            break;
        case 2:
            dev->pmode = NVM_FLAG_PMODE_DUAL;
            break;
        case 1:
            dev->pmode = NVM_FLAG_PMODE_SNGL;
            break;

        default:
            errno = EINVAL;
            return -1;
    }

    dev->erase_naddrs_max = NVM_NADDR_MAX;  //Macro at liblightnvm.h, line 42: #define NVM_NADDR_MAX 64
    dev->write_naddrs_max = NVM_NADDR_MAX;
    dev->read_naddrs_max = NVM_NADDR_MAX;

    dev->meta_mode = NVM_META_MODE_NONE;

    return 0;
}

vblk erase

nvm_vblk.c, line 116:
static inline int _cmd_nblks(int nblks, int cmd_nblks_max)//找到一个小于等于cmd_nblks_max并能整除nblks的最大整数作为并行化因子
{
    int cmd_nblks = cmd_nblks_max;

    while(nblks % cmd_nblks && cmd_nblks > 1) --cmd_nblks;

    return cmd_nblks;
}

nvm_vblk.c, line 125:
ssize_t nvm_vblk_erase(struct nvm_vblk *vblk)
{
    size_t nerr = 0;
    const struct nvm_geo *geo = nvm_dev_get_geo(vblk->dev);
    const int PMODE = vblk->dev->pmode;

    const int BLK_NADDRS = geo->nplanes;  //擦除的粒度单位，1个单位 = geo->nplanes个block地址
    const int CMD_NBLKS = _cmd_nblks(vblk->nblks,
                vblk->dev->erase_naddrs_max / BLK_NADDRS); //一个线程擦除单位数
        //一个线程擦除的block数 = 单位数 * 每单位block数 ： CMD_NBLKS * geo->nplanes
    const int NTHREADS = vblk->nblks < CMD_NBLKS ? 1 : vblk->nblks / CMD_NBLKS;//总共能出多少个线程
    //这里可以看出当nblks比较大时（大于vblk->dev->erase_naddrs_max / BLK_NADDRS），才可能出多线程。

    #pragma omp parallel for num_threads(NTHREADS) schedule(static,1) reduction(+:nerr) ordered if (NTHREADS>1)
    for (int off = 0; off < vblk->nblks; off += CMD_NBLKS) {
        ssize_t err;
        struct nvm_ret ret = {};

        const int nblks = NVM_MIN(CMD_NBLKS, vblk->nblks - off);
        const int naddrs = nblks * BLK_NADDRS;

        struct nvm_addr addrs[naddrs];

        for (int i = 0; i < naddrs; ++i) {
            const int idx = off + (i / BLK_NADDRS);

            addrs[i].ppa = vblk->blks[idx].ppa;
            addrs[i].g.pl = i % geo->nplanes;
        }

        err = nvm_addr_erase(vblk->dev, addrs, naddrs, PMODE, &ret);//真正进行擦除的地方（正如之前分析的Basic I/O）
        if (err)
            ++nerr;

        #pragma omp ordered
        {}
    }

    if (nerr) {
        errno = EIO;
        return -1;
    }

    vblk->pos_write = 0;
    vblk->pos_read = 0;

    return vblk->nbytes;
}

这里的并行化采用了OpenMP, pthread vs OpenMP:

OpenMP vs pthread

• 多数情况下openmp能很容易直接从串行程序改过来，并且在没有多线程能力的情况下退回单线程执行

• pthread得自己搞，而且如果没有多线程执行能力也会强制分时多线程，引入额外负担，好处是比openmp灵活

vblk write

由于NAND的特点，vblk包含的地址空间中的每个sector只能一次写，vblk以pos_write维护目前写了多少地址.(由此可知还剩多少sector可写.

由于IO的单位是sector，因此这里写多少个字节需要能整除sector_nbytes.

172:
static inline int _cmd_nspages(int nblks, int cmd_nspages_max)
{
    int cmd_nspages = cmd_nspages_max;

    while(nblks % cmd_nspages && cmd_nspages > 1) --cmd_nspages;

    return cmd_nspages;
}

...
181:
ssize_t nvm_vblk_pwrite(struct nvm_vblk *vblk, const void *buf, size_t count, 
     size_t offset)//count与offset都必须能整除geo->nplanes * geo->nsectors,即`对齐`
{
    size_t nerr = 0;
    const int PMODE = nvm_dev_get_pmode(vblk->dev);
    const struct nvm_geo *geo = nvm_dev_get_geo(vblk->dev);

    const int SPAGE_NADDRS = geo->nplanes * geo->nsectors;//写的粒度单位，1个单位 = geo->nplanes * geo->nsectors个sector地址 =  geo->nplanes 个page大小
    const int CMD_NSPAGES = _cmd_nspages(vblk->nblks,
                vblk->dev->write_naddrs_max / SPAGE_NADDRS);//一个线程写的单位数????这里可能有问题，multi-threading may not work. let‘s make a issue。
        //一个线程I/O的sector数 = 单位数 * 每个单位的sector数：CMD_NSPAGES * SPAGE_NADDRS
    const int ALIGN = SPAGE_NADDRS * geo->sector_nbytes;//写的粒度单位对应的字节数
    const int NTHREADS = vblk->nblks < CMD_NSPAGES ? 1 : vblk->nblks / CMD_NSPAGES;

    const size_t bgn = offset / ALIGN;//从第几个单位开始
    const size_t end = bgn + (count / ALIGN); //到第几个单位结束

    char *padding_buf = NULL;

    const size_t meta_tbytes = CMD_NSPAGES * SPAGE_NADDRS * geo->meta_nbytes;//一个线程最大可能I/O的metadata字节数
    char *meta = NULL;

    if (offset + count > vblk->nbytes) {        // Check bounds
        errno = EINVAL;
        return -1;
    }

    if ((count % ALIGN) || (offset % ALIGN)) {  // Check align
        errno = EINVAL;
        return -1;
    }

    if (!buf) { // Allocate and use a padding buffer
        const size_t nbytes = CMD_NSPAGES * SPAGE_NADDRS * geo->sector_nbytes;

        padding_buf = nvm_buf_alloc(geo, nbytes);
        if (!padding_buf) {
            errno = ENOMEM;
            return -1;
        }
        nvm_buf_fill(padding_buf, nbytes);
    }

    if (vblk->dev->meta_mode != NVM_META_MODE_NONE) {   // Meta
        meta = nvm_buf_alloc(geo, meta_tbytes);     // Alloc buf
        if (!meta) {
            errno = ENOMEM;
            return -1;
        }

        switch(vblk->dev->meta_mode) {          // Fill it
            case NVM_META_MODE_ALPHA:
                nvm_buf_fill(meta, meta_tbytes);
                break;
            case NVM_META_MODE_CONST:
                for (size_t i = 0; i < meta_tbytes; ++i)
                    meta[i] = 65 + (meta_tbytes % 20);
                break;
            case NVM_META_MODE_NONE:
                break;
        }
    }//目前版本的默认模式是meta_none（master - 3b399c9c4bc315）

    #pragma omp parallel for num_threads(NTHREADS) schedule(static,1) reduction(+:nerr) ordered if(NTHREADS>1)
    for (size_t off = bgn; off < end; off += CMD_NSPAGES) {//每个线程CMD_NSPAGES个单位
        struct nvm_ret ret = {};

        const int nspages = NVM_MIN(CMD_NSPAGES, (int)(end - off));
        const int naddrs = nspages * SPAGE_NADDRS;

        struct nvm_addr addrs[naddrs];
        const char *buf_off;

        if (padding_buf)
            buf_off = padding_buf;
        else
            buf_off = buf + (off - bgn) * geo->sector_nbytes * SPAGE_NADDRS;

        for (int i = 0; i < naddrs; ++i) {
            const int spg = off + (i / SPAGE_NADDRS);//目前写到第spg个单位
！！！       const int idx = spg % vblk->nblks;//这个是比较关键的一句:保证了IO在lun之间均匀分布，而不是集中在某个lun某个ch上.
            const int pg = (spg / vblk->nblks) % geo->npages;

            addrs[i].ppa = vblk->blks[idx].ppa;
            addrs[i].g.pg = pg;
            addrs[i].g.pl = (i / geo->nsectors) % geo->nplanes;
            addrs[i].g.sec = i % geo->nsectors;
        }

        const ssize_t err = nvm_addr_write(vblk->dev, addrs, naddrs,
                           buf_off, meta, PMODE, &ret);
        if (err)
            ++nerr;

        #pragma omp ordered
        {}
    }

    free(padding_buf);

    if (nerr) {
        errno = EIO;
        return -1;
    }

    return count;
}

vblk addressing.png

总结

• vblk：
• vblk->nblks值的单位 = geo->nplanes个block = geo->nplanes * geo->npages * geo->nsectors 个sector = geo->npages个写粒度单位（页）
• vblk擦除的粒度单位: geo->nplanes个block地址
• vblk写的粒度单位: geo->nplanes * geo->nsectors个sector地址
• 擦除和读写的上限都是NVM_NADDR_MAX个地址，但意义却不同，擦出的地址单位是block地址，读写的地址单位是sector地址
• 使用OpenMP进行并行优化.

• 一个OCSSD的lun上的plane数目只能是1，2 或 4.（见dev_attr_fill(): nvm_dev.c）