Paralléliser boucle while avec OpenMP

Comme thiton mentionné, ce code peut être I/O délimitée. Cependant, ces jours-ci de nombreux ordinateurs peuvent avoir des disques Ssd et à haut débit des disques RAID. Dans de tels cas, vous pouvez obtenir de l'accélération de la parallélisation. En outre, si le calcul n'est pas anodin, alors paralléliser les victoires. Même si le I/O est effectivement sérialisé en raison jusqu'à la saturation de la bande passante, vous pouvez toujours obtenir de l'accélération en distribuant le calcul de multicœur.

---

Revenir à la question elle-même, vous pouvez parallélisation de cette boucle par OpenMP. Avec stdin, je n'ai aucune idée de paralléliser parce qu'il doit lire dans l'ordre, et sans information préalable de la fin. Toutefois, si vous travaillez habituellement, un fichier, vous pouvez le faire.

Voici mon code avec omp parallel. J'ai utilisé une API Win32 et MSVC CRT:

void test_io2()
{
const static int BUFFER_SIZE = 1024;
const static int CONCURRENCY = 4;
uint64_t local_checksums[CONCURRENCY];
uint64_t local_reads[CONCURRENCY];
DWORD start = GetTickCount();
omp_set_num_threads(CONCURRENCY);
#pragma omp parallel
{
int tid = omp_get_thread_num();
FILE* file = fopen("huge_file.dat", "rb");
_fseeki64(file, 0, SEEK_END);
uint64_t total_size = _ftelli64(file);
uint64_t my_start_pos = total_size/CONCURRENCY * tid;
uint64_t my_end_pos   = min((total_size/CONCURRENCY * (tid + 1)), total_size);
uint64_t my_read_size = my_end_pos - my_start_pos;
_fseeki64(file, my_start_pos, SEEK_SET);
char* buffer = new char[BUFFER_SIZE];
uint64_t local_checksum = 0;
uint64_t local_read = 0;
size_t read_bytes;
while ((read_bytes = fread(buffer, 1, min(my_read_size, BUFFER_SIZE), file)) != 0 &&
my_read_size != 0)
{
local_read += read_bytes;
my_read_size -= read_bytes;
for (int i = 0; i < read_bytes; ++i)
local_checksum += (buffer[i]);
}
local_checksums[tid] = local_checksum;
local_reads[tid]     = local_read;
fclose(file);
}
uint64_t checksum = 0;
uint64_t total_read = 0;
for (int i = 0; i < CONCURRENCY; ++i)
checksum += local_checksums[i], total_read += local_reads[i];
std::cout << checksum << std::endl
<< total_read << std::endl
<< double(GetTickCount() - start)/1000. << std::endl;
}

Ce code ressemble un peu sale parce que j'avais besoin précisément de répartir le montant du fichier à lire. Toutefois, le code est assez simple. Une chose à garder à l'esprit est que vous devez avoir par thread pointeur de fichier. Vous ne pouvez pas tout simplement partager un pointeur de fichier en raison de la structure de données interne ne peut pas être thread-safe. En outre, ce code peut être parallélisée par parallel for. Mais, je pense que cette approche est plus naturel.

---

Simple des résultats expérimentaux

J'ai testé ce code pour lire un fichier de 10 go sur un disque dur (WD Green 2 to) et un SSD (Intel 120 GO).

Avec un disque dur, oui, pas d'accélérations ont été obtenus. Même ralentissement a été observé. Cela montre clairement que ce code est I/O délimitée. Ce code a pratiquement aucun calcul. Just I/O.

Cependant, avec un SSD, j'ai eu une accélération de 1,2 avec 4 cœurs. Oui, l'accélération est faible. Mais, vous pouvez toujours obtenir avec SSD. Et, si le calcul devient un peu plus (je viens de mettre sur un très court occupé-boucle d'attente), la vitesse serait importante. J'ai été en mesure d'obtenir gain de 2,5.

---

En somme, je voudrais vous recommandons d'essayer de paralléliser ce code.

Aussi, si le calcul n'est pas anodin, je vous recommande pipelining. Le code ci-dessus simplement se divise en plusieurs gros morceaux, provoquant une faible efficacité de la mémoire cache. Cependant, d'un pipeline de parallélisation peut donner une meilleure utilisation du cache. Essayez d'utiliser TBB pour le pipeline de parallélisation. Ils fournissent un moyen simple de pipeline de construire.

OriginalL'auteur minjang