一个测试sys_read, sys_write原子性的程序

思一克

编译：
gcc  -lpthread  test.c
运行：
./a.out  4 1      //4个线程写，暂停1us，不用fsync
./a.out 4  1 1   //用fsync

1. 
   
2. 
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <unistd.h>
   
6. #include <string.h>
   
7. #include <errno.h>
   
8. #include <pthread.h>
   
9. #include <sys/types.h>
   
10. #include <sys/stat.h>
    
11. #include <fcntl.h>
    
12. 
    
13. #define LEN 3*4000
    
14. 
    
15. int fd;
    
16. int need_sync = 0;
    
17. int sync_done = 0;
    
18. 
    
19. void run(void *arg)
    
20. {
    
21.     char buf[LEN];
    
22.     int usecs = *((int *)arg);
    
23.     int n, i = 0;
    
24. 
    
25.     i = pthread_self()%255;
    
26.     memset(buf, i%31+'A', sizeof(buf));
    
27.     printf("%lu === %c\n", pthread_self(), i%31+'A');
    
28.     while(1)
    
29.     {
    
30.         sync_done = 0;
    
31.         lseek(fd, 0, 0);
    
32.         n = write(fd, buf, sizeof(buf));
    
33.         if(n != sizeof(buf)) printf("ERROR! ******* partial write ******\n");
    
34.         if(need_sync) fsync(fd);
    
35.         sync_done = 1;
    
36.         //fprintf(stdout, "%d:%08x:%d\n", i++, (int )pthread_self(), usecs);
    
37.         usleep(usecs);
    
38.     }
    
39. }
    
40. 
    
41. void see()
    
42. {
    
43. int nbad = 0;
    
44. char buf[LEN];
    
45. int r, n;
    
46. 
    
47.     r = 0;
    
48.     while(1) {
    
49. 
    
50.         while(sync_done == 0);
    
51.         lseek(fd, 0, 0);
    
52.         n = read(fd, buf, sizeof(buf));
    
53.         sync_done = 0;
    
54.         r++;
    
55.         if(r % 1024 == 0) printf("%d %d\n", r, n);
    
56. 
    
57.         if(buf[0] != buf[sizeof(buf)-8]) {
    
58.                 printf("BAD DATA: %c --- %c\n", buf[0], buf[sizeof(buf)-8]);
    
59.         }
    
60.         //sleep(1);
    
61.     }
    
62. }
    
63. 
    
64. int main(int argc, char **argv)
    
65. {
    
66.     int threads_num = 0;
    
67.     int sleep_usecs = 0;
    
68.     int i = 0;
    
69.     pthread_t thread_id = 0;
    
70. 
    
71.     if(argc < 3)
    
72.     {
    
73.         fprintf(stderr, "Usage:%s threads_num sleep_usec(s)\n", argv[0]);
    
74.         _exit(-1);
    
75.     }
    
76. 
    
77.     if(argv[3]) need_sync = 1;
    
78. 
    
79. 
    
80.     fd = open("./1111", O_CREAT | O_RDWR);
    
81.     printf("fd = %d\n", fd);
    
82. 
    
83. 
    
84.     threads_num = atoi(argv[1]);
    
85.     sleep_usecs = atoi(argv[2]);
    
86.     for(i = 0; i < threads_num; i++)
    
87.     {
    
88.         if(pthread_create(&thread_id, NULL, (void *)&run, (void *)&sleep_usecs) == 0)
    
89.         {
    
90.             fprintf(stdout, "created thread[%d][%08x] sleep_usecs:%d\n",
    
91.                     i, (int )thread_id, sleep_usecs);
    
92.         }
    
93.     }
    
94.     pthread_create(&thread_id, NULL, (void *)&see, (void *)&sleep_usecs);
    
95.     while(1)
    
96.     {
    
97.         usleep(sleep_usecs);
    
98.     }
    
99.     return 0;
    
100. }
     
101. 
     
102. 
     

复制代码

思一克

1）看程序有什么问题（包括错误）没有。
2）分析结果看。

epegasus

回复 1# 思一克


    可否将测试结果描述下.我没有环境
另外在open的时候加APPEND参数结果又是什么?

思一克

回复 3# epegasus


结果是，不用fsync（./a.out 4 1)
结果是大量的乱的。
用了fsync(./a.out 4 1 1)
基本不乱了。前面有几个乱的，后面跑一天也不出一个。
估计是我的程序考虑不周到造成的。

APPEND方式下不乱。这个不用测试，也不容易测试，因为块大了文件一会将磁盘就充满了。
我的应用程序几十上百进程同时APPEND写LOG, 10年了也没有乱过的。写的块大小不定，但都小于4096.

epegasus

回复 4# 思一克


      提个建议.如果要测试同步的话放在 open选项中
当see里面的n 不完全的时候也建议打印出来.
另外如果是测试多个write之间的交错问题.应该排除write和read的交错带来的影响
所以可以设计一个读写锁.不过这个锁恰好反用.多个写可以并发获得锁.读独占锁

思一克

回复 5# epegasus


write之间不交错的。不是有那个i_mutex互斥吗。
乱的原因是读和write之间没有互斥。完全可以在写了一半的时候被读到了，结果自然是乱的了。

epegasus

回复 6# 思一克


    其实pipe里也互斥.但仍然交错. 因为pipe里会在适当的时间释放.我在那个帖子里说明了.本来是一对lock unlock但是在适当的时候中间插入unlock lock
普通文件目前还没有发现哪里有释放。但是2.6中那个for可能导致在一个 write里数据不完全的写入.这个不确定.因为那个返回EIOCBRETRY的机制还没完全弄清楚.另一个帖子里提到了这点.

思一克

回复 7# epegasus


  你说的对。
PIPE写中间可以释放锁头。所以也会交错。但每次写的大小小于PIPE_BUF即可保证原子性。

peijue

来学习学习