C++ 自制Redis数据库（十三) 持久化AOF日志模块测试完毕

小鱼儿 2022-08-20 11:16 126阅读 0赞

### 持久化AOF部分测试完毕 ###

废话不多说，一般写日志，很多人就直接write 了，但是效率很低，这里就不详细解释了。

### 我AOF模块的设计 ###

我是在为我的数据库写这个日志模块所以我需要考虑如下几个指标：

1.并发量不敢说很巨大。但是多个线程同时需要写日志这种可能性还是有的，一个连接给一个线程池中的线程干活，当业务很多的时候，好几个线程同时需要写日志是很可能的，所以需要来考虑。

2.吞吐量这个指标对于一个日志自系统来说都是很重要的，我们当然需要尽量利用硬盘的读写速度。

### 设计模式 ###

我也查了很多的多路缓冲写日志的相关信息，也问了学长@王伟豪@苗帅，然后还是不晓得怎么搞，大概理解就是开辟缓冲区，然后加锁，当缓冲区到达一定程度的时候执行写文件操作。这样，策略很多，我也是眼花缭乱，我突然想起来之前看过Glibc 的malloc的设计，于是结合着我的需求，我这个多路缓冲日志就应运而生啦。

思路：

开辟几个缓冲区，每个缓冲区均有自己的锁，然后需要写日志的时候，就获取其中的一个锁，写入缓冲区，如果一个线程发现自己写完日志后，正好这个缓冲区满了，那么它就要负责去抢文件的锁，将整个缓冲区一股脑全写进文件里去。

[![AOF][]][AOF]

就是这样，我希望每次来的日志都写进缓冲区去，然后当一个缓冲区满了就去抢写的锁。我们需要尽量将锁的争抢过程放到缓冲区上，文件写锁尽量少发生抢锁的情况，所以我们的缓冲区可以开得大一些。拖延时间，减少文件磁盘IO操作。

### 下面是一些代码和测试结果 ###

class AOF_FILE{
        private:
            int fd;
        public:
            std::mutex mutex_write;
            AOF_FILE();
    };
    
    
    class AOF_LOG{
        private:
            
            char    (*log_data)[AOF_LOG_MAXSIZE];
            AOF_FILE  FILE_WRITE;
            int useful;
                            
        public:
            std::mutex mutex_log;
            AOF_LOG();
            ~AOF_LOG();
            bool AOF_LOG_ADD(const char *mesg,int flag);
            bool WRITE();
    
    };
    
    
    class AOF_LOG_DO{
        private:
            AOF_LOG  aof_buffer[AOF_LOG_AREA];
            int useful;
            int resume;
        public:
            AOF_LOG_DO();
            bool AOF_LOG_add(const char *mesg);
            bool AOF_LOG_enforce_write();
            bool AOF_LOG_READ(char *get);
            int & AOF_LOG_getresume();
    };

AOF_FILE::AOF_FILE(){
        
        fd = 0;
    
    }
    
    /********************************************************/
    
    
    
    AOF_LOG::AOF_LOG(){             /*init  one pice of buffer*/
        
        log_data = new char[AOF_LOG_ELEM][AOF_LOG_MAXSIZE];
        
        useful   = 0;
          
    }
    
    AOF_LOG::~AOF_LOG(){
        
        delete [] log_data;
    
    }
    
    bool AOF_LOG::AOF_LOG_ADD(const char *mesg,int flag){
        
        int length = std::strlen(mesg);
        if(length != flag){
    	    return false;
        }
        bzero(log_data[useful],AOF_LOG_MAXSIZE);
        memcpy(log_data[useful],mesg,AOF_LOG_MAXSIZE);
        useful++;
        if(useful == AOF_LOG_ELEM){
            WRITE();
        }
        return true;
    }
    
    bool AOF_LOG::WRITE(){
        
        while(1){
            if(FILE_WRITE.mutex_write.try_lock()){
                break;
            }
        }
        FILE *fp;
        //fd = open("LOG_AOF.log",O_RDWR|O_APPEND|O_CREAT,777);
        fp = fopen("LOG_AOF.log","ab+");
        if(!fp){
                   
            return false;                                             
        }else{
            for(int i = useful;i > 0;i--){
    	     
                 //write(fd,log_data[i],AOF_LOG_MAXSIZE);
                fwrite(log_data[i],AOF_LOG_MAXSIZE,1,fp);
            }
            useful = 0;
            fclose(fp);
            FILE_WRITE.mutex_write.unlock();
            return true;
        }
    
    
    }
    
    /*******************************************************/
    
    AOF_LOG_DO::AOF_LOG_DO(){
        useful = 0;
    }
    
    
    
    
    bool AOF_LOG_DO::AOF_LOG_add(const char *mesg){
    
        int length = std::strlen(mesg);
        if(length > AOF_LOG_MAXSIZE){
            return false;                         
        }
        int get_mutex = 1;
        while(get_mutex){
            for(int id = 0;id < AOF_LOG_AREA; id++){    
                if(aof_buffer[id].mutex_log.try_lock()){
                    aof_buffer[id].AOF_LOG_ADD(mesg,length); 
                    aof_buffer[id].mutex_log.unlock();
                    get_mutex = 0;
                    break;
                }
            }
        }
    
    }
    
    bool AOF_LOG_DO::AOF_LOG_enforce_write(){    
        for(int i = 0;i < AOF_LOG_AREA;i++){
            while(1){
                if(aof_buffer[i].mutex_log.try_lock()){
                    break;
                }
            }
            aof_buffer[i].WRITE();
            aof_buffer[i].mutex_log.unlock();
            
        }
        return true;
    }
    
    bool AOF_LOG_DO::AOF_LOG_READ(char *get){
        FILE *fp;
        resume = 0;
        fp = fopen("LOG_AOF.log","rb");
        if(!fp){
            return false;
        }else{
            while(fread(get,AOF_LOG_MAXSIZE,1,fp)){
                
                resume++;
                //std::cout << get << std::endl;
            }
        }
        fclose(fp);
    }
    
    int & AOF_LOG_DO::AOF_LOG_getresume(){
        return resume;
    }

### 测试结果 ###

老实说，我也不知道什么样的效果才能算是称职的日志子系统，大家都看看，提提意见，这肯定不是最优的方法。

开4个线程，每个线程写500000（五十万）条日志，总共两百万条日志。

共花费1.9秒，平均每秒100万条日志，100万条日志 大约等于244MB/s.（基本把硬盘都用上了）

以上。

[AOF]: /images/20220731/5823456cfdf048a8b6d5ad5ccf4f1ae2.png