Lecture Notes for Operating Systems Concepts

30 September 2004 - Process vs Threads Performance

Threads vs. Processes

• Threads are simple, small, and fast.

• Processes are complex, big, and slow.

• Which is better: threads or processes?

  • It depends on how you want to use them.

• But performance characteristics may favor one side over the other.

Performance Measures

• There's lots of ways to measure performance.

• Take a look at create and delete costs.

  • This is the minimum overhead possible.

  • It's relatively easy to measure usefully.

• There are ways of avoiding bad performance.

  • Recycle threads and processes.

  • Designing and implementing recycling is harder than not recycling.

Unix Processes

• fork() creates an exact copy of the calling process.

  • It returns the child's process id to the caller.

  • It returns 0 to the child.

• wait() blocks the calling process until a child changes state.

  • And returns the process id of the child.

  • In this case, the child terminates.

Making Processes

main()

  pid_t pid

  while iter-- > 0
    switch pid = fork()
      case 0   // child
	exit(EXIT_SUCCESS)
      case -1  // error
	perror("fork() error:")
	exit(EXIT_FAILURE)
      default  // parent
	assert(wait(NULL) == pid)

Posix Threads

• pthread_create(&tid, f) creates a new thread.

  • tid contains the new thread's id.

  • The new thread calls f(), terminating when f() returns.

• pthread_join(tid) blocks the caller until the thread with the given id terminates.

Making Threads

static void f() { }

main()

  while (iter-- > 0)
    if e = pthread_create(&tid, f)
      printf("create failed")
      return EXIT_FAILURE

    if e = pthread_join(tid)
      printf("join failed")
      return EXIT_FAILURE

See the complete code.

The Environment

• Solaris 2.9 on a 333 mHz single-sparc processor, 128 mbytes.

• Rockhopper.

  Linux version 2.4.20-30.9smp
  gcc version 3.2.2
  Red Hat Linux 3.2.2-5
  Memory: 1,310,712k available
  Processors: 2
  Detected 728.493 MHz processor.
  CPU 16K L1 I cache, 16K L1 D cache
  CPU L2 cache: 256K
  

The Results

	Solaris	Linux
Threads	138	12
Processes	9077	722

• All times in microseconds.

• iter = 2000.

Conclusions

• Thread create and delete is cheap.

• Process create and delete is expensive.

• Why not do threads always?

  • Process simplicity, support, and security.

This page last modified on 14 November 2004.