1 #include <stdio.h>
2 #include <pthread.h>
3 #include <stdlib.h>
4 #define MANY 1000
5 #define LEVEL 100
6 typedef struct {
7 pthread_mutex_t m[MANY];
8 pthread_mutex_t d;
9 } Level;
10
11 static Level level[LEVEL];
12
13 static int stat_mutex_init = 0;
14 static int stat_mutex_lock = 0;
15 static int stat_mutex_unlock = 0;
16 static int stat_mutex_destroy = 0;
17
18 /* t2t.c : test program for the laog data structure performance testing
19 and "shaking" : it creates, locks/unlocks and destroy mutex.
20
21 USAGE: t2t [many] [level] [loops]
22 many (default 100) : how many locks are created/locked/unlocked at a certain level.
23 level (default 1) : how many levels of "nested locks" are done
24 loops : how many times these locks are created and destroyed and locked/unlocked) */
25 #define check if (ret != 0) printf("error %d at line %d\n", ret, __LINE__)
doit(int argc,char * argv[])26 int doit(int argc, char*argv[])
27 {
28 int l, i;
29 int ret;
30
31 int clo_many = 100;
32 int clo_level = 1;
33
34 if (argc >= 2) clo_many = atoi(argv[1]);
35 if (argc >= 3) clo_level = atoi(argv[2]);
36
37 if (clo_many > MANY) {
38 printf("error argv[1] (many arg) %d > max MANY %d\n", clo_many, MANY);
39 exit(1);
40 }
41
42 if (clo_level > LEVEL) {
43 printf("error argv[2] (level arg) %d > max LEVEL %d\n", clo_level, LEVEL);
44 exit(1);
45 }
46
47 printf ("many %d level %d total_locks: %d\n",
48 clo_many, clo_level,
49 clo_many * clo_level + clo_level * (clo_level == 1 ? 0 : 1));
50
51 for (l = 0; l < clo_level; l++) {
52 printf ("init level %d\n", l);
53 for (i = 0; i < clo_many; i++) {
54 ret = pthread_mutex_init (&level[l].m[i], NULL);
55 check;
56 stat_mutex_init++;
57 }
58 if (clo_level > 1) {
59 ret = pthread_mutex_init (&level[l].d, NULL);
60 check;
61 stat_mutex_init++;
62 }
63 }
64
65 for (l = 0; l < clo_level; l++) {
66 printf ("locking level %d\n", l);
67 for (i = 0; i < clo_many; i++) {
68 ret = pthread_mutex_lock (&level[l].m[i]);
69 check;
70 stat_mutex_lock++;
71 }
72 if (clo_level > 1) {
73 ret = pthread_mutex_lock (&level[l].d);
74 check;
75 stat_mutex_lock++;
76 }
77 }
78
79 for (l = 0; l < clo_level; l++) {
80 printf ("unlocking level %d\n", l);
81 for (i = 0; i < clo_many; i++) {
82 ret = pthread_mutex_unlock (&level[l].m[i]);
83 check;
84 stat_mutex_unlock++;
85 }
86 if (clo_level > 1) {
87 ret = pthread_mutex_unlock (&level[l].d);
88 stat_mutex_unlock++;
89 check;
90 }
91 }
92
93 for (l = 0; l < clo_level; l++) {
94 printf ("deleting level %d\n", l);
95 if (clo_level > 1) {
96 ret = pthread_mutex_destroy (&level[l].d);
97 /// this tests the influence of the deletion in another order.
98 check;
99 stat_mutex_destroy++;
100 }
101 for (i = 0; i < clo_many; i++) {
102 ret = pthread_mutex_destroy (&level[l].m[i]);
103 check;
104 stat_mutex_destroy++;
105 }
106 }
107 return 0;
108 }
109
main(int argc,char * argv[])110 int main(int argc, char*argv[])
111 {
112 int loops = 1;
113 int i;
114 if (argc >= 4) loops = atoi(argv[3]);
115
116 printf ("loops %d\n", loops);
117 for (i = 0; i < loops; i++)
118 doit(argc, argv);
119
120 printf ("stats: init %d lock %d unlock %d destroy %d\n",
121 stat_mutex_init, stat_mutex_lock,
122 stat_mutex_unlock, stat_mutex_destroy);
123 return 0;
124 }
125
126