Lecture Notes for Client-Server Interfaces

7 March 2002 - Process vs Threads Performance

Thread vs. Process Concurrency

• Thread concurrency.

  • Cheap to create and delete.

  • Sharing is simple, but requires synchronization.

  • Concurrent design and programming.

• Process concurrency.

  • Expensive to create and delete.

  • Sharing is difficult and expensive.

  • Serial design and programming.

• Which is better?

  • How's the performance?

  • Create-delete costs.

  • Throughput.

The Contenders

• Fork concurrency.

  pid_t pid;
  
  switch (pid = fork()) {
    case 0: 
      exit(EXIT_SUCCESS);
    case -1:
      perror("fork() error:");
      exit(EXIT_FAILURE);
    default:
      assert(wait(NULL) == pid);
    }
  

• Using threads.

  pthread_t tid;
  int e;
  
  if ((e = pthread_create(&tid, NULL, f, NULL))) {
    printf("pthread_create() failed with %d.\n", e);
    return EXIT_FAILURE;
    }
  if ((e = pthread_join(tid, NULL))) {
    printf("pthread_join() failed with %d.\n", e);
    return EXIT_FAILURE;
    }
  

• See the complete code.

The Results

cl date
Thu Mar 15 14:42:55 EST 2001

cl uname -a
SunOS clayton 5.7 sun4u sparc SUNW,Ultra-5_10

cl g++ -o forktime forktime.cc -lpthread

cl forktime
79 usec for 2000 iterations, 0.0395 usec/iteration.
7817.5 usec per fork() call for 2000 calls.
 104.193 usec per pthread_create() call for 2000 calls.

cl forktime
79 usec for 2000 iterations, 0.0395 usec/iteration.
7864.8 usec per fork() call for 2000 calls.
 109.993 usec per pthread_create() call for 2000 calls.

cl CC -o forktime forktime.cc -lpthread

cl forktime
19 usec for 2000 iterations, 0.0095 usec/iteration.
7803.37 usec per fork() call for 2000 calls.
  82.0435 usec per pthread_create() call for 2000 calls.

cl forktime
19 usec for 2000 iterations, 0.0095 usec/iteration.
7825.22 usec per fork() call for 2000 calls.
 103.33 usec per pthread_create() call for 2000 calls.

cl 

Other Systems

• Rockhopper

  ro uname -a
  Linux rockhopper.monmouth.edu 2.4.17 #1 SMP 
  Thu Jan 3 13:52:42 EST 2002 i686
  
  ro make
  g++ -o forkvthread -g forkvthread.cc -lpthread
  
  ro forkvthread
  1151.7 usec per fork() call for 2000 calls.
   140.091 usec per pthread_create() call for 2000 calls.
  
  ro forkvthread 
  1154.87 usec per fork() call for 2000 calls.
   141.853 usec per pthread_create() call for 2000 calls.
  
  ro 
  

• Moncol

  mo uname -a
  OSF1 moncol.MONMOUTH.EDU V5.1 732 alpha
  
  mo forkvthread
  42318.8 usec per fork() call for 2000 calls.
    570.305 usec per pthread_create() call for 2000 calls.
  
  mo forkvthread
  40124 usec per fork() call for 2000 calls.
    690.909 usec per pthread_create() call for 2000 calls.
  
  mo 
  

Conclusions

• Thread create and delete is cheap.

• Process create and delete is not - sometimes really not.

• Why not do threads always?

  • Process simplicity, support, and security.

• Amortize create-delete costs over many computations.

  • Inter-computation communication costs.

  • Can be tricky to do.

  • What about the connection?

This page last modified on 16 March 2002.