semspeed.c

   1 /* quick test of semaphore speed */
   2
   3 /*
   4
   5 Results with the following defines:
   6   #define NSEMS 20
   7   #define NPROCS 60
   8   #define NUMOPS 10000
   9
  10   OSF1 dominion.aquasoft.com.au V4.0 564 alpha (233 MHz)
  11   fcntl: 132.814 secs
  12   ipc: 13.5186 secs
  13
  14   Linux dominion.aquasoft.com.au 2.0.30 (alpha 233 MHz)
  15   fcntl: 16.9473 secs
  16   ipc: 61.9336 secs
  17
  18   Linux 2.1.57 on a P120
  19   fcntl: 21.3006 secs
  20   ipc: 93.9982 secs
  21
  22   Solaris 2.5 on a Ultra170
  23   fcntl: 192.805 secs
  24   ipc: 18.6859 secs
  25
  26   IRIX 6.4 on a Origin200
  27   fcntl: 183.488 secs
  28   ipc: 10.4431 secs
  29
  30   SunOS 4.1.3 on a 2 CPU sparc 10
  31   fcntl: 198.239 secs
  32   ipc: 150.026 secs
  33
  34   Solaris 2.5.1 on a 4 CPU SPARCsystem-600
  35   fcntl: 312.025 secs
  36   ipc: 24.5416 secs
  37
  38   Linux 2.1.131 on K6/200
  39   fcntl: 8.27074 secs
  40   ipc: 49.7771 secs
  41
  42   Linux 2.0.34 on P200
  43   fcntl: 7.99596 secs
  44   ipc: 52.3388 secs
  45
  46   AIX 4.2 on 2-proc RS6k with 233MHz processors
  47   fcntl: 12.4272 secs
  48   ipc: 5.41895 secs
  49
  50   Linux 2.6.27 on Core-2-duo T61 thinkpad
  51   fcntl: 0.718363 secs
  52   ipc: 2.12952 secs
  53
  54   Linux 2.6.27 on Core-2-quad
  55   fcntl: 0.718363 secs
  56   ipc: 2.12952 secs
  57
  58  */
  59
  60 #include <stdlib.h>
  61 #include <stdio.h>
  62 #include <fcntl.h>
  63 #include <errno.h>
  64 #include <unistd.h>
  65 #include <sys/types.h>
  66 #include <sys/stat.h>
  67 #include <sys/ipc.h>
  68 #include <sys/sem.h>
  69 #include <sys/time.h>
  70 #ifdef HAVE_POSIX_SEM
  71 #include <semaphore.h>
  72 #endif
  73
  74 #define NSEMS 20
  75 #define NPROCS 60
  76 #define NUMOPS 10000
  77
  78 #define SEMAPHORE_KEY 0x569890
  79 #define SHM_KEY 0x568698
  80
  81 static int fcntl_fd;
  82 static int sem_id;
  83 static int shm_id;
  84 static int *shm_p;
  85 static int mypid;
  86
  87 #ifdef HAVE_POSIX_SEM
  88 static sem_t posix_sems[NSEMS];
  89 #endif
  90
  91 static int state[NSEMS];
  92
  93 #define BUFSIZE (1024)
  94 static char buf1[BUFSIZE];
  95 static char buf2[BUFSIZE];
  96
  97 #ifdef NO_SEMUN
  98 union semun {
  99         int val;
 100         struct semid_ds *buf;
 101         unsigned short *array;
 102 };
 103 #endif
 104
 105
 106 static struct timeval tp1,tp2;
 107
 108 static void start_timer()
 109 {
 110         gettimeofday(&tp1,NULL);
 111 }
 112
 113 static double end_timer()
 114 {
 115         gettimeofday(&tp2,NULL);
 116         return((tp2.tv_sec - tp1.tv_sec) +
 117                (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
 118 }
 119
 120
 121 /************************************************************************
 122   USING FCNTL LOCKS
 123   ***********************************************************************/
 124 void fcntl_setup(void)
 125 {
 126         fcntl_fd = open("fcntl.locks", O_RDWR | O_CREAT | O_TRUNC, 0600);
 127         write(fcntl_fd, state, sizeof(state));
 128 }
 129
 130 void fcntl_close(void)
 131 {
 132         unlink("fcntl.locks");
 133 }
 134
 135 void fcntl_sem_lock(int i)
 136 {
 137         struct flock lock;
 138         int ret;
 139
 140         lock.l_type = F_WRLCK;
 141         lock.l_whence = SEEK_SET;
 142         lock.l_start = i*sizeof(int);
 143         lock.l_len = sizeof(int);
 144         lock.l_pid = 0;
 145
 146         errno = 0;
 147
 148         if (fcntl(fcntl_fd, F_SETLKW, &lock) != 0) {
 149                 perror("WRLCK");
 150                 exit(1);
 151         }
 152 }
 153
 154 void fcntl_sem_unlock(int i)
 155 {
 156         struct flock lock;
 157         int ret;
 158
 159         lock.l_type = F_UNLCK;
 160         lock.l_whence = SEEK_SET;
 161         lock.l_start = i*sizeof(int);
 162         lock.l_len = sizeof(int);
 163         lock.l_pid = 0;
 164
 165         errno = 0;
 166
 167         if (fcntl(fcntl_fd, F_SETLKW, &lock) != 0) {
 168                 perror("WRLCK");
 169                 exit(1);
 170         }
 171 }
 172
 173
 174
 175 /************************************************************************
 176   USING SYSV IPC SEMAPHORES
 177   ***********************************************************************/
 178 void ipc_setup(void)
 179 {
 180         int i;
 181         union semun su;
 182
 183         su.val = 1;
 184
 185         sem_id = semget(SEMAPHORE_KEY, NSEMS,
 186                         IPC_CREAT|IPC_EXCL|0600);
 187         if (sem_id == -1) {
 188                 sem_id = semget(SEMAPHORE_KEY, 0, 0);
 189                 if (sem_id != -1) {
 190                         semctl(sem_id, 0, IPC_RMID, su);
 191                         sem_id = semget(SEMAPHORE_KEY, NSEMS,
 192                                         IPC_CREAT|IPC_EXCL|0600);
 193                 }
 194         }
 195         if (sem_id == -1) {
 196                 perror("semget");
 197                 exit(1);
 198         }
 199
 200         for (i=0;i<NSEMS;i++) {
 201                 semctl(sem_id, i, SETVAL, su);
 202         }
 203
 204         if (sem_id == -1) {
 205                 perror("semget");
 206                 exit(1);
 207         }
 208 }
 209
 210 void ipc_close(void)
 211 {
 212         union semun su;
 213         su.val = 1;
 214         semctl(sem_id, 0, IPC_RMID, su);
 215 }
 216
 217
 218 void ipc_change(int i, int op)
 219 {
 220         struct sembuf sb;
 221         sb.sem_num = i;
 222         sb.sem_op = op;
 223         sb.sem_flg = 0;
 224         if (semop(sem_id, &sb, 1)) {
 225                 fprintf(stderr,"semop(%d,%d): ", i, op);
 226                 perror("");
 227                 exit(1);
 228         }
 229 }
 230
 231 void ipc_sem_lock(int i)
 232 {
 233         ipc_change(i, -1);
 234 }
 235
 236 void ipc_sem_unlock(int i)
 237 {
 238         ipc_change(i, 1);
 239 }
 240
 241
 242 #ifdef HAVE_POSIX_SEM
 243 /************************************************************************
 244   USING POSIX semaphores
 245   ***********************************************************************/
 246 void posix_setup(void)
 247 {
 248         int i;
 249
 250         for (i=0;i<NSEMS;i++) {
 251                 if (sem_init(&posix_sems[i], 1, 1) != 0) {
 252                         fprintf(stderr,"failed to setup semaphore %d\n", i);
 253                         break;
 254                 }
 255         }
 256 }
 257
 258 void posix_close(void)
 259 {
 260         int i;
 261
 262         for (i=0;i<NSEMS;i++) {
 263                 if (sem_close(&posix_sems[i]) != 0) {
 264                         fprintf(stderr,"failed to close semaphore %d\n", i);
 265                         break;
 266                 }
 267         }
 268 }
 269
 270
 271 void posix_lock(int i)
 272 {
 273         if (sem_wait(&posix_sems[i]) != 0) fprintf(stderr,"failed to get lock %d\n", i);
 274 }
 275
 276 void posix_unlock(int i)
 277 {
 278         if (sem_post(&posix_sems[i]) != 0) fprintf(stderr,"failed to release lock %d\n", i);
 279 }
 280 #endif
 281
 282
 283 void test_speed(char *s, void (*lock_fn)(int ), void (*unlock_fn)(int ))
 284 {
 285         int i, j, status;
 286         pid_t pids[NPROCS];
 287
 288         for (i=0;i<NSEMS;i++) {
 289                 lock_fn(i);
 290         }
 291
 292         for (i=0;i<NPROCS;i++) {
 293                 pids[i] = fork();
 294                 if (pids[i] == 0) {
 295                         mypid = getpid();
 296                         srandom(mypid ^ time(NULL));
 297                         for (j=0;j<NUMOPS;j++) {
 298                                 unsigned sem = random() % NSEMS;
 299
 300                                 lock_fn(sem);
 301                                 memcpy(buf2, buf1, sizeof(buf1));
 302                                 unlock_fn(sem);
 303                                 memcpy(buf1, buf2, sizeof(buf1));
 304                         }
 305                         exit(0);
 306                 }
 307         }
 308
 309         sleep(1);
 310
 311         printf("%s: ", s);
 312         fflush(stdout);
 313
 314         start_timer();
 315
 316         for (i=0;i<NSEMS;i++) {
 317                 unlock_fn(i);
 318         }
 319
 320         for (i=0;i<NPROCS;i++)
 321                 waitpid(pids[i], &status, 0);
 322
 323         printf("%g secs\n", end_timer());
 324 }
 325
 326 int main(int argc, char *argv[])
 327 {
 328         srandom(getpid() ^ time(NULL));
 329
 330         printf("NPROCS=%d NSEMS=%d NUMOPS=%d\n", NPROCS, NSEMS, NUMOPS);
 331
 332
 333         fcntl_setup();
 334         test_speed("fcntl", fcntl_sem_lock, fcntl_sem_unlock);
 335         fcntl_close();
 336
 337         ipc_setup();
 338         test_speed("ipc", ipc_sem_lock, ipc_sem_unlock);
 339         ipc_close();
 340
 341 #ifdef HAVE_POSIX_SEM
 342         posix_setup();
 343         test_speed("posix", posix_lock, posix_unlock);
 344         posix_close();
 345 #endif
 346
 347         return 0;
 348 }