Como posso fazer o multiprocessing.pool.map distribuir processos em ordem numérica?

Mais informações:
Eu tenho um programa que processa alguns milhares de arquivos de dados, fazendo um gráfico de cada um. Estou usando ummultiprocessing.pool.map para distribuir cada arquivo para um processador e funciona muito bem. Às vezes isso leva muito tempo, e seria bom olhar para as imagens de saída enquanto o programa está sendo executado. Isso seria muito mais fácil se o processo de mapa distribuísse os instantâneos em ordem; Em vez disso, para a execução específica que acabei de executar, os 8 primeiros instantâneos analisados ​​foram:0, 78, 156, 234, 312, 390, 468, 546. Existe uma maneira de distribuí-los mais de perto em ordem numérica?

Exemplo:
Aqui está um código de exemplo que contém os mesmos elementos-chave e mostra o mesmo resultado básico:

import sys
from multiprocessing import Pool
import time

num_proc  = 4; num_calls = 20; sleeper   = 0.1

def SomeFunc(arg):
    time.sleep(sleeper)
    print "%5d" % (arg),
    sys.stdout.flush()     # otherwise doesn't print properly on single line

proc_pool = Pool(num_proc)
proc_pool.map( SomeFunc, range(num_calls) )

Rendimentos:

   0  4  2  6   1   5   3   7   8  10  12  14  13  11   9  15  16  18  17  19

Responda:

De @Hayden: use o parâmetro 'chunksize',def map(self, func, iterable, chunksize=None).

Mais informações:
ochunksize determina quantas iterações são alocadas para cada processador por vez. Meu exemplo acima, por exemplo, usa um chunksize de 2 --- o que significa que cada processador se apaga e faz o que quer por 2 iterações da função, depois volta para mais ('check-in'). O trade-off por trás do chunksize é que há sobrecarga para o 'check-in' quando o processador tem que sincronizar com os outros --- sugerindo que você quer umgrande chunksize. Por outro lado, se você tem grandes pedaços, então um processador pode terminar seu pedaço enquanto outro tem um longo tempo de sobra para ir --- então você deve usar umpequeno chunksize. Eu acho que a informação útil adicional é quanto alcance existe, em quanto tempo cada chamada de função pode levar. Se eles realmente devem ter a mesma quantidade de tempo - é muito mais eficiente usar um grande tamanho de bloco. Por outro lado, se algumas chamadas de função puderem levar o dobro de outras, você precisará de um pequeno chunksize para que os processadores não fiquem presos.

Para o meu problema, cada chamada de função deve levar muito perto da mesma quantidade de tempo (eu acho), então se eu quiser que os processos sejam chamados em ordem, vou sacrificar a eficiência por causa da sobrecarga de check-in.