Auto-Parallelization Overview

The auto-parallelization feature of the Intel® compiler automatically translates serial portions of the input program into equivalent multithreaded code. Automatic parallelization determines the loops that are good worksharing candidates, performs the dataflow analysis to verify correct parallel execution, and partitions the data for threaded code generation as needed in programming with OpenMP* directives. The OpenMP and auto-parallelization features provide the performance gains from shared memory on multiprocessor and dual core systems.

The auto-parallelizer analyzes the dataflow of the loops in the application source code and generates multithreaded code for those loops which can safely and efficiently be executed in parallel.

This behavior enables the potential exploitation of the parallel architecture found in symmetric multiprocessor (SMP) systems.

The guided auto-parallelization feature of the Intel® compiler helps you locate portions in your serial code that can be parallelized further. You can invoke guidance for parallelization, vectorization, or data transformation using specified compiler options of the -guide (Linux* OS) or /Qguide (Windows* OS) series.

Automatic parallelization frees developers from having to:

• find loops that are good worksharing candidates

• perform the dataflow analysis to verify correct parallel execution

• partition the data for threaded code generation as is needed in programming with OpenMP* directives.

The parallel run-time support provides run-time features as found in OpenMP*, such as handling the details of loop iteration modification, thread scheduling, and synchronization. You can use the -par-runtime-control (Linux* OS) or the /Qpar-runtime-control (Windows* OS) compiler option to generate code that performs run-time checks for loops that have symbolic loop bounds. The loop is executed in parallel if the granularity of a loop is greater than the parallelization threshold. The parallelization threshold can be set using the -par-threshold (Linux OS) or the /Qpar-threshold (Windows OS) compiler option, which sets a threshold for the auto-parallelization of loops based on the probability of profitable execution of the loop in parallel.

Although OpenMP directives enable serial applications to transform into parallel applications quickly, you must explicitly identify specific portions of your application code that contain parallelism and add the appropriate compiler directives. Auto-parallelization, which is triggered by the -parallel (Linux* OS and OS X*) or /Qparallel (Windows* OS) option, automatically identifies those loop structures that contain parallelism. During compilation, the compiler automatically attempts to deconstruct the code sequences into separate threads for parallel processing. No other effort is needed.

Serial code can be divided so that the code can execute concurrently on multiple threads. For example, consider the following serial code example.

subroutine ser(a, b, c)

  integer, dimension(100) :: a, b, c

  do i=1,100

    a(i) = a(i) + b(i) * c(i)

  enddo

end subroutine ser

The following example illustrates one method showing how the loop iteration space, shown in the previous example, might be divided to execute on two threads.

subroutine par(a, b, c)

  integer, dimension(100) :: a, b, c

  ! Thread 1

  do i=1,50

    a(i) = a(i) + b(i) * c(i)

  enddo

  ! Thread 2

  do i=51,100

    a(i) = a(i) + b(i) * c(i)

  enddo

end subroutine par

DO I = 1, 100     ! Execute groups of iterations in different hreads (TLP)

  DO J = 1, 32    ! Execute in SIMD style with multimedia extension (ILP)

     A(J,I) = A(J,I) + 1

  ENDDO

ENDDO

!OMP$ PARALLEL PRIVATE(NUM), SHARED (X,A,B,C)

! Defines a parallel region  

!OMP$ PARALLEL DO

! Specifies a parallel region that

! implicitly contains a single DO directive

DO I = 1, 1000

  NUM = FOO(B(i), C(I))

  X(I) = BAR(A(I), NUM)

! Assume FOO and BAR have no other effect

ENDDO