• 九、（正点原子）Linux定时器

    一、Linux中断简介

            1、中断号

            每个中断都有一个中断号，通过中断号即可区分不同的中断，有的资料也把中断号叫做中断线。在 Linux 内核中使用一个 int 变量表示中断号。在Linux中，我们可以使用已经编写好的API函数来申请中断号，定义在include/linux/interrupt.h里面。

            ①、设备树中断信息节点

            如果使用设备树的话就需要在设备树中设置好中断属性信息， Linux 内核通过读取设备树
    中 的 中断 属性 信息 来配 置中 断。 对于 中断 控制 器 而言 ，设备树绑定信息参考文档Documentation/devicetree/bindings/arm/gic.txt。打开 imx6ull.dtsi 文件，其中的 intc 节点就是I.MX6ULL 的中断控制器节点，节点内容如下所示：

    1. intc: interrupt-controller@00a01000 {
    2.     compatible = "arm,cortex-a7-gic";
    3.     #interrupt-cells = <3>;
    4.     interrupt-controller;
    5.     reg = <0x00a01000 0x1000>,
    6.           <0x00a02000 0x100>;
    7. };

             Documentation/devicetree/bindings/arm/gic.txt这个文档里面说：

             compatible表示GIC中断控制器对应的型号，我们使用imx6ull属于cortex-A7系列。

            #interrupt-cells 和#address-cells、 #size-cells 一样。表示此中断控制器下设备的 cells大小，对于设备而言，会使用 interrupts 属性描述中断信息， #interrupt-cells 描述了 interrupts 属性的 cells 大小，也就是一条信息有几个 cells。每个 cells 都是 32 位整形值，对于 ARM 处理的GIC 来说，一共有 3 个 cells，这三个 cells 的含义如下：

            第一个 cells：中断类型， 0 表示 SPI（共享） 中断， 1 表示 PPI （私有）中断。
            第二个 cells：中断号，对于 SPI 中断来说中断号的范围为 0~987，对于 PPI 中断来说中断
    号的范围为 0~15。
            第三个 cells：标志， bit[3:0]表示中断触发类型，为 1 的时候表示上升沿触发，为 2 的时候
    表示下降沿触发，为 4 的时候表示高电平触发，为 8 的时候表示低电平触发。 bit[15:8]为 PPI 中
    断的 CPU 掩码。
            第 4 行， interrupt-controller 节点为空，表示当前节点是中断控制器。

            举个例子，比如GPIO，GPIO有可以作为一个中断控制器：

    1. gpio5: gpio@020ac000 {
    2.     compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
    3.     reg = <0x020ac000 0x4000>;
    4.     interrupts = 74 IRQ_TYPE_LEVEL_HIGH>,
    5.                  75 IRQ_TYPE_LEVEL_HIGH>;
    6.     gpio-controller;
    7.     #gpio-cells = <2>;
    8.     interrupt-controller;
    9.     #interrupt-cells = <2>;
    10. };

            interrupts有三个参数，第一个表示中断类型，第二个表示中断号，可以查看参考手册。第三个表示中断触发方式。

            interrupt-controller 表明了 gpio5 节点也是个中断控制器，用于控制 gpio5 所有 IO的中断。
            将#interrupt-cells 修改为 2，我们可以打开gpio5的一个子节点看一下：

    1. fxls8471@1e {
    2.     compatible = "fsl,fxls8471";
    3.     reg = <0x1e>;
    4.     position = <0>;
    5.     interrupt-parent = <&gpio5>;
    6.     interrupts = <0 8>;
    7. };

            可以看到因为interrups属性只有两个值，所以在它的父节点的#interrupt-cells就为2.

    注：我们使用设备树添加中断信息时候，其实我们只需要添加interrupt-parent，指定父中断，也就是中断控制器h和interrupts，指定中断号，触发方式，这两个属性。


            ②、获取设备树中节点的中断号

            编写驱动的时候需要用到中断号，我们用到中断号，中断信息已经写到了设备树里面，因此可以通过 irq_of_parse_and_map 函数从 interupts 属性中提取到对应的设备号，定义在：linux/of_irq.h中函数原型如下：

    extern unsigned int irq_of_parse_and_map(struct device_node *node, int index);

            node：设备节点。

            index：索引号。

            返回值：中断号。 

            如果我们使用中断的引脚属于GPIO中断，我们可以使用gpio_to_irq 函数来获取 gpio 对应的中断号，定义在include/asm/gpio.h下函数原型如下：

    static inline int __gpio_to_irq(unsigned gpio)

            gpio：要获取中断号的gpio编号。

            返回值：gpio对于的中断号。 


     

            ③、request_irq函数

            在 Linux 内核中要想使用某个中断是需要申请的， request_irq 函数用于申请中断， request_irq函数可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码段中使用 request_irq 函数。 request_irq 函数会激活(使能)中断，所以不需要我们手动去使能中断，request_irq 函数原型如下：

    1. static inline int __must_check request_irq(unsigned int irq, irq_handler_t handler,                     
    2.                                            unsigned long flags,const char *name, void *dev)

            irq：要申请中断的中断号。

            handler：中断处理函数，当中断发生以后就会执行此中断处理函数。函数原型：

    typedef irqreturn_t (*irq_handler_t)(int irq, void *dev);

            （irq）：中断处理函数的中断号。

            （dev）：第二个参数是一个指向 void 的指针，也就是个通用指针，需要与 request_irq 函数的 dev 参数保持一致。用于区分共享中断的不同设备，dev 也可以指向设备数据结构。

            （返回值）：一般中断服务函数返回值使用如下形式：

    return IRQ_RETVAL(IRQ_HANDLED)

            flags：中断标志，可以在在文件 include/linux/interrupt.h 里面查看所有的中断标志，此标志可以使用“|”命令来实现多种组和,这里举例常用的中断标志。

    1. #define IRQF_SHARED                 0x00000080    /*多个设备共享一个中断线，共享的所有中断都必须指定此标志。如果使用共享中断的话， request_irq 函数的 dev 参数就是唯一区分他们的标志。 */
    2.  
    3. #define IRQF_TRIGGER_NONE	        0x00000000    /* 无触发 */
    4. #define IRQF_TRIGGER_RISING	        0x00000001    /* 上升沿触发 */
    5. #define IRQF_TRIGGER_FALLING	    0x00000002    /* 下降沿触发 */
    6. #define IRQF_TRIGGER_HIGH	        0x00000004    /* 高电平触发 */
    7. #define IRQF_TRIGGER_LOW	        0x00000008    /* 低电平触发 */
    8. #define IRQF_TRIGGER_MASK	    (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | \
    9. 				                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)

            name：中断的名字，设置申请后可以在/proc/interrupts文件看到对应的中断名字。使用命令cat /proc/interrupts查看。

            dev：如果flags设置为IRQF_SHARED，使用dev来区分不同的中断，一般情况下，将dev设置为设备结构体，dev会传递给中断处理函数的第二个参数。

            返回值：0 中断申请成功，其他负值 中断申请失败，如果返回-EBUSY 的话表示中断已经被申请了。

            ④、free_irq函数

            使用中断的时候需要通过 request_irq 函数申请，使用完成以后就要通过 free_irq 函数释放掉相应的中断。如果中断不是共享的，那么 free_irq 会删除中断处理函数并且禁止中断。 free_irq函数原型如下所示（定义在include/linux/interrupt.h）：

    extern void free_irq(unsigned int irq, void *dev);

             irq：释放的中断号。

            dev：如果中断设置为共享(IRQF_SHARED)的话，此参数用来区分具体的中断。共享中断只有在释放最后中断处理函数的时候才会被禁止掉。

            ⑤、中断使能与禁止函数

            常用的中断使能和禁止函数为（定义在include/linux/interrupt.h）：

    1. /* 定义在linux/interrupt.h */
    2. extern void disable_irq_nosync(unsigned int irq);
    3. extern void disable_irq(unsigned int irq);
    4. extern void enable_irq(unsigned int irq);
    5.  
    6.  
    7. /* 定义在linux/irqflags */
    8. #define local_irq_enable()	        do { raw_local_irq_enable(); } while (0)
    9. #define local_irq_disable()	        do { raw_local_irq_disable(); } while (0)
    10.  
    11. #define local_irq_save(flags)	    do {raw_local_irq_save(flags);} while (0)
    12. #define local_irq_restore(flags)    do { raw_local_irq_restore(flags); } while (0)

            enable_irq和disable_irq 用于使能和禁止指定的中断。disable_irq要等到当前正在执行的中断处理函数执行完才返回,如果我们希望使用时候不需要等待中断处理函数已经全部退出。在这种情况下我们使用disable_irq_nosync函数。

            disable_irq_nosync 函数调用以后立即返回，不会等待当前中断处理程序执行完毕。

            local_irq_enable和local_irq_disable函数关闭全局中断。

            如果现在有两个任务A和B，A任务关闭全局中断10s，2s以后B任务关闭全局中断3s，然后打开全局中断。这时候B任务打开全局中断才过去5sA任务关闭10s全局中断还没到，A任务就会崩溃。为了解决这个问题， B 任务不能直接简单粗暴的通过 local_irq_enable 函数来打开全局中断，而是将中断状态恢复到以前的状态，要考虑到别的任务的感受，此时就要用到下面两个函数：

            local_irq_save、local_irq_restore函数，关闭全局中断时会先将中断的状态保存起来，打开全局中断将以前保存的中断的状态在恢复。

            ⑥、中断示例代码：

    1. 第一步：修改Linux内核设备树信息，添加中断信息。
    2.  
    3. /* 在设备树文件中 */
    4. 节点{
    5.  
    6.     interrupt-parent = <父节点中断>；
    7.     interrups = <硬件对应的gpio或者其他中断引脚号  中断的触发方式 >
    8. }；
    9.  
    10. 第二步：从设备树中获取中断号并向Linux申请中断号
    11.     
    12. /* 初始化文件中 */
    13.     int irqnum = irq_of_parse_and_map(设备树节点, 索引如果属性只有一个就为0);
    14.     request_irq(request_irq(unsigned int irq, irq_handler_t handler,                     
    15.                             unsigned long flags,const char *name, void *dev)；
    16.  
    17. 第三步：建立中断处理函数
    18. 类型：irqreturn_t (*irq_handler_t)(int irq, void *dev);
    19.  
    20. 第四步：删除中断号
    21. free_irq(unsigned int irq, void *dev);

            2、上半部与下半部

            中断号申请成功后，执行中断处理函数。我们都知道在中断中，必须快进快出，不能过多耽误。如果在中断中调用一些函数或者执行语句耽误的时间很多，那么效率就很低下，所以Linux内核引入上半部和下半部，上半部里面处理一些耗时少的，下半部处理耗时多的。

            ①、简介

            上半部：上半部就是中断处理函数，那些处理过程比较快，不会占用很长时间的处理就可以放在上半部完成。
            下半部：如果中断处理过程比较耗时，那么就将这些比较耗时的代码提出来，交给下半部去执行，这样中断处理函数就会快进快出。
            因此， Linux 内核将中断分为上半部和下半部的主要目的就是实现中断处理函数的快进出，那些对时间敏感、执行速度快的操作可以放到中断处理函数中，也就是上半部。剩下的所有工作都可以放到下半部去执行，至于哪些代码属于上半部，哪些代码属于下半部并没有明确的规定，一切根据实际使用情况去判断，这里有一些可以借鉴的参考点：

    •      如果要处理的内容不希望被其他中断打断，那么可以放到上半部
    •      如果要处理的任务与硬件有关，可以放到上半部
    •      如果要处理的任务对时间敏感，可以放到上半部

         上半部处理很简单，直接编写中断处理函数就行了，关键是下半部该怎么做呢？

            ②、处理下半部 

    •         软中断

            一开始Linux 内核提供了“bottom half”机制来实现下半部，简称“BH”。后面引入了软中断和 tasklet 来替代“BH”机制，完全可以使用软中断和 tasklet 来替代 BH，从 2.5 版本的 Linux内核开始 BH 已经被抛弃了。 Linux 内核使用结构体 softirq_action 表示软中断， softirq_action结构体定义在文件 include/linux/interrupt.h 中，内容如下：

    1. struct softirq_action
    2. {
    3. 	void	(*action)(struct softirq_action *);
    4. };

            在kernel/softirq.c中定义了10个软中断 ：

    1. static struct softirq_action softirq_vec[NR_SOFTIRQS]
    2.  
    3. NR_SOFTIRQS:
    4. enum
    5. {
    6. 	HI_SOFTIRQ=0,               /* 高优先级软中断 */
    7. 	TIMER_SOFTIRQ,              /* 定时器软中断 */
    8. 	NET_TX_SOFTIRQ,             /* 网络数据发送软中断 */
    9. 	NET_RX_SOFTIRQ,             /* 网络数据接收软中断 */
    10. 	BLOCK_SOFTIRQ,
    11. 	BLOCK_IOPOLL_SOFTIRQ,
    12. 	TASKLET_SOFTIRQ,            /* tasklet 软中断 */
    13. 	SCHED_SOFTIRQ,              /* 调度软中断 */
    14. 	HRTIMER_SOFTIRQ,            /* 高精度定时器软中断 */
    15. 	RCU_SOFTIRQ,                /* RCU 软中断 */
    16.  
    17. 	NR_SOFTIRQS
    18. };

            softirq_action 结构体中的 action 成员变量就是软中断的服务函数，数组 softirq_vec 是个全局数组，因此所有的 CPU(对于 SMP 系统而言)都可以访问到，每个 CPU 都有自己的触发和控制机制，并且只执行自己所触发的软中断。但是各个 CPU 所执行的软中断服务函数确是相同的，都是数组 softirq_vec 中定义的 action 函数。要使用软中断，必须先使用 open_softirq 函数注册对应的软中断处理函数， open_softirq 函数原型如下：

    extern void open_softirq(int nr, void (*action)(struct softirq_action *));

             nr：要开启的软中断，在kernel/softirq.c中定义了10个软中断。

            action：软中断对应的中断服务函数。

      注：软中断必须在编译的时候静态注册！Linux 内核使用softirq_init函数，来初始化软中断，函数原型： 

    1. void __init softirq_init(void)
    2. {
    3. 	int cpu;
    4.  
    5. 	for_each_possible_cpu(cpu) {
    6. 		per_cpu(tasklet_vec, cpu).tail =
    7. 			&per_cpu(tasklet_vec, cpu).head;
    8. 		per_cpu(tasklet_hi_vec, cpu).tail =
    9. 			&per_cpu(tasklet_hi_vec, cpu).head;
    10. 	}
    11.  
    12. 	open_softirq(TASKLET_SOFTIRQ, tasklet_action);
    13. 	open_softirq(HI_SOFTIRQ, tasklet_hi_action);
    14. }

            可以看到会默认打开tasklet软中断和高精度定时器软中断。 

            注册号软中断后，还需要开启软中断，也叫作触发软中断，使用raise_softirq函数，函数原型如下（定义在kernel/softirq.c）：

    extern void raise_softirq(unsigned int nr);

            nr：要触发的软中断。

    •         tasklet

             tasklet 是利用软中断来实现的另外一种下半部机制，在软中断和 tasklet 之间，建议大家使用 tasklet。 Linux 内核使用 tasklet_struct 结构体来表示 tasklet（定义在linux/interrupt.h）：

    1. struct tasklet_struct
    2. {
    3. 	struct tasklet_struct *next;        /* 下一个 tasklet */
    4. 	unsigned long state;                /* tasklet 状态 */
    5. 	atomic_t count;                     /* 计数器，记录对 tasklet 的引用次数 */
    6. 	void (*func)(unsigned long);        /* tasklet 执行的函数，用户定义 */
    7. 	unsigned long data;                 /* 函数 func 的参数 */
    8. };

             要使用tasklet来处理下半部，先定义一个tasklet，一般定义tasklet都是在设备结构体中定义。然后使用 tasklet_init 函数初始化 tasklet，taskled_init 函数原型如下：

    1. extern void tasklet_init(struct tasklet_struct *t,
    2. 			             void (*func)(unsigned long), unsigned long data);

             t：要初始化的tasklet。

            func：tasklet处理函数。

            data：传递给func函数的参数。

            也可以使用宏DECLARE_TASKLET来一次性完成tasklet的定义和初始化。定义如下：

    1. #define DECLARE_TASKLET(name, func, data) \
    2. struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }

            name：要定义的tasklet的名字。

            func：tasklet处理函数。

            data： 传递给func函数的参数。

            注：tasklet的func处理函数要能够执行，必须在上半部，也就是在中断处理函数中调用tasklet_schedule函数，就能使 tasklet 在合适的时间运行， tasklet_schedule 函数原型如下：

    static inline void tasklet_schedule(struct tasklet_struct *t)

            t：要调度的tasklet，也就是tasklet的名字。 

            ③、使用tasklet的示例代码：

    1. 第一步：先定义一个tasklet并初始化tasklet。
    2. 第二部：在中断处理函数中调度tsklet。
    3. 第三步：tasklet函数处理。
    4. 第四步：删除tasklet。
    5.  
    6.  
    7. /* 定义 taselet */
    8. struct tasklet_struct testtasklet;
    9. /* tasklet 处理函数 */
    10. void testtasklet_func(unsigned long data)
    11. {
    12. /* tasklet 具体处理内容 */
    13. }
    14. /* 中断处理函数 */
    15. irqreturn_t test_handler(int irq, void *dev_id)
    16. {
    17. ......
    18. /* 调度 tasklet */
    19. tasklet_schedule(&testtasklet);
    20. ......
    21. }
    22. /* 驱动入口函数 */
    23. static int __init xxxx_init(void)
    24. {
    25. ......
    26. /* 初始化 tasklet */
    27. tasklet_init(&testtasklet, testtasklet_func, data);
    28. /* 注册中断处理函数 */
    29. request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
    30. ......
    31. }
    • 工作队列

             工作队列是另外一种下半部执行方式，工作队列在进程上下文执行，工作队列将要推后的工作交给一个内核线程去执行，因为工作队列工作在进程上下文，因此工作队列允许睡眠或重新调度。因此如果你要推后的工作可以睡眠那么就可以选择工作队列，否则的话就只能选择软中断或 tasklet。

            Linux 内核使用 work_struct 结构体表示一个工作，定义在（linux/workqueue.h）内容如下：

    1. struct work_struct {
    2. 	atomic_long_t data;
    3. 	struct list_head entry;
    4. 	work_func_t func;            /* 工作队列处理函数 */
    5. #ifdef CONFIG_LOCKDEP
    6. 	struct lockdep_map lockdep_map;
    7. #endif
    8. };

             这些工作组成工作队列，工作队列使用 workqueue_struct 结构体表示，内容如下：

    1. struct workqueue_struct {
    2. 	struct list_head	pwqs;		/* WR: all pwqs of this wq */
    3. 	struct list_head	list;		/* PR: list of all workqueues */
    4.  
    5. 	struct mutex		mutex;		/* protects this wq */
    6. 	int			work_color;	/* WQ: current work color */
    7. 	int			flush_color;	/* WQ: current flush color */
    8. 	atomic_t		nr_pwqs_to_flush; /* flush in progress */
    9. 	struct wq_flusher	*first_flusher;	/* WQ: first flusher */
    10. 	struct list_head	flusher_queue;	/* WQ: flush waiters */
    11. 	struct list_head	flusher_overflow; /* WQ: flush overflow list */
    12.  
    13. 	struct list_head	maydays;	/* MD: pwqs requesting rescue */
    14. 	struct worker		*rescuer;	/* I: rescue worker */
    15.  
    16. 	int			nr_drainers;	/* WQ: drain in progress */
    17. 	int			saved_max_active; /* WQ: saved pwq max_active */
    18.  
    19. 	struct workqueue_attrs	*unbound_attrs;	/* WQ: only for unbound wqs */
    20. 	struct pool_workqueue	*dfl_pwq;	/* WQ: only for unbound wqs */
    21.  
    22. #ifdef CONFIG_SYSFS
    23. 	struct wq_device	*wq_dev;	/* I: for sysfs interface */
    24. #endif
    25. #ifdef CONFIG_LOCKDEP
    26. 	struct lockdep_map	lockdep_map;
    27. #endif
    28. 	char			name[WQ_NAME_LEN]; /* I: workqueue name */
    29.  
    30. 	struct rcu_head		rcu;
    31.  
    32. 	unsigned int		flags ____cacheline_aligned; /* WQ: WQ_* flags */
    33. 	struct pool_workqueue __percpu *cpu_pwqs; /* I: per-cpu pwqs */
    34. 	struct pool_workqueue __rcu *numa_pwq_tbl[]; /* FR: unbound pwqs indexed by node */
    35. };

            Linux 内核使用工作者线程(worker thread)来处理工作队列中的各个工作， Linux 内核使用
    worker 结构体表示工作者线程， worker 结构体内容如下：

    1. struct worker {
    2. 	/* on idle list while idle, on busy hash table while busy */
    3. 	union {
    4. 		struct list_head	entry;	/* L: while idle */
    5. 		struct hlist_node	hentry;	/* L: while busy */
    6. 	};
    7.  
    8. 	struct work_struct	*current_work;	/* L: work being processed */
    9. 	work_func_t		current_func;	/* L: current_work's fn */
    10. 	struct pool_workqueue	*current_pwq; /* L: current_work's pwq */
    11. 	bool			desc_valid;	/* ->desc is valid */
    12. 	struct list_head	scheduled;	/* L: scheduled works */
    13.  
    14. 	/* 64 bytes boundary on 64bit, 32 on 32bit */
    15.  
    16. 	struct task_struct	*task;		/* I: worker task */
    17. 	struct worker_pool	*pool;		/* I: the associated pool */
    18. 						/* L: for rescuers */
    19. 	struct list_head	node;		/* A: anchored at pool->workers */
    20. 						/* A: runs through worker->node */
    21.  
    22. 	unsigned long		last_active;	/* L: last active timestamp */
    23. 	unsigned int		flags;		/* X: flags */
    24. 	int			id;		/* I: worker id */
    25.  
    26.  
    27. 	char			desc[WORKER_DESC_LEN];
    28.  
    29. 	struct workqueue_struct	*rescue_wq;	/* I: the workqueue to rescue */
    30. };

            注：每个 worker 都有一个工作队列，工作者线程处理自己工作队列中的所有工作。在实际的驱动开发中，我们只需要定义工作(work_struct)即可。

            简单创建工作很简单，直接定义一个 work_struct 结构体变量即可，然后使用 INIT_WORK 宏来初始化工作， INIT_WORK （定义在linux/workqueue.h）宏定义如下：

    #define INIT_WORK(_work, _func)		__INIT_WORK((_work), (_func), 0)

             _work:要初始化的工作。

            _func:工作的内容，也就是处理函数。

            也可以使用 DECLARE_WORK 宏一次性完成工作的创建和初始化，宏定义如下：

    #define DECLARE_WORK(n, f)			struct work_struct n = __WORK_INITIALIZER(n, f)

            n：定义的工作。

            f：表示工作的内容，也就是对应的处理函数。 

            定义和初始化完工作，也就是work_struct结构体变量定义与初始化。需要在中断中调度才能开始工作运行，使用函数schedule_work，函数原型：

    static inline bool schedule_work(struct work_struct *work)

            work：要调度的工作。

            返回值：0，成功。其他值失败。 

            ④、使用工作队列的示例

    1. 第一步：定义和初始化工作。
    2. 第二步：在中断处理函数中调度工作。
    3. 第三步：定义工作的内容，也就是编写work的处理函数。
    4. 第四步：删除工作。
    5.  
    6.  
    7. /* 定义工作(work) */
    8. struct work_struct testwork;
    9.  
    10. /* work 处理函数 */
    11. void testwork_func_t(struct work_struct *work);
    12. {
    13.     /* work 具体处理内容 */
    14. }
    15.  
    16. /* 中断处理函数 */
    17. irqreturn_t test_handler(int irq, void *dev_id)
    18. {
    19.  
    20.     /* 调度 work */
    21.     schedule_work(&testwork);
    22.  
    23. }
    24.  
    25. /* 驱动入口函数 */
    26. static int __init xxxx_init(void)
    27. {
    28.  
    29.     /* 初始化 work */
    30.     INIT_WORK(&testwork, testwork_func_t);
    31.  
    32.     /* 注册中断处理函数 */
    33.     request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
    34.  
    35. }
  • 相关阅读:
    vue-springboot 前后端传参的形式
    复杂逻辑的开发利器—Mendix快速实现AQL质量抽检
    where 1=1 是什么意思
    Ubuntu系统下挂载共享文件夹的操作
    accelerate 分布式技巧（一）
    字典树——最大异或对（模板）
    实战｜如何低成本训练一个可以超越 70B Llama2 的模型 Zephyr-7B
    nVisual网络可视化管理平台功能和价值点
    APS智能排产助力锂电池行业智能化排产
    C#开发的OpenRA游戏之生命值
  • 原文地址：https://blog.csdn.net/Tofu_Cabbage/article/details/139960069