2.6.1 Speedup and efficiency Usually the best we can hope to do is to equally divide the work among the cores, while at the same time introducing no additional work for the cores. If we succeed in doing this, and we run our program with p cores, one thread or process on each core, then our parallel program will run p times faster than the serial program. If we call the serial run-time Tserial and our parallel run-time Tparallel, then the best we can hope for is Tparallel = Tserial/p. When this happens, we say that our parallel program has linear speedup. In practice, we’re unlikely to get linear speedup because the use of multiple processes/threads almost invariably introduces some overhead. For example, shared-memory programs will almost always have critical sections, which will require that we use some mutual exclusion mechanism such as a mutex. The calls to the mutex functions are overhead that’s not present in the serial program, and the use of the mutex forces the parallel program to serialize execution of the critical section. Distributed-memory programs will almost always need to transmit data across the network, which is usually much slower than local memory access. Serial programs, on the other hand, won’t have these overheads. Thus, it will be very unusual for us to find that our parallel programs get linear speedup. Furthermore, it’s likely that the overheads will increase as we increase the number of processes or threads, that is, more threads will probably mean more threads need to access a critical section. More processes will probably mean more data needs to be transmitted across the network. So if we define the speedup of a parallel program to be: then linear speedup has S = p, which is unusual. Furthermore, as p increases, we expect S to become a smaller and smaller fraction of the ideal, linear speedup p. Another way of saying this is that S/p will probably get smaller and smaller as p increases. Table 2.4 shows an example of the changes in S and S/p as p increases.1 This value, S/p, is sometimes called the efficiency of the parallel program. If we substitute the formula for S, we see that the efficiency is: It’s clear that Tparallel, S, and E depend on p, the number of processes or threads. We also need to keep in mind that Tparallel, S, E, and Tserial all depend on the problem size. For example, if we halve and double the problem size of the program whose speedups are shown in Table 2.4, we get the speedups and efficiencies shown in Table 2.5. The speedups are plotted in Figure 2.18, and the efficiencies are plotted in Figure 2.19. We see that in this example, when we increase the problem size, the speedups and the efficiencies increase, while they decrease when we decrease the problem size. This behavior is quite common. Many parallel programs are developed by dividing the work of the serial program among the processes/threads and adding in the necessary “parallel overhead” such as mutual exclusion or communication. Therefore, if Toverhead denotes this parallel overhead, it’s often the case that: Furthermore, as the problem size is increased, Toverhead often grows more slowly than Tserial. When this is the case the speedup and the efficiency will increase. See Exercise 2.16. This is what your intuition should tell you: there’s more work for the processes/threads to do, so the relative amount of time spent coordinating the work of the processes/threads should be less. A final issue to consider is what values of Tserial should be used when reporting speedups and efficiencies. Some authors say that Tserial should be the run-time of the fastest program on the fastest processor available. In practice, most authors use a serial program on which the parallel program was based and run it on a single processor of the parallel system. So if we were studying the performance of a parallel shell sort program, authors in the first group might use a serial radix sort or quicksort on a single core of the fastest system available, while authors in the second group would use a serial shell sort on a single processor of the parallel system. We’ll generally use the second approach.

2.6.1 Aceleración y eficiencia Por lo general, lo mejor que podemos esperar es dividir por igual el trabajo entre los núcleos, mientras que al mismo tiempo no se introduce trabajo adicional para los núcleos. Si lo logramos, y ejecutamos nuestro programa con núcleos, un hilo o proceso en cada núcleo, nuestro programa paralelo se ejecutará p veces más rápido que el programa en serie. Si llamamos al tiempo de ejecución serial Tserial y nuestro tiempo de ejecución paralelo Tparallel, entonces lo mejor que podemos esperar es Tparallel = Tserial / p. Cuando esto sucede, decimos que nuestro programa paralelo tiene una aceleración lineal. En la práctica, es poco probable que obtengamos una aceleración lineal ya que el uso de múltiples procesos / subprocesos casi invariablemente genera cierta sobrecarga. Por ejemplo, los programas de memoria compartida casi siempre tendrán secciones críticas, lo que requerirá que usemos algún mecanismo de exclusión mutua, como un mutex. Las llamadas a las funciones de exclusión mutua son una sobrecarga que no está presente en el programa en serie, y el uso de la exclusión mutua obliga al programa paralelo a serializar la ejecución de la sección crítica. Los programas de memoria distribuida casi siempre necesitarán transmitir datos a través de la red, que suele ser mucho más lento que el acceso a la memoria local. Los programas en serie, por otro lado, no tendrán estos gastos generales. Por lo tanto, será muy inusual para nosotros descubrir que nuestros programas paralelos obtienen una aceleración lineal.Además, es probable que los gastos generales aumenten a medida que aumentamos el número de procesos o subprocesos, es decir, que más subprocesos probablemente significarán que más subprocesos necesitan acceder a una sección crítica. Es probable que más procesos signifiquen que es necesario transmitir más datos a través de la red. Entonces, si definimos la aceleración de un programa paralelo a ser: entonces la aceleración lineal tiene S = p, lo cual es inusual. Además, a medida que aumenta p, esperamos que S se convierta en una fracción cada vez más pequeña de la aceleración lineal ideal p. Otra forma de decir esto es que S / p probablemente se hará cada vez más pequeño a medida que aumenta p. La Tabla 2.4 muestra un ejemplo de los cambios en S y S / p a medida que aumenta p.1 Este valor, S / p, a veces se denomina eficiencia del programa paralelo. Si sustituimos la fórmula por S, vemos que la eficiencia es: Está claro que Tparallel, S y E dependen de p, el número de procesos o subprocesos. También debemos tener en cuenta que Tparallel, S, E y Tserial dependen del tamaño del problema. Por ejemplo, si reducimos a la mitad y duplicamos el tamaño del problema del programa cuyas aceleraciones se muestran en la Tabla 2.4, obtenemos las aceleraciones y eficiencias que se muestran en la Tabla 2.5. Las aceleraciones se representan en la Figura 2.18, y las eficiencias se representan en la Figura 2.19. Vemos que en este ejemplo, cuando aumentamos el tamaño del problema, aumentan las aceleraciones y las eficiencias, mientras que disminuyen cuando disminuimos el tamaño del problema.Este comportamiento es bastante común. Muchos programas paralelos se desarrollan dividiendo el trabajo del programa en serie entre los procesos / subprocesos y agregando la "sobrecarga paralela" necesaria, como la exclusión mutua o la comunicación. Por lo tanto, si Toverhead denota esta sobrecarga paralela, a menudo es el caso que: Además, a medida que aumenta el tamaño del problema, Toverhead a menudo crece más lentamente que Tserial. Cuando este sea el caso, la aceleración y la eficiencia aumentarán. Ver ejercicio 2.16. Esto es lo que su intuición debería decirle: hay más trabajo para los procesos / subprocesos, por lo que la cantidad relativa de tiempo dedicado a coordinar el trabajo de los procesos / subprocesos debería ser menor. Un último problema a considerar es qué valores de Tserial deben usarse al informar sobre aceleraciones y eficiencias. Algunos autores dicen que Tserial debería ser el tiempo de ejecución del programa más rápido en el procesador más rápido disponible. En la práctica, la mayoría de los autores utilizan un programa en serie en el que se basó el programa paralelo y lo ejecutan en un solo procesador del sistema paralelo. Por lo tanto, si estuviéramos estudiando el rendimiento de un programa de clasificación de shell paralelo, los autores del primer grupo podrían usar una clasificación de serie en serie o un pedido rápido en un solo núcleo del sistema más rápido disponible, mientras que los autores del segundo grupo usarían una clasificación de shell en serie Un solo procesador del sistema paralelo. Generalmente usaremos el segundo enfoque.