RT-Thread 的环形缓冲区 ---- 镜像指示位

news2025/11/4 11:24:46

可以看一下这篇我写的博客，了解一下大概： 

RingBuffer 环形缓冲区----镜像指示位_呵呵哒(￣▽￣)"的博客-CSDN博客https://blog.csdn.net/weixin_41987016/article/details/132340883?spm=1001.2014.3001.5501

【回顾】缓冲区变满在环形缓冲区（ring buffer）中会实际发生，一般会有两种处理策略：

        🐞① 覆盖老数据

        🐞② 抛出“异常”

镜像指示位：缓冲区的长度如果是n，逻辑地址空间则为0至n-1；那么，规定n至2n-1为镜像逻辑地址空间。本策略规定读写指针的地址空间为0至2n-1，其中低半部分对应于常规的逻辑地址空间，高半部分对应于镜像逻辑地址空间。当指针值大于等于2n时，使其折返（wrapped）到ptr-2n。使用一位表示写指针或读指针是否进入了虚拟的镜像存储区：置位表示进入，不置位表示没进入还在基本存储区。

        在读写指针的值相同情况下，如果二者的指示位相同，说明缓冲区为空；如果二者的指示位不同，说明缓冲区为满。这种方法优点是测试缓冲区满/空很简单；不需要做取余数操作；读写线程可以分别设计专用算法策略，能实现精致的并发控制。缺点是读写指针各需要额外的一位作为指示位。

        如果缓冲区长度是2的幂，则本方法可以省略镜像指示位。如果读写指针的值相等，则缓冲区为空；如果读写指针相差n，则缓冲区为满，这可以用条件表达式（写指针==(读指针异或缓冲区长度)）来判断。

----（来自百度百科）

一、基本步骤

1.数据结构

typedef struct ringbuffer
{
    uint8 *buffer_ptr;
    uint16 read_mirror : 1;
    uint16 read_index : 15;
    uint16 write_mirror : 1;
    uint16 write_index : 15;
    /* as we use msb of index as mirror bit, the size should be signed and
     * could only be positive. */
    uint16 size;
}ringbuff;

 2.缓冲区初始化

// 缓冲区初始化 
void rb_init(ringbuff *rb,uint8 *pool,uint16 size){
    /* initialize read and write index */
    rb->read_mirror = rb->read_index = 0;
    rb->write_mirror = rb->write_index = 0;

    /* set buffer pool and size */
    rb->buffer_ptr = pool;
    rb->size = DATA_ALIGN_DOWN(size, DATA_ALIGN_SIZE);
}

 3.创建一个ringbuffer

// 创建一个ringbuff
ringbuff* rb_create(uint16_t size) {
    ringbuff *rb;
    uint8_t *pool;

    size = DATA_ALIGN_DOWN(size, DATA_ALIGN_SIZE);// 大小做字节对齐

    rb = (ringbuff *)malloc(sizeof(ringbuff));// 申请内存
    if (rb == NULL)
        goto exit;

    pool = (uint8_t *)malloc(size);// 申请数据缓冲区内存
    if (pool == NULL) {
        free(rb);
        rb = NULL;
        goto exit;
    }
    rb_init(rb, pool, size);// 初始化 ringbuff

exit:
    return rb;
}

 4.销毁环形缓冲区

// 摧毁 ringbuff
void rb_destroy(ringbuff *rb) {   
    cout<<"销毁ringbuff~"<<endl;    
    free(rb->buffer_ptr);
    free(rb);// 释放申请的内存
}

二、缓冲区中填充指定数据长度的数据

5. 缓冲区中填充指定数据长度的数据

举个例子：(当缓冲区空间小于待写入的数据长度事覆盖缓冲区原有数据)

图1：当环形缓冲区为空时，读索引和写索引指向相同的位置（这里初始化为0）；

图2：写操作：想往（rb->buffer_size = 8)缓冲区中写入15个元素:123456789ABCDEF，但写入的数据长度（length）超过缓冲区空闲长度（space_length）了。解决方法：RT-Thread（覆盖老数据策略）就是只截取后8位数据放入缓冲区。

可知length=15,space_length=8,满足length > space_length，让ptr = &ptr[length - rb->buffer_size]

图3：由图2的操作可以得到以上的环形缓冲区的数据内容分布

图4：读操作，读取缓冲区4个元素：89AB，修改读索引

图5：写操作，写入缓冲区4个元素：1234，修改写索引

 图6：读操作，读取缓冲区4个元素：CDEF，修改读索引

🐞① 当缓冲区空间小于待写入的数据长度事覆盖缓冲区原有数据

/* 缓冲区中填充指定数据长度的数据(当缓冲区空间小于待写入的数据长度事覆盖缓冲区原有数据) */
uint16 rb_put_force(ringbuff *rb,const uint8 *ptr,uint16 length);
// 强制往 ringbuff 写入数据
uint16 rb_put_force(ringbuff *rb,const uint8 *ptr,uint16 length) {
    uint16 space_length = 0;

    space_length = rb_space_len(rb);
    // cout<<"ptr: "<<ptr<<endl;
    // cout<<"space_length: "<<space_length<<endl;
    // cout<<"length: "<<length<<endl;
    if (length > space_length) { 
        ptr = &ptr[length - rb->size];
        length = rb->size;
    }
    // cout<<"ptr: "<<ptr<<endl;
    // cout<<"length: "<<length<<endl;

    if (rb->size - rb->write_index > length)
    {
        // cout<<"lailailailai"<<endl;
        /* read_index - write_index = empty space */
        memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->write_index += length;

        if (length > space_length)
            rb->read_index = rb->write_index;

        return length;
    }

    memcpy(&rb->buffer_ptr[rb->write_index],
           &ptr[0],
           rb->size - rb->write_index);

    memcpy(&rb->buffer_ptr[0],
           &ptr[rb->size - rb->write_index],
           length - (rb->size - rb->write_index));

    /* we are going into the other side of the mirror */
    rb->write_mirror = ~rb->write_mirror;
    rb->write_index = length - (rb->size - rb->write_index);

    if (length > space_length)
    {
        rb->read_mirror = ~rb->read_mirror;
        rb->read_index = rb->write_index;
    }

    return length;
}

🐞② 当缓冲区空间小于待写入的数据长度事不覆盖缓冲区原有数据

/* 缓冲区中填充指定数据长度的数据(当缓冲区空间小于待写入的数据长度事不覆盖缓冲区原有数据) */
uint16 rb_put(ringbuff *rb,const uint8 *ptr,uint16 length);
// 往 ringbuff 写入数据
uint16 rb_put(ringbuff *rb,const uint8 *ptr,uint16 length) {
    uint16 size = 0;

    /* whether has enough space */
    size = rb_space_len(rb);// 获取 ring_buff 中可用空间的大小

    /* no space */
    if (size == 0)
        return 0;// 如果空间不够 直接返回

    /* drop some data */
    if (size < length) // 如果缓存区的空间不够保存这一次数据， 则把能够写入的这一部分数据写进去
        length = size;
	/* One-time write */
    if (rb->size - rb->write_index > length)
    {
        /* read_index - write_index = empty space */
        memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->write_index += length;
        return length;// 返回写入数据的长度
    }
	/* two-time write */
    memcpy(&rb->buffer_ptr[rb->write_index],
           &ptr[0],
           rb->size - rb->write_index);
    memcpy(&rb->buffer_ptr[0],
           &ptr[rb->size - rb->write_index],
           length - (rb->size - rb->write_index));

    /* we are going into the other side of the mirror */
    rb->write_mirror = ~rb->write_mirror;
    rb->write_index = length - (rb->size - rb->write_index);

    return length;
}

6. 缓冲区中获取指定长度的数据(返回实际获取数据的长度)

/* 缓冲区中获取指定长度的数据(返回实际获取数据的长度) */
uint16 rb_get(ringbuff *rb,uint8 *ptr,uint16 length);
// 从 ringbuff 获取数据
uint16 rb_get(ringbuff *rb,uint8 *ptr,uint16 length) {
    uint16 size = 0;

    /* The length of the existing data in the buffer */
    size = rb_data_len(rb);

    /* no data */
    if (size == 0)
        return 0;

    /* less data */
    if (size < length)
        length = size;
    
    cout<<"size: "<<size<<" < "<<"length: " << length<<(size < length)<<endl;

    if (rb->size - rb->read_index > length)
    {
        /* copy all of data */
        memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->read_index += length;
        return length;
    }

    memcpy(&ptr[0],
           &rb->buffer_ptr[rb->read_index],
           rb->size - rb->read_index);
    memcpy(&ptr[rb->size - rb->read_index],
           &rb->buffer_ptr[0],
           length - (rb->size - rb->read_index));

    /* we are going into the other side of the mirror */
    rb->read_mirror = ~rb->read_mirror;
    rb->read_index = length - (rb->size - rb->read_index);

    return length;
}

7.测试和打印

void readprint(ringbuff* rb,uint8 buff[]) {
    cout<<"读取数据：";
    int i = 0;
    while(buff[i]!='\0') {
        cout<<buff[i++];
    }
    print(rb);
}

void writeprint(ringbuff* rb){
    for(int i=0;i<rb->size;i++){
        cout<<rb->buffer_ptr[i];
    }
    print(rb);
}

void test01() {
    ringbuff* rb = rb_create(9);

    const uint8 p[] = "123456789ABCDEF";
    uint32_t len = sizeof(p) / sizeof(char);
    
    cout<<"写入数据："<<p<<endl;
    // rb_put(rb,p,len-1);
    rb_put_force(rb,p,len-1); 
    writeprint(rb);                       // 89ABCDEF

    uint8 saveBuff[20] = "";
    rb_get(rb,saveBuff,4);   // 89AB
    readprint(rb,saveBuff);
    
    const uint8 p1[] = "1234";
    cout<<"写入数据："<<p1<<endl;
    rb_put_force(rb,p1,4);    // 1234CDEF
    writeprint(rb);

    memset(saveBuff,0,20);
    rb_get(rb,saveBuff,4);   // CDEF
    
    cout<<"读取数据：";
    readprint(rb,saveBuff);

    // 销毁ringbuff
    rb_destroy(rb);
}
写入数据：123456789ABCDEF
89ABCDEF
rb->write_index: 0
rb->read_index: 0
rb->write_mirror: 1
rb->read_mirror: 0
rb_data_len: 8
rb_space_len: 0

size: 8 < length: 40
读取数据：89AB
rb->write_index: 0
rb->read_index: 4
rb->write_mirror: 1
rb->read_mirror: 0
rb_data_len: 4
rb_space_len: 4

写入数据：1234
1234CDEF
rb->write_index: 4
rb->read_index: 4
rb->write_mirror: 1
rb->read_mirror: 0
rb_data_len: 8
rb_space_len: 0

size: 8 < length: 40
读取数据：读取数据：CDEF
rb->write_index: 4
rb->read_index: 0
rb->write_mirror: 1
rb->read_mirror: 1
rb_data_len: 4
rb_space_len: 4

销毁ringbuff~

三、缓冲区中填充一个数据

5. 缓冲区中填充一个数据

举个例子：(当缓冲区空间小于待写入的数据长度事覆盖缓冲区原有数据)

图1：依次存入1、2、3、4、5、6、7、8、A、B、C、D、E、F这些字符，直到缓冲区为满

图2：依次读出单个字符: 8、9、A、B

🐞① 当缓冲区空间小于待写入的数据长度事覆盖缓冲区原有数据

/* 缓冲区中填充一个数据(当缓冲区空间小于待写入的数据长度事覆盖缓冲区原有数据) */
uint16 rb_putchar_force(ringbuff *rb, const uint8 ch);
// 往 ringbuff 强制写入一个字符
uint16 rb_putchar_force(ringbuff *rb, const uint8 ch) {
    enum rb_state old_state = rb_status(rb);// 获取状态
    rb->buffer_ptr[rb->write_index] = ch;// 写入数据
    /* flip mirror */
    if (rb->write_index == rb->size-1) {// 检查当前镜像是不是满了
        rb->write_mirror = ~rb->write_mirror; // 翻转写镜像
        rb->write_index = 0;// 翻转之后设置下标为 0
        if (old_state == RINGBUFFER_FULL) {// 如果 ringbuff 的状态是满
            rb->read_mirror = ~rb->read_mirror; // 翻转读镜像
            rb->read_index = rb->write_index; // 设置读下标和写下标一致
        }
    }else{
        rb->write_index++; // 写下标加1
        if (old_state == RINGBUFFER_FULL)
            rb->read_index = rb->write_index;// 如果满，设置读下标等于写下标
    }
    return 1; // 写入一个字符，返回1
}

🐞② 当缓冲区空间小于待写入的数据长度事不覆盖缓冲区原有数据

/* 缓冲区中填充一个数据(当缓冲区空间小于待写入的数据长度事不覆盖缓冲区原有数据) */
uint16 rb_putchar(ringbuff *rb, const uint8 ch);
// 往 ringbuff 中写入一个字符
uint16 rb_putchar(ringbuff *rb, const uint8 ch) {
    /* whether has enough space */
    if (!rb_space_len(rb)) // 没有足够的空间就直接返回了
        return 0;
    rb->buffer_ptr[rb->write_index] = ch;// 把这个字符写入到缓冲区的指定位置
    /* flip mirror */
    if (rb->write_index == rb->size-1) {// 检查写入这个字符后，当前镜像是否写满
        rb->write_mirror = ~rb->write_mirror;// 翻转镜像
        rb->write_index = 0;// 设置下标为0
    }else{
        rb->write_index++; // 下标加1
    }
    return 1;// 写入一个字符，返回 1
}

6. 缓冲区中获取一个数据(返回实际获取数据的长度)

/* 缓冲区中获取一个数据(返回实际获取数据的长度) */
uint16 rb_getchar(ringbuff *rb, uint8 *ch);
// 从ringbuff 获取一个字符
uint16 rb_getchar(ringbuff *rb,uint8 *ch) {
    /* ringbuffer is empty */
    if (!rb_data_len(rb)) // 检查 ringbuff 是否为空
        return 0;
    /* put character */
    *ch = rb->buffer_ptr[rb->read_index];// 获取当前读下标的数据
    if (rb->read_index == rb->size-1) {// 如果当前镜像满了
        rb->read_mirror = ~rb->read_mirror;// 翻转镜像
        rb->read_index = 0; // 设置读数据的下标为0
    } else {
        rb->read_index++; // 下标加1
    }

    return 1;// 读取一个字节，返回1
}

7.测试和打印

#include "rb.h"
#include "rb.cpp"
void print(ringbuff *rb) {
    cout<<endl;
    cout<<"rb->write_index: "<<rb->write_index<<endl;
    cout<<"rb->read_index: "<<rb->read_index<<endl;
    cout<<"rb->write_mirror: "<<rb->write_mirror<<endl;
    cout<<"rb->read_mirror: "<<rb->read_mirror<<endl;
    cout<<"rb_data_len: "<<rb_data_len(rb)<<endl;
    cout<<"rb_space_len: "<<rb_space_len(rb)<<endl;
    cout<<endl;
}

void writeprint(ringbuff* rb){
    for(int i=0;i<rb->size;i++){
        cout<<rb->buffer_ptr[i];
    }
    print(rb);
}

void test02() {
    ringbuff* rb = rb_create(9);
    cout<<"rb->size: "<<rb->size<<endl;
    const uint8 p[] = "123456789ABCDEF";
    uint32_t len = sizeof(p) / sizeof(char);
    // cout<<len<<endl;
    cout<<"写入数据："<<p<<endl;
    for(int i=0;i<len-1;i++) {
        // rb_putchar(rb,p[i]); 
        rb_putchar_force(rb,p[i]); 
    }
    writeprint(rb); // 9ABCDEF8                      

    uint8 singlechar = ' ';
    for(int i=0;i<4;i++) {
        rb_getchar(rb,&singlechar);
        cout<<"读单个字符: "<<singlechar<<endl;
    }
    print(rb);

    // 销毁ringbuff
    rb_destroy(rb);
}
rb->size: 8
写入数据：123456789ABCDEF
9ABCDEF8
rb->write_index: 7
rb->read_index: 7
rb->write_mirror: 1
rb->read_mirror: 0
rb_data_len: 8
rb_space_len: 0

读单个字符: 8
读单个字符: 9
读单个字符: A
读单个字符: B

rb->write_index: 7
rb->read_index: 3
rb->write_mirror: 1
rb->read_mirror: 1
rb_data_len: 4
rb_space_len: 4

销毁ringbuff~

四、RT-Thread🦥小结

来自此文总结：ring buffer，一篇文章讲透它？ - 知乎 (zhihu.com)

🦝 在多线程中，对同一个环形缓冲区进行读写操作时，需要加上锁，不然存在访问不安全问题；

🦝 当只有一个读线程和一个写线程时，用rb_put和rb_get进行读写操作缓冲区是线程安全的，无需加锁；但是rb_put_force不行，因为其可能对读写索引都进行操作的场景，这个时候再进行rb_get读操作，就是不安全访问；

🦝 读写指针已经在读写(rb_get和rb_put)过程中转换为了读写索引。所以read_index(读索引)和write_index(写索引)可以直接用来操作缓冲区，无需转换；

🦝 read_index 和write_index 的大小区间为[0,n−1]，n为缓冲区大小；

🦝 RT-Thread的环形缓冲区不需要buffer大小为2的幂。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/903767.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Git的正确使用姿势与最佳实践：团队协作和版本控制的最佳实践

Git的正确使用姿势与最佳实践：团队协作和版本控制的最佳实践

Git是一个版本控制系统&#xff0c;用于跟踪和管理软件开发项目中的代码变更。它可以追踪文件的修改、添加和删除&#xff0c;并记录这些变更的历史。Git可以帮助团队成员协同开发&#xff0c;并提供了一种有效的方式来处理并发编辑和代码合并。 在这篇文章中&#xff0c;我们将…
阅读更多...
大数据-玩转数据-Flink

大数据-玩转数据-Flink

一、说明 在电商网站中&#xff0c;订单的支付作为直接与营销收入挂钩的一环&#xff0c;在业务流程中非常重要。对于订单而言&#xff0c;为了正确控制业务流程&#xff0c;也为了增加用户的支付意愿&#xff0c;网站一般会设置一个支付失效时间&#xff0c;超过一段时间不支…
阅读更多...
大数据从入门到放弃——浅谈数据架构的前世今生

大数据从入门到放弃——浅谈数据架构的前世今生

文章目录 1. 背景2. 数据的定义及分类2.1 数据的定义2.2 数据的分类2.3 数据和信息的区别 3. 数据的作用4. 数据的那些美好时代4.1 人脑时代4.2 文件时代4.3 数据库时代4.3.1 大服务器时代4.3.2 读写分离时代4.4 数据库的分布式时代4.5 云端时代 5. 数据的未来 1. 背景 随着云时…
阅读更多...
excel 核心快捷键用法

excel 核心快捷键用法

1、wps怎样只复制公示计算出来的数据 1.1、按下快捷键“CtrlC”&#xff0c;复制该单元格。 1.2、按下快捷键“ShiftCtrlV”&#xff0c;即“粘贴为数值”&#xff0c;即可只复制数字而不复制该单元格的公式 1.3、wps怎样只复制公示计算出来的数据_百度知道https://zhidao.baid…
阅读更多...
【福建事业单位-综合基础知识】05民法典

【福建事业单位-综合基础知识】05民法典

这里写自定义目录标题 一、民法概述概念原则总结 二、自然人概念总结 三、民事法律行为总结 民法考察2-4题&#xff08;重点总则篇&#xff09; 一、民法概述 概念原则 总结 二、自然人 概念 总结 三、民事法律行为 总结
阅读更多...
【python】正则表达式

【python】正则表达式

本文介绍正则表达式常用的用法。 有哪些正则字符 正则表达式中有各种各样的正则字符&#xff0c;用于匹配不同情况下的字符串。具体如下&#xff1a; 使用 re 模块进行字符串匹配 比如&#xff0c;我们要从 ‘Xiaoshuaib has 100 bananas’ 中匹配一个数字&#xff0c;可…
阅读更多...
在线SHA计算哈希(不可逆的加密又称摘要)工具

在线SHA计算哈希(不可逆的加密又称摘要)工具

具体可前往: 在线计算SHA摘要工具
阅读更多...
Zoho Books的安全性和数据保护：财务信息安全的保障措施揭秘

Zoho Books的安全性和数据保护：财务信息安全的保障措施揭秘

在信息化时代&#xff0c;如何保障企业信息安全是十分重要的问题&#xff0c;尤其是财务信息。财务管理工具的安全性是否有保障是许多用户担心的问题。 Zoho Books财务管理工具为客户提供了一系列的数据保护和安全措施&#xff0c;以确保客户财务信息的安全。 1. 采用高度加密…
阅读更多...
漏洞指北-VluFocus靶场专栏-工具篇

漏洞指北-VluFocus靶场专栏-工具篇

漏洞指北-VluFocus靶场专栏-番外篇奇技淫巧 &#x1f338;1、burp suite 、中国蚁剑工具、Strut2扫描软件地址&#x1f338;&#x1f338;2、burp suite使用&#x1f338;step1 浏览器开启代理&#xff0c;**推荐使用&#xff1a;SwitchyOmega** step2 确认浏览器端口和burp su…
阅读更多...
LeetCode 542. 01 Matrix【多源BFS】中等

LeetCode 542. 01 Matrix【多源BFS】中等

本文属于「征服LeetCode」系列文章之一&#xff0c;这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁&#xff0c;本系列将至少持续到刷完所有无锁题之日为止&#xff1b;由于LeetCode还在不断地创建新题&#xff0c;本系列的终止日期可能是永远。在这一系列刷题文章…
阅读更多...
栈空间和栈帧

栈空间和栈帧

如图所示&#xff0c;栈空间是每个线程私有的&#xff0c;其中每个方法有一个栈帧&#xff0c;里面保存了局部变量 返回地址等信息。 如果是多线程&#xff0c;每个线程都会有一个栈空间。 多线程切换的时候需要保存局部变量、当前的地址等信息。 线程上下文切换的时机&…
阅读更多...
mybatis入门Idea搭建

mybatis入门Idea搭建

一、概念 1、什么是mybatis&#xff1f; MyBatis是一个开源的Java持久层框架&#xff0c;它提供了一种简化数据库访问的方式。它的主要作用是将Java对象与数据库表之间进行映射&#xff0c;使开发者可以通过面向对象的方式操作数据库&#xff0c;而不需要编写大量的SQL语句。M…
阅读更多...
线性代数的学习和整理5： 矩阵的加减乘除及其几何意义(未完成，建设ing)

线性代数的学习和整理5： 矩阵的加减乘除及其几何意义(未完成，建设ing)

目录 1 矩阵加法 1.1 矩阵加法的定义 1.2 加法的属性 1.2.1 只有同类型&#xff0c;相同n*m的矩阵才可以相加 1.2.1 矩阵加法的可交换律&#xff1a; 1.2.2 矩阵加法的可结合律&#xff1a; 1.3矩阵加法的几何意义 2 矩阵的减法 2.1 矩阵减法定义和原理基本同 矩阵的…
阅读更多...
前端学习记录~2023.8.3~JavaScript重难点实例精讲～第5章 DOM与事件

前端学习记录~2023.8.3~JavaScript重难点实例精讲～第5章 DOM与事件

第 5 章 DOM与事件 前言5.1 DOM选择器5.1.1 传统原生JavaScript选择器&#xff08;1&#xff09;通过id定位&#xff08;2&#xff09;通过class定位&#xff08;3&#xff09;通过name属性定位&#xff08;4&#xff09;通过标签名定位 5.1.2 新型的querySelector选择器和quer…
阅读更多...
虚拟内存机制1

虚拟内存机制1

虚拟内存机制 计算机的存储系统 为什么要有虚拟内存&#xff1f; 在早期的计算机中&#xff0c;是没有虚拟内存的概念的。我们要运行一个程序&#xff0c;会把程序全部装入内存&#xff0c;然后运行。当运行多个程序时&#xff0c;经常会出现以下问题&#xff1a; 进程地址空…
阅读更多...
2022年国考行政执法卷-判断推理

2022年国考行政执法卷-判断推理

去掉重复题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 类比推理 例题 例题 例题 例题 例题 例题
阅读更多...
【汇编语言】CS、IP寄存器

【汇编语言】CS、IP寄存器

文章目录 修改CS、IP的指令转移指令jmp问题分析 修改CS、IP的指令 理论&#xff1a;CPU执行何处的指令&#xff0c;取决于CS:IP应用&#xff1a;程序员可以通过改变CS、IP中的内容&#xff0c;进行控制CPU即将要执行的目标指令&#xff1b;问题&#xff1a;如何改变CS、IP中的…
阅读更多...
go: go.mod file not found in current directory or any parent directory.

go: go.mod file not found in current directory or any parent directory.

go version go 1.20.7 go 1.17 以后都是用 go install 命令 D:\Go\bin\go.exe get -u github.com/nsf/gocode D:\Go\bin\go.exe get -u golang.org/x/tools/cmd/guru D:\Go\bin\go.exe get -u github.com/rogpeppe/godef>> Running: D:\Go\bin\go.exe get -u github.com…
阅读更多...
Kubernetes_Scheduler_资源调度

Kubernetes_Scheduler_资源调度

文章目录 一、前言二、k8s 资源模型2.1 Node 资源抽象2.1.1 Capacity2.1.2 Allocatable2.1.3 Allocated 2.2 Node 资源切分&#xff08;预留&#xff09;2.2.1 SystemReserved2.2.2 KubeReserved2.2.3 EvictionThreshold&#xff08;驱逐门限&#xff09;2.2.4 Allocatable 2.3…
阅读更多...
二叉树搜索

二叉树搜索

✅<1>主页&#xff1a;我的代码爱吃辣&#x1f4c3;<2>知识讲解&#xff1a;数据结构——二叉搜索树☂️<3>开发环境 &#xff1a;Visual Studio 2022&#x1f4ac;<4>前言&#xff1a;在之前的我们已经学过了普通二叉树&#xff0c;了解了基本的二叉树…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023