int linux 原子操作_linux 原子操作
原子操作
原子操作,顾名思义,就是说像原子一样不可再细分不可被中途打断。一个操作是原子操作,意思就是说这个操作是以原子的方式被执行,要一口气执行完,执行过程不能够被OS的其他行为打断,是一个整体的过程,在其执行过程中,OS的其它行为是插不进来的。
在linux中提供了两种形式的原子操作:
一种是对整数进行的操作
一种是对单独的位进行操作
在linux中有一个专门的atomic_t类型(一个24位原子访问计数器)和一些对atomic类型变量进行相应操作的的函数
其atomic_t原型如下:
typedef struct { volatile int counter; } atomic_t;
它是一个只含有一个volatile类型的成员变量的结构体;因此编译器不对相应的值进行访问优化(因为是volatile类型的)。
原子整数操作的使用:
常见的用途是计数器,因为计数器是一个很简单的操作,所以无需复杂的锁机制;
能使用原子操作的地方,尽量不使用复杂的锁机制;
对atomic_t类型的变量的使用方法以及对其所能进行的操作:
下面是相应的函数及其原型:
小提示:
******
在其函数的实现体中,有一个LOCK_PREFIX宏定义,如果选了CONFIG_SMP,就会定义这么一个宏,与SMP相关的一些设置,否则LOCK_PREFIX的定义就为空;
******
//原子的读取atomic_t变量的值,v是这个变量的地址
#define atomic_read(v) ((v)->counter)
//原子的设置atomic_t变量的值,v是这个变量的地址,i要设置的新值;
#define atomic_set(v,i) (((v)->counter) = (i))
//原子的增加atomic_t变量的值,i是要增加的数值,v是这个变量的地址
static __inline__ void atomic_add(int i, atomic_t *v)
{
__asm__ __volatile__(
LOCK_PREFIX "addl %1,%0"
:"=m" (v->counter)
:"ir" (i), "m" (v->counter));
}
//原子的减少atomic_t变量的值,i是要减少的数值,v是这个变量的地址;
static __inline__ void atomic_sub(int i, atomic_t *v)
{
__asm__ __volatile__(
LOCK_PREFIX "subl %1,%0"
:"=m" (v->counter)
:"ir" (i), "m" (v->counter));
}
//原子的对atomic_t变量的值进行减少i的操作,并且检测其结果是否为0;若为0,返回true,否则,返回false;
//i是要减少的数值,v是这个变量的地址;
static __inline__ int atomic_sub_and_test(int i, atomic_t *v)
{
unsigned char c;
__asm__ __volatile__(
LOCK_PREFIX "subl %2,%0; sete %1"
:"=m" (v->counter), "=qm" (c)
:"ir" (i), "m" (v->counter) : "memory");
return c;
}
//原子的对atomic_t变量的值进行加1的操作,v是这个变量的地址;
static __inline__ void atomic_inc(atomic_t *v)
{
__asm__ __volatile__(
LOCK_PREFIX "incl %0"
:"=m" (v->counter)
:"m" (v->counter));
}
//原子的对atomic_t变量的值进行减1的操作,v是这个变量的地址;
static __inline__ void atomic_dec(atomic_t *v)
{
__asm__ __volatile__(
LOCK_PREFIX "decl %0"
:"=m" (v->counter)
:"m" (v->counter));
}
//原子的对atomic_t变量的值进行减少1的操作,并且检测其结果是否为0;若为0,返回true,否则,返回false;
//v是这个变量的地址;
static __inline__ int atomic_dec_and_test(atomic_t *v)
{
unsigned char c;
__asm__ __volatile__(
LOCK_PREFIX "decl %0; sete %1"
:"=m" (v->counter), "=qm" (c)
:"m" (v->counter) : "memory");
return c != 0;
}
//原子的对atomic_t变量的值进行加1的操作,并且检测其结果是否为0;若为0,返回true,否则,返回false;
//v是这个变量的地址;
static __inline__ int atomic_inc_and_test(atomic_t *v)
{
unsigned char c;
__asm__ __volatile__(
LOCK_PREFIX "incl %0; sete %1"
:"=m" (v->counter), "=qm" (c)
:"m" (v->counter) : "memory");
return c != 0;
}
//原子的对atomic_t变量的值进行加i的操作,并且检测其结果是否为负;若为负,返回true,否则,返回false;
//i是要增加的数值,v是这个变量的地址;
static __inline__ int atomic_add_negative(int i, atomic_t *v)
{
unsigned char c;
__asm__ __volatile__(
LOCK_PREFIX "addl %2,%0; sets %1"
:"=m" (v->counter), "=qm" (c)
:"ir" (i), "m" (v->counter) : "memory");
return c;
}
//原子的对atomic_t变量的值进行加i的操作,并且将所得结果返回;
//i是要增加的数值,v是这个变量的地址;
static __inline__ int atomic_add_return(int i, atomic_t *v)
{
int __i;
#ifdef CONFIG_M386
unsigned long flags;
if(unlikely(boot_cpu_data.x86==3))
goto no_xadd;
#endif
/* Modern 486+ processor */
__i = i;
__asm__ __volatile__(
LOCK_PREFIX "xaddl %0, %1;"
:"=r"(i)
:"m"(v->counter), "0"(i));
return i + __i;
#ifdef CONFIG_M386
no_xadd: /* Legacy 386 processor */
local_irq_save(flags);
__i = atomic_read(v);
atomic_set(v, i + __i);
local_irq_restore(flags);
return i + __i;
#endif
}
//原子的对atomic_t变量的值进行减i的操作,并且将所得结果返回;
//i是要减少的数值,v是这个变量的地址;
static __inline__ int atomic_sub_return(int i, atomic_t *v)
{
return atomic_add_return(-i,v);
}
//原子的比较old与v是否相等,若相等,则把new的值写入到v中,并且返回old的值;
#define atomic_cmpxchg(v, old, new) ((int)cmpxchg(&((v)->counter), old, new))
//原子的比较
#define atomic_xchg(v, new) (xchg(&((v)->counter), new))
/**
* atomic_add_unless - add unless the number is a given value
* @v: pointer of type atomic_t
* @a: the amount to add to v...
* @u: ...unless v is equal to u.
*
* Atomically adds @a to @v, so long as it was not @u.
* Returns non-zero if @v was not @u, and zero otherwise.
*/
//原子的对atomic_t变量的值进行加a的操作,直到v等于u,如果v与u不等,返回非零值;否则返回0;
//a是要增加的数值,v是这个变量的地址,u是要比较的值;
#define atomic_add_unless(v, a, u) \
({ \
int c, old; \
c = atomic_read(v); \
for (;;) { \
if (unlikely(c == (u))) \
break; \
old = atomic_cmpxchg((v), c, c + (a)); \
if (likely(old == c)) \
break; \
c = old; \
} \
c != (u); \
})
#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
#define atomic_inc_return(v) (atomic_add_return(1,v))
#define atomic_dec_return(v) (atomic_sub_return(1,v))
//掩码
/* These are x86-specific, used by some header files */
#define atomic_clear_mask(mask, addr) \
__asm__ __volatile__(LOCK_PREFIX "andl %0,%1" \
: : "r" (~(mask)),"m" (*addr) : "memory")
#define atomic_set_mask(mask, addr) \
__asm__ __volatile__(LOCK_PREFIX "orl %0,%1" \
: : "r" (mask),"m" (*(addr)) : "memory")
下面举例说明原子操作的用法:
定义一个atomic_c类型的数据很简单,还可以定义时给它设定初值:
(1) atomic_t u; /*定义 u*/
(2) atomic_t v = ATOMIC_INIT(0) /*定义 v 并把它初始化为0*/
对其操作:
(1) atomic_set(&v,4) /* v = 4 ( 原子地)*/
(2) atomic_add(2,&v) /* v = v + 2 = 6 (原子地) */
(3) atomic_inc(&v) /* v = v + 1 =7(原子地)*/
如果需要将atomic_t转换成int型,可以使用atomic_read()来完成:
printk(“%d\n”,atomic_read(&v)); /* 会打印7*/
原子整数操作最常见的用途就是实现计数器。使用复杂的锁机制来保护一个单纯的计数器是很笨拙的,所以,开发者最好使用atomic_inc()和atomic_dec()这两个相对来说轻便一点的操作。
还可以用原子整数操作原子地执行一个操作并检查结果。一个常见的例子是原子的减操作和检查。
int atomic_dec_and_test(atomic_t *v)
这个函数让给定的原子变量减1,如果结果为0,就返回1;否则返回0
原子位操作
操作函数的参数是一个指针和一个位号
第0位是给定地址的最低有效位
原子位操作中没有特殊的数据类型
例如:set_bit(0, &word);
如:标志寄存器EFLSGS的系统标志,用于控制I/O访问,可屏蔽硬件中断。共32位,不同的位代表不同的信息,对其中信息改变都是通过位操作实现的
原子操作中的位操作部分函数如下:
void set_bit(int nr, void *addr) 原子设置addr所指的第nr位
void clear_bit(int nr, void *addr) 原子的清空所指对象的第nr位
void change_bit(nr, void *addr) 原子的翻转addr所指的第nr位
int test_bit(nr, void *addr) 原子的返回addr位所指对象nr位
int test_and_set_bit(nr, void *addr) 原子设置addr所指对象的第nr位,并返回原先的值
int test_and_clear_bit(nr, void *addr) 原子清空addr所指对象的第nr位,并返回原先的值
int test_and_change_bit(nr, void *addr) 原子翻转addr所指对象的第nr位,并返回原先的值
#include #include#include#include#include#include#include#include#include#include#include#include#include#include
#define MAGIC 'B'
#define GET_BTN_VAL _IOR(MAGIC,1,unsigned long)typedefstruct{
unsignedintgpio;
unsignedintbtn;
unsignedintirq;char*name;
}irq_typedef;static irq_typedef irq_source[]={
{EXYNOS4_GPX3(2),1,0,"btn1"},
{EXYNOS4_GPX3(3),2,0,"btn2"},
{EXYNOS4_GPX3(4),3,0,"btn3"},
{EXYNOS4_GPX3(5),4,0,"btn4"}
};//等待队列静态申请
static intcondition;//static wait_queue_head_t btn_wait_que;//static init_waitqueue_head(&btn_wait_que);
DECLARE_WAIT_QUEUE_HEAD(btn_wait_que);//定时器
structtimer_list btn_timer;static unsigned longbtn_num;
irq_typedef*curdev;static inttimer_flag;//中断函数
static irq_handler_t gpio_btn_handler(int irq, void *dev)
{
curdev= (irq_typedef*)dev;if(!timer_flag)
{
add_timer(&btn_timer);
timer_flag=1;
}elsemod_timer(&btn_timer, jiffies+msecs_to_jiffies(200));return 0;
}//定时器处理函数
static void btn_tim_function(unsigned longdata)
{
printk("%s\n",curdev->name);
printk("curbtn :%d\n",curdev->btn);
condition=1;
wake_up(&btn_wait_que);//全局变量在ioctrl中调用
btn_num = curdev->btn;
}
atomic_t btn_atomic= ATOMIC_INIT(1);static int btn_open(struct inode *node, struct file *fil)
{inti,ret;if(!atomic_dec_and_test(&btn_atomic))
{
atomic_inc(&btn_atomic);return -1;
}for(i=0;i<4;i++)
{//设置相应IO口为中断
irq_source[i].irq =gpio_to_irq(irq_source[i].gpio);//请求中断
ret = request_irq(irq_source[i].irq,(irq_handler_t)gpio_btn_handler, IRQF_TRIGGER_FALLING,irq_source[i].name,&irq_source[i]);
}
btn_timer.expires=jiffies+msecs_to_jiffies(200);
btn_timer.function=btn_tim_function;
btn_timer.data=0;
init_timer(&btn_timer);returnret;
}static int btn_release(struct inode *node, struct file *fil)
{inti;
atomic_inc(&btn_atomic);
del_timer(&btn_timer);//释放中断号和中断那个结构体成员//free_irq(unsigned int irq, void * dev_id)
for(i=0;i<4;i++)
free_irq(irq_source[i].irq,&irq_source[i]);return 0;
}static long btn_ioctl(struct file *fil, unsigned int cmd, unsigned longarg)
{//int ret;//把数据转换成用户空间类型 和上层进行通信
void __user *argp = (void __user *)arg;
wait_event_interruptible(btn_wait_que, condition);
condition=0;switch(cmd)
{caseGET_BTN_VAL://printk("btn_num :%ld\n",btn_num);
put_user(btn_num, (unsigned int __user *) argp);//ret = copy_to_user((void __user *) argp, (void *)&btn_num,4);//copy_to_user(void __user * to, const void * from, unsigned long n);
break;default:return -EINVAL;
}return 0;
}//文件操作集合
static struct file_operations btn_irq_fops ={
.owner=THIS_MODULE,
.unlocked_ioctl=btn_ioctl,
.open=btn_open,
.release=btn_release,
};//杂项注册
static struct miscdevice btn_misc={
.minor= 255,
.name= "btn",
.fops= &btn_irq_fops,
};static __init int btn_irq_init(void)
{intret;
ret= misc_register(&btn_misc);returnret;
}static __exit void btn_irq_exit(void)
{
misc_deregister(&btn_misc);
}
module_init(btn_irq_init);
module_exit(btn_irq_exit);
MODULE_LICENSE("GPL");
1 #include
2 #include
3 #include
4 #include
5 #include
6 #include
7 #include
8
9 #define MAGIC 'B'
10 #define GET_BTN_VAL _IOR(MAGIC, 1, unsigned long)
11
12 int main(int argc,char *argv[])13 {14 int btn_fd,btn_val=0;15
16 if(argc!=2)17 {18 printf("Usage: \n",argv[0]);19 return -1;20 }21
22 btn_fd = open(argv[1],O_RDONLY);23
24 if(btn_fd<0)25 {26 printf("busy!!!!!\n");27 return -1;28
29 }30
31
32 while(1)33 {34 ioctl(btn_fd,GET_BTN_VAL,&btn_val);35 //ioctl(btn_fd,GET_BTN_VAL,btn_val);36 //sleep(1);
37
38 printf("btn_val(irq):%d\n",btn_val);39 }40 }
1 obj-m +=btnirq.o2 SOURCE =btntest.o3
4 CROSS_COMPLIE = arm-linux-
5 CC =$(CROSS_COMPLIE)gcc6
7 KERNDIR = /centos/xyd/linux-3.5
8 #CURDIR =$(shell pwd)9 CURDIR =`pwd`10
11 .PHONY: module clean12
13 all: module $(SOURCE:.o=)14
15 module:16 $(MAKE) -C $(KERNDIR) M=$(CURDIR) modules17
18 $(SOURCE:.o=):$(SOURCE)19 $(CC) -o $@ $^
20
21 %.o:%.c22 $(CC) -c $<
23
24 clean:25 $(MAKE) -C $(KERNDIR) M=$(CURDIR) clean26 rm $(SOURCE:.o=)
int linux 原子操作_linux 原子操作相关推荐
- int linux 原子操作_Linux原子操作
一.原子操作 所谓原子操作,就是该操作绝不会在执行完毕前被任何其他任务或事件打断,也就说,它是最小的执行单位,不可能有比它更小的执行单位,因此这里的原子实际是使用了物理学里的物质微粒的概念. 原子操作 ...
- int linux 原子操作_linux c++编程之多线程:原子操作如何解决线程冲突
在多线程中操作全局变量一般都会引起线程冲突,为了解决线程冲突,引入原子操作. 1.线程冲突 #include #include #include #include int g_count = 0;vo ...
- linux内核的原子操作简述
前言 原子操作可以保证对一个整型数据的修改是排他性的.Linux内核提供了一系列函数来实现内核中的原子操作,这些函数又分为两类,分别针对位和整型变量进行原子操作.位和整型变量的原子操作都依赖于底层CP ...
- Linux驱动之 原子操作
Linux驱动之 原子操作学习记录: 概念: 原子操作是指在执行过程中不会被别的代码所中断的操作,即它是最小的执行单位. 最简单的原子操作就是一条条的汇编指令(不包括一些伪指令,伪指令会被汇编器解释成 ...
- int i =1 是原子操作吗?i++是原子操作吗?
int i =1 是原子操作吗?i++是原子操作吗? int i =1 是原子操作吗?i++是原子操作吗? 1.什么是原子操作 2.示例:凡有赋值的操作在多线程环境都要加锁 参考 int i =1 是 ...
- linux并发控制之原子操作
原子操作指的是在执行过程中不会被别的代码路径所中断的操作. 分为两类:整型原子操作 和 位原子操作. 特点: 1.任何情况下操作都是原子的. 2.都依赖底层的CPU的原子操作来实现,所以和CPU架构密 ...
- linux c/c++ 原子操作库 atomic atomic_flag 简介
目录 简介 1.类classes 1.1 atomic 1)构造函数 2)赋值运算 3)is_lock_free 4)store 5)load 6)operator T 7)exchange 8)co ...
- linux 信号_Linux信号量(1)-SYSTEM V
信号量概念 信号量本质上是一个计数器(不设置全局变量是因为进程间是相互独立的,而这不一定能看到,看到也不能保证++引用计数为原子操作),用于多进程对共享数据对象的读取,它和管道有所不同,它不以传送 ...
- java 什么是原子操作_java原子操作CAS
本次内容主要讲原子操作的概念.原子操作的实现方式.CAS的使用.原理.3大问题及其解决方案,最后还讲到了JDK中经常使用到的原子操作类. 1.什么是原子操作? 所谓原子操作是指不会被线程调度机制打断的 ...
最新文章
- 读懂深度迁移学习,看这文就够了 | 赠书
- 深度学习前人精度很高了,该怎么创新?
- ISE14.7在win10下的兼容性问题汇总
- springboot学习笔记(一)
- 我的世界java和pe版_《我的世界》pe版不一样的方块世界
- android Lint优化代码
- PHP-CGI, FastCGI, PHP-FPM的关系和区别
- 你们数学老师当年是怎么叫这些符号的…
- python根据文件路径获取上级目录路径
- 关于未来世界,永生的几个方向和总结思考
- Flume监听文件夹中的文件变化_并把文件下沉到hdfs
- maven安装本地jar到本地仓库
- 开始我的.NET的学习旅程
- hadoop大数据生态概述
- 在Ubuntu上安装D-link DWA-131驱动
- 2021年9月基因编辑/CRISPR最新研究进展
- 分享下Python从业者的生存现状,告诉你一般程序员真实工资
- Jim Zemlin:中国是开源最重要的市场
- 对qq空间动手--selenium实践
- 复数complex的magnitude是什么
热门文章
- (Buuctf) [第五空间2019 决赛]PWN5 简单格式化字符串漏洞利用
- Python字符串练习题
- python 两种多线程比较
- RS(纠删码)技术浅析及Python实现
- 一文读懂:从 Python 打包到 CLI 工具
- 【opencv4】opencv视频教程 C++(opencv教程)1、opencv介绍和环境搭建
- ubuntu终端按ctrl+s就卡住怎么办?(按ctrl+q)(锁住)(锁屏)(暂停打印)
- numba numpy计算加速器 官方教程 GPU CUDA配置
- windows中端口号(port id)和port的区别,如何通过端口查看进程pid,如何通过pid查看程序,如何通过pid查看端口?
- linux——关于ip、静态网络、动态网络、网关、DNS的设置