算术运算指令

ADD

• 编码格式：R-type， 寄存器类型
  • opcode：0110011
• 符号拓展：最高位(符号位)为1，零扩展：最高位(符号位)为0
• 有符号数在计算机中表示：二进制补码
• 补码→原码：减一取反

SUB

ADDI

• 编码格式：I-type，立即数格式
  • opcode：0b0010011
• 缺陷：
  • immediate立即数占12位
  • 参与运算时会被符号拓展为一个32位的数
  • 这个立即数表示的范围为[-2048, 2047)
  • RISCV没有提供subi指令
• 问题：如何构造大数，一个32位的数
  • 思路：
    • 引入一个新的命令先设置高20位，存放在rs1
    • 然后复用现有的addi命令补上剩余的低12位即可
    • [LUI指令](#LUI(Lod Upper Immediate))

基于算术运算指令实现的其他伪指令

LUI(Lod Upper Immediate)

• 编码格式：U-type

  • opcode：0b0110111

• lui指令构造一个32bits的立即数，这个立即数的高20位对应指令中的imm，低12位清零。这个立即数作为结果存放在rd中

• 利用lui+addi来为寄存器加载一个大数：

  • 0x12345678

    • lui x1, 0x12345

      addi x1, x1, 0x678

  • 特殊情况：0x12345FFF：0xFFF是个负数，直接用addi是错误的

    • lui x1, 0x12346

      addi x1, x1, -1

LI

• li是一个伪指令
• 汇编器会根据imm的实际情况自动生成正确的真实指令
• 用来代替lui

AUIPC

• 编码格式：U-type
  • 和lui指令类似，auipc指令构造一个32bits的立即数，这个立即数高20位对应指令中的imm，低12位清零。不同的是auipc会先将这个立即数和pc值相加，将相加的结果放入rd中
• 用于构造相对地址：相对PC值

LA(Load Address)

• LA是一个伪指令
• 具体编程时给出需要加载的label，编译器会根据实际情况利用auipc和其他指令自动生成正确的指令序列
• 常用于加载一个函数或变量地址

逻辑运算指令

• 逻辑指令都是按位操作
• xor(异或)：相同为0，相异为1

这里-1表示为16进制就是 0xFFFFFFFF，在和RS中的值异或，就达到取反的目的

移位运算指令

逻辑移位

• 逻辑左移、逻辑右移都是补0

算术移位

• 算术右移时按照符号位值填充
• 算术移位只有右移，没有左移：左移会把符号位移走，就没意义了
• 算术移位可以作为负数除法

内存读写指令

• 内存读指令：Load，将数据从内存读入寄存器
• 内存写指令：Store，将数据从寄存器写出内存

内存读（Load）

//TODO

exercises

ch3 编译与链接

练习3-1

使⽤ gcc 编译代码并使⽤ binutils ⼯具对⽣成的⽬标文件和可执⾏文件（ELF 格式）进⾏分析。具体要求如下：

• 编写⼀个简单的打印 “hello world！” 的程序源文件：hello.c

  1 2 3 4 5 6 7

  #include <stdio.h> int main(void) { printf("hello world!\n"); return 0; }

• 对源文件进⾏本地编译，⽣成针对⽀持 x86_64 指令集架构处理器的⽬标文件 hello.o。

  1	gcc hello.c -c -o hello.o

  补充gcc常用选项：

  gcc [options] [filename]

  常用选项	含义
  -E	只做预处理
  -c	只编译不连接，生成目标文件”.o”
  -S	生成汇编代码
  -o file	把输出生成到由file指定文件名的文件中
  -g	在输出的文件中加入支持调试的信息
  -v	显示输出详细的命令执行过程信息

• 查看 hello.o 的文件的文件头信息。

  1	readelf -h hell.o

  信息如下：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  ELF 头： Magic： 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 类别: ELF64 数据: 2 补码，小端序 (little endian) Version: 1 (current) OS/ABI: UNIX - System V ABI 版本: 0 类型: REL (可重定位文件) 系统架构: Advanced Micro Devices X86-64 版本: 0x1 入口点地址： 0x0 程序头起点： 0 (bytes into file) Start of section headers: 792 (bytes into file) 标志： 0x0 Size of this header: 64 (bytes) Size of program headers: 0 (bytes) Number of program headers: 0 Size of section headers: 64 (bytes) Number of section headers: 14 Section header string table index: 13

• 查看 hello.o 的 Section header table。

  1	readelf -SW hello.c

  信息如下：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  There are 14 section headers, starting at offset 0x318: 节头： [Nr] Name Type Address Off Size ES Flg Lk Inf Al [ 0] NULL 0000000000000000 000000 000000 00 0 0 0 [ 1] .text PROGBITS 0000000000000000 000040 00001b 00 AX 0 0 1 [ 2] .rela.text RELA 0000000000000000 000258 000030 18 I 11 1 8 [ 3] .data PROGBITS 0000000000000000 00005b 000000 00 WA 0 0 1 [ 4] .bss NOBITS 0000000000000000 00005b 000000 00 WA 0 0 1 [ 5] .rodata PROGBITS 0000000000000000 00005b 00000d 00 A 0 0 1 [ 6] .comment PROGBITS 0000000000000000 000068 00002b 01 MS 0 0 1 [ 7] .note.GNU-stack PROGBITS 0000000000000000 000093 000000 00 0 0 1 [ 8] .note.gnu.property NOTE 0000000000000000 000098 000020 00 A 0 0 8 [ 9] .eh_frame PROGBITS 0000000000000000 0000b8 000038 00 A 0 0 8 [10] .rela.eh_frame RELA 0000000000000000 000288 000018 18 I 11 9 8 [11] .symtab SYMTAB 0000000000000000 0000f0 000138 18 12 10 8 [12] .strtab STRTAB 0000000000000000 000228 000029 00 0 0 1 [13] .shstrtab STRTAB 0000000000000000 0002a0 000074 00 0 0 1 Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings), I (info), L (link order), O (extra OS processing required), G (group), T (TLS), C (compressed), x (unknown), o (OS specific), E (exclude), l (large), p (processor specific)

• 对 hello.o 反汇编，并查看 hello.c 的 C 程序源码和机器指令的对应关系。

  1	objdump -S hello.o

  反汇编：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  hello.o： 文件格式 elf64-x86-64 Disassembly of section .text: 0000000000000000 <main>: #include <stdio.h> int main(void) { 0: f3 0f 1e fa endbr64 4: 55 push %rbp 5: 48 89 e5 mov %rsp,%rbp printf("hello world!\n"); 8: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # f <main+0xf> f: e8 00 00 00 00 callq 14 <main+0x14> return 0; 14: b8 00 00 00 00 mov $0x0,%eax 19: 5d pop %rbp 1a: c3 retq

练习3-2

如下例⼦ C 语⾔代码：

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int global_init = 0x11111111;
const int global_const = 0x22222222;
void main()
{
    static int static_var = 0x33333333;
    static int static_var_uninit;
    int auto_var = 0x44444444;
    printf("hello world!\n");
    return;
}

请问编译为 .o 文件后，global_init, global_const, static_var, static_var_uninit, auto_var 这些变 量分别存放在那些 section ⾥，”hello world!\n” 这个字符串⼜在哪⾥？并尝试⽤⼯具查看并验证你的猜测。

• global_init ——-> .data

• global_const ——-> .data .rodata

• static_var ——-> .data

• static_var_uninit ——-> .bss

• auto_var ——-> 栈区 .text

  使用objdump -s -x -d test.o可以得到以下信息

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  SYMBOL TABLE: 0000000000000000 l df *ABS* 0000000000000000 test.c 0000000000000000 l d .text 0000000000000000 .text 0000000000000000 l d .data 0000000000000000 .data 0000000000000000 l d .bss 0000000000000000 .bss 0000000000000000 l d .rodata 0000000000000000 .rodata 0000000000000000 l O .bss 0000000000000004 static_var_uninit.2318 0000000000000004 l O .data 0000000000000004 static_var.2317 0000000000000000 l d .note.GNU-stack 0000000000000000 .note.GNU-stack 0000000000000000 l d .note.gnu.property 0000000000000000 .note.gnu.property 0000000000000000 l d .eh_frame 0000000000000000 .eh_frame 0000000000000000 l d .comment 0000000000000000 .comment 0000000000000000 g O .data 0000000000000004 global_init 0000000000000000 g O .rodata 0000000000000004 global_const 0000000000000000 g F .text 0000000000000022 main 0000000000000000 *UND* 0000000000000000 _GLOBAL_OFFSET_TABLE_ 0000000000000000 *UND* 0000000000000000 puts

ch4 嵌入式开发介绍

练习4-1

熟悉交叉编译概念，使⽤ riscv gcc 编译代码并使⽤ binutils ⼯具对⽣成的⽬标文件和可执⾏文件（ELF 格式） 进⾏分析。具体要求如下：

• 编写⼀个简单的打印”hello world!”的程序源文件hello.c

  1 2 3 4 5 6 7 8

  #include <stdio.h> int main(void) { printf("hello world!\n"); return 0; }

• 对源文件进⾏编译，⽣成针对⽀持 rv32ima 指令集架构处理器的⽬标文件hello.o。

  1	riscv64-unknown-elf-gcc -march=rv32ima -mabi=ilp32 -c hello.c

  2022-08-13补充:

  Ubuntu20.04系统直接apt install搭建的环境，编译这个练习会报错:

  编译命令:

  1	/usr/bin/riscv64-unknown-elf-gcc -march=rv32ima -mabi=ilp32 -c hello.c

  报错：

  1 2 3 4

  hello.c:1:10: fatal error: stdio.h: No such file or directory 1 | #include <stdio.h> | ^~~~~~~~~ compilation terminated.

  根据仓库[issue](stdio.h 头文件找不到 · Issue #I4D6N9 · unicornx/riscv-operating-system-mooc - Gitee.com)可以知道这是工具链的问题，解决方法很简单，根据[howto-run-with-ubuntu1804_zh.md](howto-run-with-ubuntu1804_zh.md · unicornx/riscv-operating-system-mooc - 码云 - 开源中国 (gitee.com))搭建环境即可，这个应该是不挑Ubuntu版本的，我在Ubuntu20.04上已经没问题

• 查看hello.o的文件的文件头信息。

  1	readelf -h hello.o

  信息如下：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  ELF 头： Magic： 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 类别: ELF32 数据: 2 补码，小端序 (little endian) Version: 1 (current) OS/ABI: UNIX - System V ABI 版本: 0 类型: REL (可重定位文件) 系统架构: RISC-V 版本: 0x1 入口点地址： 0x0 程序头起点： 0 (bytes into file) Start of section headers: 556 (bytes into file) 标志： 0x0 Size of this header: 52 (bytes) Size of program headers: 0 (bytes) Number of program headers: 0 Size of section headers: 40 (bytes) Number of section headers: 11 Section header string table index: 10

• 查看 hello.o 的 Section header table。

  1	readelf -S hello.o

  信息如下：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  There are 11 section headers, starting at offset 0x22c: 节头： [Nr] Name Type Addr Off Size ES Flg Lk Inf Al [ 0] NULL 00000000 000000 000000 00 0 0 0 [ 1] .text PROGBITS 00000000 000034 000038 00 AX 0 0 4 [ 2] .rela.text RELA 00000000 000190 000048 0c I 8 1 4 [ 3] .data PROGBITS 00000000 00006c 000000 00 WA 0 0 1 [ 4] .bss NOBITS 00000000 00006c 000000 00 WA 0 0 1 [ 5] .rodata PROGBITS 00000000 00006c 00000d 00 A 0 0 4 [ 6] .comment PROGBITS 00000000 000079 000029 01 MS 0 0 1 [ 7] .riscv.attributes RISCV_ATTRIBUTE 00000000 0000a2 000026 00 0 0 1 [ 8] .symtab SYMTAB 00000000 0000c8 0000b0 10 9 9 4 [ 9] .strtab STRTAB 00000000 000178 000018 00 0 0 1 [10] .shstrtab STRTAB 00000000 0001d8 000054 00 0 0 1 Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings), I (info), L (link order), O (extra OS processing required), G (group), T (TLS), C (compressed), x (unknown), o (OS specific), E (exclude), p (processor specific)

• 对hello.o 反汇编，并查看 hello.c 的 C 程序源码和机器指令的对应关系。

  注意：直接使用objdump不行，因为不支持riscv架构。

  2022-08-13补充:

  提示如下:

  1 2	hello.o： 文件格式 elf32-little objdump: can't disassemble for architecture UNKNOWN!

  所以使用以下命令:

  1	riscv64-unknown-elf-objdump -S hello.o

  信息如下：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  hello.o： 文件格式 elf32-littleriscv Disassembly of section .text: 00000000 <main>: 0: ff010113 addi sp,sp,-16 4: 00112623 sw ra,12(sp) 8: 00812423 sw s0,8(sp) c: 01010413 addi s0,sp,16 10: 000007b7 lui a5,0x0 14: 00078513 mv a0,a5 18: 00000097 auipc ra,0x0 1c: 000080e7 jalr ra # 18 <main+0x18> 20: 00000793 li a5,0 24: 00078513 mv a0,a5 28: 00c12083 lw ra,12(sp) 2c: 00812403 lw s0,8(sp) 30: 01010113 addi sp,sp,16 34: 00008067 ret

练习4-2

基于 练习 4-1 继续熟悉 qemu/gdb 等⼯具的使⽤，具体要求如下：

• 将 hello.c 编译成可调式版本的可执⾏程序 a.out

  1	riscv64-unknown-elf-gcc -g -march=rv32ima -mabi=ilp32 hello.c

• 先执⾏ qemu-riscv32 运⾏ a.out。

  1	qemu-riscv32 ./a.out

  可以看到控制台输出以下内容：

  1	hello world!

• 使⽤ qemu-riscv32 和 gdb 调试 a.out。

  这里会用到两个终端，一个终端打开qemu并同时监听1234端口；一个终端打开gdb，连接1234端口，步骤如下：

  • 在终端1，使用qemu-riscv32 -g 1234 a.out

  • 这时在终端2，使用riscv64-unknown-elf-gdb直接进入gdb(不要使用默认的gdb，不支持rv32)

    • 随后在gdb中使用set architecture riscv:rv32设置架构
    • 然后设置断点(因为只有hello world一行代码)，b hello.c:5
    • 最后使用target remote localhost:1234连接qemu

  • 这时终端2会显示

    1 2 3 4

    Remote debugging using localhost:1234 warning: No executable has been specified and target does not support determining executable automatically. Try using the "file" command. 0x00010090 in ?? ()

    这是因为我们设置了断点，想运行的话按r或者c

  • 最后在终端一可以看到hello world!

  

练习4-3

• ⾃学 Makefile 的语法，理解在 riscv-operating-system-mooc 仓库的根⽬录下执⾏ make 会发⽣什么。

  Makefile学习

ch5 RISC-V汇编语言编程

练习5-1

• 对 code/asm/sub 执⾏反汇编，查看 sub x5, x6, x7 这条汇编指令对应的机器指令的编码，并对照 RISC-V 的 specificaion ⾃⼰解析该条指令的编码。

  • 使用make hex可查看二进制编码

    1 2	00000000 13 03 f0 ff 93 03 e0 ff b3 02 73 40 6f 00 00 00 |..........s@o...| 00000010

    由于指令是四字节对齐的，所以可以知道b3 02 73 40是sub x5,x6,x7对应的16进制编码，并且是小端序，所以可以分析出该指令值为0x407302b3，同时可以使用make code进行求证

  • 针对0x407302b3可以先转成二进制：01000000-01110011-00000010-10110011

    

    该图可知，指令的低7位可以确定指令类型，该指令低7位：0110011，分析得出该指令属于OP，R-Type类型

  • 接下来可以查看funct3与funct7，funct3在1214位，funct7在2531位

    可以得到funct3为000，funct7为0100000

    

  • opcode、funct3、funct7可以确定指令了

    

  • 寄存器由上图可知：rd为711，rs1为1518，rs2为20~24，分析可知：rd=00101→x5；rs1=00110→x6；rs2=00111→x7

• 现知道某条 RISC-V 的机器指令在内存中的值为 b3 05 95 00，从左往右为从低地址到⾼地址，单位为 字节，请将其翻译为对应的汇编指令。

  • 该值化为易读形式：0x009505b3，再化为二进制：00000000-10010101-00000101-10110011

  • 首先分析opcode：0110011，为OP，R-Type类型

  • 然后分析funct3、funct7：分别为000,0000000，结合opcode，分析得出该指令为add指令

  • 随后分析寄存器：rd=01011→x11，rs1=01010→x10，rs2=01001→x9

  • 最后该指令为：add x11,x10,x9

  • 可以写代码验证：

    

练习5-2

假设有如下这么一段C语言程序代码，尝试写一段汇编代码，达到等效的结果，并采用gdb调试查看执行结果，注意请使用寄存器来存放变量的值：

1
2
3
4
5
6

register int a, b, c, d, e;
b = 1;
c = 2;
e = 3;
a = b + c;
d = a - e;

• 首先定义变量使用了register，意为将变量保存在寄存器中，和“注意”里边的相照应

• 汇编代码：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  .text .global _start _start: li x5, 1 # b = 1 li x6, 2 # c = 2 li x7, 3 # e = 3 add x9, x5, x6 # x9 = x5 + x6 # a = b + c sub x10, x9, x7 stop: j stop .end

• 直接make && make debug就可以得到如下结果（gdbinit中display了x5到x11寄存器）

  1 2 3 4 5 6 7 8 9

  stop () at test.s:19 19 j stop => 0x80000014 <stop+0>: 6f 00 00 00 j 0x80000014 <stop> 1: /z $x5 = 0x00000001 2: /z $x6 = 0x00000002 3: /z $x7 = 0x00000003 4: /z $x9 = 0x00000003 5: /z $x10 = 0x00000000 6: /z $x11 = 0x87e00000

练习5-3

假设有如下这么一段C语言程序代码，尝试写一段汇编代码，达到等效的结果，并采用gdb调试查看执行结果，注意请使用寄存器来存放变量的值：

1
2
3
4
5
6

register int a, b, c, d, e;
b = 1;
c = 2;
d = 3;
e = 4;
a = (b + c) - (d + e);

• 本练习和练习5-2差不多，不过是运算稍复杂

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  .text .global _start _start: li x1, 1 # b = 1 li x2, 2 # c = 2 li x3, 3 # d = 3 li x4, 4 # e = 4 add x1, x1, x2 add x3, x3, x4 sub x5, x1, x3 stop: j stop .end

• 不过上述代码最后输出结果如下，x5为0xfffffffc，x5为-4，而负数在计算机中使用补码表示，可以计算一下它的原码：减一然后按位取反

  • 减一：0xfffffffb，二进制：1111 1111 1111 1111 1111 1111 1111 1011
  • 取反：0x00000004，二进制：0000 0000 0000 0000 0000 0000 0000 0100

  1 2 3 4 5 6 7 8 9 10 11

  Breakpoint 1, stop () at test.s:23 23 j stop => 0x8000001c <stop+0>: 6f 00 00 00 j 0x8000001c <stop> 1: /z $x1 = 0x00000003 2: /z $x2 = 0x00000002 3: /z $x3 = 0x00000007 4: /z $x4 = 0x00000004 5: /z $x5 = 0xfffffffc 6: /z $x6 = 0x00000000 7: /z $x7 = 0x00000000 (gdb)

练习5-4

给定一个32位数0x87654321，先编写c程序，将其低16位(0x4321)和高16位(0x8765)分别分离出来保存到独立变量中；完成后在尝试采用汇编语言实现类似效果

通过逻辑左右移就可以了

• C语言

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  #include<stdio.h> void foo() { unsigned int i = 0x87654321; unsigned int high = i >> 16; unsigned int low = (i << 16)>>16; printf("i = 0x%x\n" "high = 0x%x\n" "low = 0x%x\n", i, high, low); } int main(void) { foo(); return 1; }

• RISC-V汇编

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  # exercise 5-4 .text .global _start _start: li x1, 0x87654321 srli x2, x1, 16 slli x3, x1, 16 srli x3, x3, 16 stop: j stop .end

练习7-1

要求：完全采用汇编语言重写01-helloRVOS, 运行后在控制台打印输出”Hello, RVOS!”

• 字符数组这儿，即代码中的.data后边的内容放在目前位置没问题，先前放在_start前边就G了，具体原因待排查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

#include "platform.h"
.data
    array:
        .byte 'H', 'e', 'l', 'l', 'o', ',', 'R', 'V', 'O', 'S', '!', 0
        .space 12
    # size of each hart's stack is 1024 bytes
    .equ    STACK_SIZE, 1024
    .global _start

    .text

    .macro uart_read_reg reg1, reg2
        lb \reg1, 0(\reg2)
    .endm

    .macro uart_write_reg reg1, v
        sb \v, 0(\reg1)
    .endm

_start:
    csrr t0, mhartid    # 读Hart id
    mv tp, t0
    bnez   t0, park

    slli t0, t0, 10     #t0 向左移动10位, 1024
    la sp, stacks + STACK_SIZE

    add sp, sp, t0; #  把sp移动到Hart对应的栈的栈顶位置上

    li s0, 0x10000000

    j start_kernel
    

park:
    wfi
    j park

stacks:
    .skip STACK_SIZE * MAXNUM_CPU

start_kernel:
    # prologue
    addi sp, sp, -8; # sp = sp + -8
    sw ra, 0(sp) # 

    call uart_init

    la a0, array

    call uart_puts

uart_init:
    addi sp, sp, -20

    addi s1, s0, 0x01
    uart_write_reg s1, zero # uart_write_reg(IER, 0x00);
                            # sb \v, 0(\reg1)

    addi s1, s0, 0x03            # uint8_t lcr = uart_read_reg(LCR);
    uart_read_reg s2, s1    # lb \reg1, 0(\reg2)

    slli s2, s2, 7          # uart_write_reg(LCR, lcr | (1 << 7));
    uart_write_reg s1, s2   

    li s2, 0x03             # uart_write_reg(DLL, 0x03);
    uart_write_reg s0, s2 

    addi s1, s0, 0x01       # uart_write_reg(DLM, 0x00);
    li s2, 0x00
    uart_write_reg s1, s2
    
    addi s1, s0, 0x03       # uart_write_reg(LCR, lcr | (3 << 0));
    li s2, 0x03
    uart_write_reg s1, s2

    addi sp, sp, 20
    ret

uart_puts:
    addi sp, sp, -12; # sp = sp + -12
    sw s1, 0(sp)
    sw s2, 4(sp)
    sw ra, 8(sp)

    mv s1, a0
loop:
    lbu a0, 0(s1)
    mv s2, a0
    addi s1, s1, 1; # a0 = a0 + 1
    jal uart_putc  # jump to uart_puts and save position to ra
    bnez s2, loop

    lw s1, 0(sp) # 
    lw s2, 4(sp) # 
    lw ra, 8(sp) # 
    addi sp, sp, 12; # sp = sp + 12
    ret

uart_putc:
    addi sp, sp, -8; # sp = sp + -8
    sw s1, 0(sp)
    sw s2, 4(sp) # 
    
    addi s1, s0, 5; # s1 = s0 + 5
    uart_read_reg s2, s1
check:
    andi s2, s2, 32; # s2 = s2 & 32
    beqz s2, check

    uart_write_reg s0, a0 

    lw s1, 0(sp) # 
    lw s2, 4(sp) # 
    addi sp, sp, 8; # sp = sp + 8
    ret

    .end

练习7-2

要求：参考01-helloRVOS，在此基础上采用轮询方式读取控制台上输入的字符并回显在控制台上。另外用户按下回车后能够另起一行从头开始

为节省篇幅，只记录修改部分

• 纯单片机编辑，读写寄存器就完事。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/* kernel.c */
#include "types.h"
#include "platform.h"

extern void uart_init(void);
extern void uart_puts(char *s);
extern int uart_putc(char ch);
extern char uart_getc(void);

void start_kernel(void)
{
    uart_init();
    uart_puts("hello, RVOS!\n");
    while (1)
    {
        uint8_t ch = uart_getc();
        if (ch == '\r')
        {
            uart_puts("\r\n");
        }
        uart_putc(ch);
    }
    
}

1
2
3
4
5
6

/* uart.c */
char uart_getc(void)
{
    while ((uart_read_reg(LSR) & LSR_RX_READY) == 0){}
    return uart_read_reg(RHR);
}

1
2
3
4
5
6
7
8

target:prerequisites #目标:依赖的文件或者其他目标
cmd_1
cmd_2
cmd_3

.PHONY:clean#伪目标
clean:
cmd

Makefile变量、模式匹配

变量

• 系统变量

  1 2 3 4 5 6 7 8 9 10 11 12

  .PHONY: all all: echo "$(CC)" echo "$(AS)" echo "$(MAKE)" #输出结果 #echo "cc" #cc #echo "as" #as #echo "make" #make

• 自定义变量

  • =，延迟赋值（引用此变量的时候才赋值）

    1 2 3 4 5 6 7 8

    A=123 B=$(A) A=456 .PHONY: all all: echo "$(B)" #输出结果 #456

• :=，立即赋值

  1 2 3 4 5 6 7 8

  A=123 B:=$(A) A=456 .PHONY: all all: echo "$(B)" #输出结果 #123

• ?=，空赋值（变量为空的时候才有效）

  1 2 3 4 5 6 7 8

  A?=123 #B:=$(A) A?=456 .PHONY: all all: echo "$(A)" #输出结果 #123

• +=，追加赋值（不会改变变量的值）

  1 2 3 4 5 6 7 8

  A?=123 #B:=$(A) A+=456 .PHONY: all all: echo "$(A)" #输出结果 #123 456

• 自动化变量

  • $<，第一个依赖文件

  • $^，全部的依赖文件

  • $@，目标

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

    all:targeta targetb echo "$<" echo "$^" echo "$@" targeta: targetb: #输出结果 #echo "targeta" #targeta #echo "targeta targetb" #targeta targetb #echo "all" #all

模式匹配

%，匹配任意多个非空字符

类似于shell的*通配符

1
2

%:
echo "$@"

默认规则

.o文件默认使用.c文件编译

Makefile条件分支

1
2
3
4
5

ifeq(var1,var2)
....
else
....
endif

1
2
3
4
5

ifneq(var1,var2)
....
else
....
endif

Makefile常用函数

patsubst

模式替换函数

1
2
3

.PHONY:all
all:
echo "$(patsubst %.c,%.o,x.c.c bar.c)"

把字串“x.c.c bar.c”中以.c 结尾的单词替换成以.o 结尾的字符。函数的返回结果 是“x.c.o bar.o”

notdir

取文件名函数

1
2
3

.PHONY:all
all:
echo "$(notdir src/foo.c hacks)"

返回值为：“foo.c hacks”

wildcard

获取匹配模式文件名函数

1
2
3

.PHONY:all
all:
echo "$(wildcard *.c)"

返回值为当前目录下所有.c 源文件列表

foreach

函数“foreach”不同于其它函数。它是一个循环函数。类似于 Linux 的 shell 中的 for 语句

1
2
3
4
5
6
7

dirs := a b c d 
files := $(foreach dir,$(dirs),$(wildcard $(dir)/*))

.PHONY:all
all:
echo "$(files)"

把文件夹里边的文件全部找出来

Makefile解决头文件依赖

1. 写一个头文件，并把头文件添加到编译器的头文件的路径
2. 实时检查头文件的更新情况，一旦头文件发生变化，应该重新编译所有相关文件

较为完善的Makefile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

ARCH?=x86
ifeq ($(ARCH),x86)
CC=gcc
else 
CC=arm-linux-gnueabihf-gcc
endif

TARGET=mp3
BUILD_DIR=build
SRC_DIR=module1 module2
INC_DIR=include
CFLAGS=$(patsubst %,-I%,$(INC_DIR))

INCLUDE= $(foreach dir,$(INC_DIR),$(wildcard $(dir)/*.h))
SOURCES=  $(foreach dir,$(SRC_DIR),$(wildcard $(dir)/*.c))
OBJS=$(patsubst %.c,$(BUILD_DIR)/%.o,$(notdir $(SOURCES)))
VPATH=$(SRC_DIR)


$(BUILD_DIR)/$(TARGET):$(OBJS)
$(CC) $^ -o $@ $(CFLAGS)

$(BUILD_DIR)/%.o:%.c $(INCLUDE) | create_build
$(CC) -c $< -o $@

.PHONY:create_build
create_build:
mkdir -p $(BUILD_DIR)

.PHONY:clean
clean:
rm -rf $(BUILD_DIR)

select系统调用的用途是：在一段时间内，监听多个文件描述符上的可读、可写和异常等事件。

1
2
3
4

#include <sys/time.h>         /* For portability */ 
#include <sys/select.h> 

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

• nfds 被监听文件描述符的总和(readfds + writefds + exceptfds)
• readfds、writefds、exceptfds分别指向可读、可写、异常事件对应的文件描述符集合
• timeout 超时时间

  •       ==0，检查一遍文件描述符状态立即返回；

  • == NULL 或者 非零值，会一直阻塞直到：

    •                          三种fds中有至少一个文件描述符进入ready状态

    •                        被信号处理中断

    •                        到达指定的超时时间

各个层级协议

C/S、B/S模型优缺点

网络传输流程

数据没有封装之前，是不能在网络中传递

数据-应用层-传输层-网络层-链路层 网络环境

协议简介

• 以太网帧协议

  • ARP：根据IP地址获取mac地址
  • 以太网帧协议：根据MAC地址，完成数据包传输

• IP协议

  • 版本：IPv4、IPv6

  • TTL

    • time to live
    • 设置数据包在路由节点中的跳转上限。每经过一个路由 节点，该值-1，减为0的路由有义务将该数据包丢弃

  • 源IP：32位 — 4字节 192.168.1.108—点分十进制

  • 目的IP：32位—-4字节

    IP地址可以在网络环境中唯一标识一台主机

    端口号：可以在网络的一台主机上，唯一的标识一个进程

    IP地址+端口号：唯一标识一个进程

• UDP

  • 16位源端口号
  • 16位目的端口号

• TCP

  • 16位源端口号
  • 16位目的端口号
  • 32位序号
  • 32确认序号
  • 6个标志位
  • 16位窗口大小 2^16=65536

网络套接字

• 小端法(本地字节序)

  • 高位高地址、低位低地址

  • int a = 0x12345678

    • 

• 大端法(网络字节序)

  • 高位低地址、低位高地址

• htonl –> 本地 –> 网络(IP)

• htons –> 本地 –> 网络(port)

• ntohl –> 网络(IP) –> 本地

• ntohs –> 网络(port) –> 本地

IP地址转换

• int inet_pton(int af, const char *src, void *dst);

  • 本地字节序转换为网络字节序
  • af：AF_INET、AF_INET6
  • src：IP地址(点分十进制)
  • dst：传出：转换后的网络字节序 IP地址
  • 返回值：
    • 成功返回 1
    • 异常返回 0，说明src指向的不是一个有效的ip地址
    • 失败返回 -1

• const char *inet_ntop(int af, const void *src,char *dst, socklen_t size);

  • 本地字节序转换为网络字节序

  • af：AF_INET、AF_INET6

  • src：网络字节序IP地址

  • dst：本地字节序

  • size：dst的大小

  • 返回值：

    • 成功返回 dst
    • 失败返回 NULL

sockaddr地址结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

struct sockaddr_in addr；

addr.sin_family = AF_INET;

addr.sin_port = htons(8080);

int dst;

inet_pton(AF_INET,"127.0.0.1",(void *)&dst);

addr.sin_addr.s_addr = dst;

addr.sin_addr.s_addr = htonl(INADDR_ANY);

bind(fd,(struct sockaddr*)&addr,size);

socket模型穿件流程图

一个服务端和一个客户端建立通信一共三个套接字

服务端、客户端

• 服务端：

  • bind()绑定ip+port

- listen()设置同时监听上限- accept()阻塞监听客户端连接

• 客户端：
  • connect()绑定ip+port

套接字函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#include <sys/socket.h>

int socket(int domain, int type, int protocol); 
/**
*创建一个套接字
*domain: AF_INET、AF_INET6、AF_UNIX
*type：SOCK_STREAM、SOCK_DGRAM
*protocol：0
*返回值：
*成功：新套接字所对应的文件描述符
*失败：-1 errno
**/

int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
/**
*给socket绑定一个地址结构
*sockfd：socket函数返回值
*struct sockaddr_in addr;
*addr.sin_family = AF_INET;
*addr.sin_port = htons(8888);
*addr.sin_addr.s_addr = htonl(INADDR_ANY);
*addr：传入参数(struct sockaddr*)&address
*addrlen:sizeof(addr) 地址结构的大小
*返回值：
*成功：0
*失败：-1 error
**/

int listen(int sockfd, int backlog); 
/**
*设置同时与服务器建立连接的上线数(同时进行3次握手 的客服端数量)
*sockfd：socket函数返回值
*backlog：上限的值
*返回值：
*成功：0
*失败： -1 error
**/

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
/**
*阻塞等待客服端建立连接，成功返回一个与客户端成功连接的socket文件描述符
*sockfd：socket函数返回值
*addr：传出参数。成功与服务器建立连接的那个客服端的地址结构
*addrlen：&client_addr_len。传入传出。入：addr的大小，出：客服端addr的实际大小
*socket_t client_addr_len = sizeof(addr);
*返回值：
*成功：能与服务器进行数据通信的socket对应的文件描述符
*失败：-1 error
**/

 int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
/**
*使用现有socket与服务器建立连接
*sockfd：socket函数返回值
*addr：传入参数。服务器的地址结构(struct sockaddr*)&address
*addrlen：sizeof(addr) 服务器地址结构的大小
*返回值：
*成功：0
*失败： -1 error
* 如果不使用bind()函数绑定客户端地质结构，采用"隐式绑定"。
**/

TCP通信流程分析

TCP协议

• 三次握手

  • 主动发起连接请求端，发送 SYN 标志位，请求建立连接。携带数据包包号、数据字节数(0)、滑动窗口大小。
  • 被动接受连接请求端，发送 ACK 标志位，同时携带 SYN 请求标志位。携带序号、确认序号、数据字节数(0)、滑动窗口大小。
  • 主动发起连接请求端，发送 ACK 标志位，应答服务器连接请求。携带序号、确认序号

• 

• 四次挥手

  • 主动关闭连接请求端，发送 FIN 标志位。
  • 被动关闭连接请求端，应答 ACK 标志位。 —–半关闭完成
  • 被动关闭连接请求端，发送 FIN 标志位。
  • 主动关闭连接请求端，应答 ACK 标志位 。——连接全部关闭

• 滑动窗口
  • 发送给连接对端，本段缓冲区实时大小，保证数据不会丢失

TCP状态时序图

1. 主动发起连接请求端：CLOSE — 发送SYN — SYN_SEND — 接收ACK、SYN — SYN_SEND — 发送方ACK — ESTABLISHED(数据通信状态)

2. 主动关闭连接请求端：ESTABLISHED(数据通信状态) — 发送FIN — FIN_WAIT_1— 接收ACK — FIN_WAIT_2 — 接收对端发送的FIN — FIN_WAIT_2 — 回发ACK — TIME_WAIT(只有主动关闭连接方，会经历该状态) — 等2MSL时长 — CLOSED

3. 被动接收连接请求端：CLOSE — LISTEN — 接收SYN — LISTEN — 发送ACK、SYN — SYN_RCVD — 接收ACK — ESTABLISHED

4. 被动关闭连接请求端：ESTABLISHED—接收对端FIN — ESTABLISHED — 发送ACK — CLOSE_WAIT(说明对端(主动关闭连接端)处于半关闭状态) — 发送FIN — LAST_ACK — 接收ACK — CLOSE

重点记忆： ESTABLISHED、FIN_WAIT_2 、CLOSE_WAIT、TIME_WAIT(2MSL时长)

2MSL时长

一定出现在主动关闭连接请求一端

保证，最后一个ACK能被成功接收。(等待期间，对端没有接收到ACK，对端会再次发送FIN请求)

端口复用

1
2

int opt = 1; //设置端口复用
setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,(void *)&opt,sizeof(opt));

半关闭

通信双方只有一端关闭通信。——FIN_WAIT_2(半关闭状态)

close(cfd);

1
2
3
4
5

int shutdown(itn fd, int how)
/**    how:SHUT_RD 关闭读
 *       SHUT_WR关闭写
 *       SHUT_RDWR关闭读写
**/

区别：

• shutdown在关闭多个文件描述符应用的文件时，采用全关闭的方法，close只关闭一个

错误处理函数

封装目的

• 在server.c编程过程中突出裸机，将出错处理与逻辑分开，可以直接跳转man手册

wrap.c

• 存放网络信相关常用　自定义函数
• 命名方式：
  • 系统调用函数首字母大写 方便查看man手册。如：Listen()、Accept()
• 函数功能：调用系统调用函数，处理出错场景
• 在server.c 和 client.c 中调用 自定义函数
  • server.c 和 wrap.c 生成 server
  • client.c 和 wrap.c 生成 client

wrap.h

• 存放 网络通信相关常用 自定义函数原神(声明)

高并发服务器

多进程并发服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Socket();//创建监听套接字 lfd
Bind();//绑定地址结构 
Listen();//设置监听上限
while(1)
{
    cfd = Accpet();//接收客户端连接请求
    pid = fork();//
    
    if(pid == 0)//子进程read()-->小写转大写-->write(cfd)
    {
        close(lfd);//关闭用于建立连接的套接字
        read();
        upper();
        write();
    }else if(pid > 0)
    {
        close(cfd);//关闭用于与客户端通信的套接字 cfd

        contiue;
    }
}

• 子进程

  • close(lfd); //关闭用于建立连接的套接字
  • read();
  • upper();
  • write();

• 父进程

  • 注册信号捕捉函数：SIGCHLD

  • 在回调函数中，完成子进程回收

    ​ while ( waitpid());

多线程并发服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Socket();//创建监听套接字 lfd
Bind();//绑定地址结构 
Listen();//设置监听上限
while(1)
{
    cfd = Accpet();//接收客户端连接请求
    pthread_create(&tid, NULL,tfn,NULL);
    pthread_detach(tid);
}

//子线程
void *tfn(void *arg)
{
    close(lfd);
read(cfd);
    upper();
    write(cfd);
    pthread_exit((void*)10);
}

read函数返回值

1. 大于0 实际读到的字节数
2. 等于0 已经读到结尾(对端已经关闭)【重点】
3. -1 应该进一步判断errno的值
   1. errno= EAGAIN or EWOULDBLOCK：设置了非阻塞方式读。没有数据到达
   2. errno= EINTR 慢速系统调用被 中断
   3. errno= “其他情况” 异常。

select多路IO转接

• 原理：借助内核，select来监听，客户端连接、数据通 信事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

/**
 * 清空一个文件描述符集合
 * fd_set rset;
 * FD_ZERO(&rset);
**/
void FD_ZERO(fd_set *set);

/**
 * 将监听的文件描述符，添加到集合中
 * FD_SET(3,&rset);FD_SET(4,&rset);FD_SET(5,&rset);
**/
void FD_SET(int fd,fd_set*set);

/**
* 将一个文件描述符从监听集合中删除
* FD_CLR(4,&rset);
**/
void FD_CLR(int fd,fd_set *set);


/**
 * 判断一个文件描述符是否在监听集合中
 * FD_ISSET(4,&rset);
 * 返回值：在：1；不在：0;
**/
int FD_ISSET(int fd,fd_set *set);


/**
 * 判断一个文件描述符是否在监听集合中
 * nfds: 监听的所有文件描述符中，最大文件描述符+1
 * readfds:读  文件描述符监听集合  传入传出参数
 * writefds: 写  文件描述符监听集合传入传出参数NULL
 * exceptfds: 异常  文件描述符监听集合传入传出参数NULL
 * timeout:>0: 设置监听超时时长
 NULL: 阻塞监听
 0:非阻塞监听,轮询
 * 返回值:
 >0:所有监听 集合中，满足对应事件的总数。
  0:没有满足监听条件的文件描述符
 -1:errno
**/
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);

思路分析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

lfd = socket();  //创建套接字
bind();//绑定地址结构
listen();//设置监听上限

fd_set rset,allset;//创建r监听集合
FD_ZERO(&allset);//将监听r集合清空
FD_SET(lfd,&allset);//将lfd添加至读集合中

while(1)
{
    rset = allset;//保存监听集合
    ret = select(lfd+1,&rset,NULL,NULL,NULL); //监听文件描述符集合对应事件
    if(ret>0){//有监听的描述符满足对应事件
        if(FD_ISSET(lfd,&rset))
        {
            cfd = accept();//建立连接，返回用于通信的文件描述符
            FD_SET(cfd,&allset);//添加到监听通信描述符集合中
        }
        for(i=lfd+1;i<=最大文件描述符;i++)
        {
            FD_ISSET(i,&rset);
            read();
            小---大
            write();
        }
}   
}

C++版本的线程池是根据C语言版本修改来的，为了熟悉一下C++的相关语法，所以就有了这篇笔记。记录一下修改的过程中遇到的问题。

本线程池是基于对象的，并不是面向对象。

[线程池简单实现(基于C语言)](Linux C线程池简单实现 | Blog (ethereal14.github.io))

• 也不知道会不会有内存泄露的问题，这些事以后再说

文件说明

线程池对象设计

基本就是把原来的结构体改成现在的class，把变量定义在private里。把工作线程定义为静态成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class threadpool
{
private:
    pthread_mutex_t m_lock;
    pthread_cond_t m_notify;
    pthread_t *m_threads;
    threadpool_task *m_queue;

    int m_thread_count;
    int m_queue_size;
    int m_head;
    int m_tail;
    int m_count;
    int m_shutdown;
    int m_started;

private:
    static void *threadpool_thread(void *arg);

public:
    threadpool(int thread_count, int queue_size, int flags);
    ~threadpool();

    int threadpool_add(threadpool *pool, void (*function)(void *), void *argument, int flag);
    int threadpoolexit(threadpool *pool, int flag);
};

任务队列对象

如上，仅仅把struct改为class

1
2
3
4
5
6
7
8

class threadpool_task
{
public:
    void (*function)(void *);
    void *argument;
    threadpool_task();
    ~threadpool_task();
};

各种枚举类型

• 不知道能不能把这些枚举类型放在class里边，以后有空研究

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

typedef enum
{
    threadpool_invalid = -1,
    threadpool_lock_failure = -2,
    threadpool_queue_full = -3,
    threadpool_shutdown = -4,
    threadpool_thread_failure = -5
} threadpool_terror_t;

typedef enum
{
    immediate_shutdown = 1, //自动关闭
    graceful_shutdown = 2   //立即关闭
} threadpool_shutdown_t;

typedef enum
{
    threadpool_graceful = 1
} threadpool_destroy_flags_t;

线程池构造函数

• 这里遇到个问题：构造函数是没有返回值的，所以不能把原来的创建线程池函数照搬过来。
  • 使用do while结构来进行构造

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

threadpool::threadpool(int thread_count = 32, int queue_size = 256, int flags = 0) : m_queue_size(queue_size)
{
    do
    {
        if (thread_count <= 0 || thread_count > MAX_THREADS || queue_size <= 0 || queue_size > MAX_QUEUE)
        {
            std::cout << "argument eeror" << std::endl;
            break;
        }

        this->m_thread_count = 0;
        //this->m_queue_size = queue_size;
        this->m_head = this->m_tail = this->m_count = 0;
        this->m_shutdown = this->m_started = 0;

        this->m_threads = new pthread_t[thread_count];
        this->m_queue = new threadpool_task[queue_size];

        if ((pthread_mutex_init(&this->m_lock, nullptr) != 0) ||
            (pthread_cond_init(&this->m_notify, NULL) != 0) ||
            (this->m_threads == nullptr) || (this->m_queue == nullptr))
        {
            std::cout << "init eeror" << std::endl;
            break;
        }

        for (size_t i = 0; i < thread_count; i++)
        {
            if (pthread_create(&this->m_threads[i], nullptr, threadpool_thread, this) != 0)
            {
                std::cout << "create " << i << " thread error" << std::endl;
                break;
            }
            this->m_thread_count++;
            this->m_started++;
        }

    } while (0);
}

线程池析构函数

析构函数把一些资源释放了就行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

threadpool::~threadpool()
{
    if (this == NULL || this->m_started > 0)
    {
        exit(-1);
    }
    if (this->m_threads)
    {
        delete[] this->m_threads;
        delete[] this->m_queue;

        pthread_mutex_lock(&(this->m_lock));
        pthread_mutex_destroy(&(this->m_lock));
        pthread_cond_destroy(&(this->m_notify));
    }
    //delete[] this;
}

以下函数基本没啥变化

添加任务函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

int threadpool::threadpool_add(threadpool *pool, void (*function)(void *), void *argument, int flag)
{
    int err = 0, next;

    if (pool == nullptr || function == nullptr)
        return threadpool_invalid;
    if (pthread_mutex_lock(&(pool->m_lock)) != 0)
    {
        return threadpool_lock_failure;
    }

    next = pool->m_tail + 1;

    next = (next == pool->m_queue_size) ? 0 : next;

    do
    {
        if (pool->m_count == pool->m_queue_size)
        {
            err = threadpool_queue_full;
            break;
        }
        pool->m_queue[pool->m_tail].function = function;
        pool->m_queue[pool->m_tail].argument = argument;

        pool->m_tail = next;
        pool->m_count++;

        if (pthread_cond_signal(&(pool->m_notify)) != 0)
        {
            err = threadpool_lock_failure;
            break;
        }

    } while (0);

    if (pthread_mutex_unlock(&(pool->m_lock)) != 0)
    {
        err = threadpool_lock_failure;
    }

    return err;
}

线程退出函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

int threadpool::threadpoolexit(threadpool *pool, int flag)
{
    int i, err = 0;

    if (pool == nullptr)
        return threadpool_invalid;

    if (pthread_mutex_lock(&(pool->m_lock)) != 0)
        return threadpool_lock_failure;

    do
    {
        if (pool->m_shutdown)
        {
            err = threadpool_shutdown;
            break;
        }
        pool->m_shutdown = (flag & threadpool_graceful) ? graceful_shutdown : immediate_shutdown;

        if ((pthread_cond_broadcast(&(pool->m_notify)) != 0) || (pthread_mutex_unlock(&(pool->m_lock)) != 0))
        {
            err = threadpool_lock_failure;
            break;
        }

        for (size_t i = 0; i < pool->m_thread_count; i++)
        {
            if (pthread_join(pool->m_threads[i], nullptr) != 0)
                err = threadpool_thread_failure;
        }

    } while (0);

    return err;
}

工作线程函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

void *threadpool::threadpool_thread(void *arg)
{
    threadpool *pool = static_cast<threadpool *>(arg);
    threadpool_task task;

    for (;;)
    {
        pthread_mutex_lock(&(pool->m_lock));
        while ((pool->m_count == 0) && (!pool->m_shutdown))
        {
            pthread_cond_wait(&(pool->m_notify), &(pool->m_lock));
        }
        if ((pool->m_shutdown == immediate_shutdown) || ((pool->m_shutdown == graceful_shutdown) && (pool->m_count == 0)))
        {
            break;
        }

        task.function = pool->m_queue[pool->m_head].function;
        task.argument = pool->m_queue[pool->m_head].argument;

        pool->m_head++;
        pool->m_head = (pool->m_head == pool->m_queue_size) ? 0 : pool->m_head;
        pool->m_count--;

        pthread_mutex_unlock(&(pool->m_lock));

        // (*(task.function))(task.argument);

        task.function(task.argument);
    }

    pool->m_started--;
    pthread_mutex_unlock(&(pool->m_lock));
    pthread_exit(nullptr);
    return nullptr;
}

最后的测试用例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#include "threadpool.h"
#include <iostream>
#include <pthread.h>
#include <assert.h>
#include <unistd.h>

#define THREAD 32
#define QUEUE 256

int tasks = 0, done = 0;
pthread_mutex_t lock;

void dumy_task(void *arg)
{
    usleep(10000);
    pthread_mutex_lock(&lock);

    done++;
    pthread_mutex_unlock(&lock);
}

int main(int, char **)
{
    threadpool *pool = new threadpool(THREAD, QUEUE, 0);

    pthread_mutex_init(&lock, nullptr);

    std::cout << "pool started with " << THREAD << " threads and queue size of " << QUEUE << std::endl;

    while ((pool->threadpool_add(pool, &dumy_task, nullptr, 0)) == 0)
    {
        pthread_mutex_lock(&lock);
        tasks++;
        pthread_mutex_unlock(&lock);
    }
    std::cout << "add " << tasks << " tasks" << std::endl;

    while ((tasks / 2) > done)
    {
        usleep(10000);
    }
    //pool->threadpoolexit(pool, 0) == 0;
    assert(pool->threadpoolexit(pool, 0) == 0);
    std::cout << "did " << done << " tasks" << std::endl;

    delete[] pool;

    return 0;
}

CMakeLists文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

cmake_minimum_required(VERSION 3.0.0)
project(threadpool_cpp VERSION 0.1.0)

include(CTest)
enable_testing()

add_executable(threadpool_cpp main.cpp threadpool.cpp threadpool.h)

find_package(Threads)
target_link_libraries(threadpool_cpp ${CMAKE_THREAD_LIBS_INIT})

set(CPACK_PROJECT_NAME ${PROJECT_NAME})
set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
include(CPack)

测试效果图

TCP/IP协议族体系结构以及主要协议

四层协议模型：

Linux网络编程基础API

socket地址API

主机字节序和网络字节序

• 大端字节序：高存低，低存高

• 小端字节序：高存高，低存低

• 主机字节序—-小端存储

• 网络字节序—-大端存储

• 一台机器上的两个进程间通信也需要字节序转换(jvm就是大端存储)

• 主机字节序和网络字节序转换API

  1 2 3 4 5

  #include<netinet/in.h> unsigned long int htonl(unsigned long int hostlong); unsigned short int htons(unsigned short int hostshort); unsigned long int ntohl(unsigned long int netlong); unsigned short int ntohs(unsigned short int netshort);

  • 长整型通常用来转换IP地址、短整型用来转换端口号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>

void byteorder()
{
    union
    {
        short value;
        char union_bytes[sizeof(short)];
    } test;

    test.value = 0x0102;
    if ((test.union_bytes[0] == 1) && (test.union_bytes[1] == 2))
    {
        printf("big endian\n");
    }
    else if ((test.union_bytes[0] == 2) && (test.union_bytes[1] == 1))
    {
        printf("little endian\n");
    }
    else
    {
        printf("unknown....\n");
    }
}

int main(int argc, const char **argv)
{

    byteorder();

    return 0;
}

通用socket地址

socket网络编程接口中表示socket地址的是结构体sockaddr，定义如下：

1
2
3
4
5
6
7

#include <bits/socket.h>

struct sockaddr
{
    sa_family_t sa_family;
    char sa_data[14];
}

1. sa_family成员是地址族类型变量。

   协议族	地址族	描述
   PF_UNIX	AF_UNIX	UNIX本地域协议族
   PF_INET	AF_INET	TCP/IPv4协议族
   PF_INET6	AF_INET6	TCP/IPv6协议族

• 宏PF_ 和 AF_都定义在bis/socket.h文件中，两者值完全相同，所以常常混用
• sa_data成员用于存放socket地址值。但是不同的协议族地址值有不同含义和长度

  协议族	地址值含义和长度
  PF_UNIX	文件的路径名，长度可达108字节
  PF_INET	16bit端口号和32bitIPv4地址，共6字节
  PF_INET6	16bit端口号、32bit流标识、128bitIPv6地址，32bit范围ID，共26字节

下边也是通用的socket结构体

1
2
3
4
5
6
7

#include<bits/socket.h>
struct sockaddr_storage
{
    sa_family_t sa_family;
    unsigned long int __ss_align;
    char __ss_padding[128-sizeof(__ss_align)];
}

专用socket地址

通用socket地址不好用，用Linux提供的专用socket地址结构体

1. sockaddr_un 为 本地套接字
2. sockaddr_in 为 ipv4
3. sockaddr_in6 为 ipv6

重点为ipv4：

1
2
3
4
5
6
7
8
9
10

struct sockaddr_in
{
sa_family_t sa_family; //地址族：AF_INET
    u_int16_t sin_port;//端口号，要用网络字节序表示
    struct in_addr sin_addr;//IPv4地址结构体
}
struct in_addr
{
    u_int32_t s_addr;//IPv4地址，要用网络字节序表示
}

所有专用socket地址类型变量在使用的时候都必须强转为sockaddr类型

IP地址转换函数

编程中需要把点分十进制(192.168.1.117)转换成整数(二进制数)

ipv4使用以下函数转换:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <arpa/inet.h>
/**
 *将点分十进制字符串表示的IPv4地址转化为网络字节序整数表示的地址。
 *失败返回INADDR_NONE
**/
in_addr_t inet_addr(const char *strptr);

/**
 *功能和inet_addr一样：将点分十进制字符串表示的IPv4地址转化为网络字节序整数表示的地址。
 * 但是将转化结果存储与参数inp指向的地址结构中
 *成功返回 1
 *失败返回 0
**/
int inet_aton(const* cp,struct in_addr* inp);

/**
 *将网络字节序整数表示的IPv4地址转化为点分十进制字符串表示的地址。
 * 但是将转化结果存储与参数inp指向的地址结构中
 *该函数不可重入
**/
char *inet_ntoa(struct in_addr in);

/**
 *将点分十进制字符串src表示的IP(v4、v6)地址转化为网络字节序整数表示的地址,并把转换结果存储与dst指向的内存中。
 * af：地址族
 * 成功返回 1
 *失败返回 0 errno
**/
int inet_pton(int af,const char*src,void *dst);

/**
 *与inet_pton作相反转换
**/
const char *inet_ntop(int af,const void *src,char *dst,socklen_t cnt);

创建socket(socket函数)

1
2
3
4
5
6
7
8
9

#include <sys/types.h>
#include <sys/socket.h>
/*
* domain:  协议族  PF_INET、PF_INET6、PF_UNIX
* type:  服务类型   SOCK_STREAM、SOCK_DGRAM
* protocol: 0
* 返回值:  成功返回 文件描述符, 失败返回-1, errno
*/
int socket(int domain, int type, int protocol);