Il s'agit de la commande PDL::ParallelCPUp qui peut être exécutée dans le fournisseur d'hébergement gratuit OnWorks en utilisant l'un de nos multiples postes de travail en ligne gratuits tels que Ubuntu Online, Fedora Online, l'émulateur en ligne Windows ou l'émulateur en ligne MAC OS.
PROGRAMME:
Nom
PDL::ParallelCPU - Prise en charge du multithreading du processeur parallèle dans PDL (expérimental)
DESCRIPTION
PDL prend en charge (actuellement expérimental) la répartition du traitement numérique entre
plusieurs threads de processeur parallèles (ou pthreads) en utilisant le set_autopthread_targ et
set_autopthread_size les fonctions. Cela peut améliorer les performances de traitement (de plus de
2-4X dans la plupart des cas) en tirant parti des machines multicœurs et/ou multiprocesseurs.
SYNOPSIS
utiliser PDL ;
# Définir la cible de 4 pthreads parallèles à créer, avec une limite inférieure de
# Éléments 5Meg pour diviser le traitement en pthreads parallèles.
set_autopthread_targ(4);
set_autopthread_size(5);
$a = zéros (5000,5000 25 XNUMX) ; # Créer un tableau d'éléments de XNUMX Mo
$b = $a + 5 ; # Le traitement sera divisé en plusieurs pthreads
# Obtenez le nombre réel de pthreads pour le dernier
# opération de traitement.
$actualPthreads = get_autopthread_actual();
Terminologie
L'utilisation du terme filetage peut prêter à confusion avec PDL, car il peut faire référence à PDL
filetage, tel que défini dans la documentation PDL::Threading, ou pour processeur multi-threading.
Pour réduire la confusion avec la terminologie de thread PDL existante, ce document utilise
pthreading se référer à processeur multi-threading, qui est l'utilisation de plusieurs processeurs
threads pour diviser le traitement numérique en opérations parallèles.
Les fonctions qui des bactéries PDL PThreads
Ceci est une brève liste et une description des fonctions de pthreading PDL, voir le PDL::Core
docs pour des informations détaillées.
set_autopthread_targ
Définissez le nombre cible de threads de processeur (pthreads) pour le traitement multithread.
Définir auto_pthread_targ sur 0 signifie qu’aucun pthreading ne se produira.
Voir PDL :: Core pour plus de détails.
set_autopthread_size
Définir la taille minimale (en Meg-éléments ou 2**20 éléments) du plus grand PDL impliqué
dans une fonction où le threading automatique sera effectué. Pour les petits PDL, c'est probablement
ne vaut pas la peine de démarrer plusieurs pthreads, cette fonction est donc utilisée pour définir un minimum
seuil où le threading automatique ne sera pas tenté.
Voir PDL :: Core pour plus de détails.
get_autopthread_actual
Obtenez le nombre réel de pthreads exécutés pour la dernière fonction de traitement pdl.
Voir PDL::get_autopthread_actual pour plus de détails.
Global Contrôle of PDL PThreading en utilisant Environnement Variables
PDL PThreading peut être activé globalement, sans modifier le code existant en définissant
Variables d'environnement PDL_AUTOPTHREAD_TARG et PDL_AUTOPTHREAD_SIZE avant d'exécuter un PDL
scénario. Ces variables d'environnement sont vérifiées au démarrage de PDL et appelle
set_autopthread_targ et set_autopthread_size fonctions réalisées avec l'environnement
les valeurs de la variable.
Par exemple, si l'environnement var PDL_AUTOPTHREAD_TARG est fixé à 3, et
PDL_AUTOPTHREAD_SIZE est défini sur 10, alors tout script pdl s'exécutera comme si les lignes suivantes
étaient en tête du fichier :
set_autopthread_targ(3);
set_autopthread_size(10);
Comment la It Accès
Le processus de pthreading automatique fonctionne en analysant les dimensions du tableau de threads dans les opérations PDL.
et diviser le traitement en fonction des dimensions des filetages et du nombre souhaité de
pthreads (c'est-à-dire la cible pthread ou pthread_targ). Les décalages et incréments que PDL
utilise pour parcourir les données en mémoire sont modifiés pour chaque pthread afin que chacun voie un
ensemble de données différent lors de l’exécution du traitement.
Exemple
$a = séquence(20,4,3); # Petit tableau 3D, taille 20,4,3
# Configurer le threading automatique :
set_autopthread_targ(2); # Cible de 2 pthreads
set_autopthread_size(0); # Zéro pour que les petits PDL de cet exemple soient pthreadés
# Ceci sera divisé en 2 pthreads
$c = maximum($a);
Pour l'exemple ci-dessus, le maximales la fonction a une signature de "(a(n); [o]c())", qui
signifie que la première dimension de $a (taille 20) est un Core dimension de la maximales
fonction. Les autres dimensions de $a (taille 4,3) sont fileté dimensions (c'est-à-dire sera
enfilé dans le maximales la fonction.
L'algorithme de filetage automatique examine les dimensions filetées de taille (4,3) et sélectionne les 4
dimension, puisqu'elle est également divisible par l'autopthread_targ de 2. Le traitement de
la fonction maximale est ensuite divisée en deux pthreads sur la dimension taille 4, avec dim
index 0,2 traités par un pthread
et les index faibles 1,3 traités par l'autre pthread.
Limites
Must avons POSIX Threads Activé
Auto-PThreading ne fonctionne que si votre installation PDL a été compilée avec des threads POSIX
activé. C'est normalement le cas si vous utilisez Linux ou d'autres variantes d'Unix.
Non-Threadsafe Code
Toutes les bibliothèques avec lesquelles PDL s'interface ne sont pas thread-safe, c'est-à-dire qu'elles ne sont pas écrites dans
fonctionner dans un environnement multithread sans planter ni provoquer d’effets secondaires. Quelques
exemples dans le noyau PDL est le fft fonction et le pnmout fonctions.
Pour fonctionner correctement avec ce type de fonctions, le flag PPCode Pas de fil a été
introduit pour indiquer une fonction comme pas étant pthread-safe. Voir la documentation PDL::PP pour plus de détails.
Taille of PDL Dimensions et PThread Cible
En raison de la manière dont un PDL est divisé pour fonctionner à l'aide de plusieurs pthreads, la taille d'un
la dimension doit être divisible également par la cible pthread. Par exemple, si un PDL a
dimensions filetées de (4,3,3) et les auto_pthread_targ a été réglé sur 2, alors le
la première dimension filetée (taille 4) sera sélectionnée pour être divisée en deux fils de taille
2 et 2. Cependant, si les dimensions filetées sont (3,3,3) et que le auto_pthread_targ is
toujours 2, alors le pthreading n'aura pas lieu, car aucune dimension filetée n'est divisible par 2.
L'algorithme qui sélectionne le nombre réel de pthreads a une certaine intelligence (mais pourrait probablement
être amélioré) pour ajuster à la baisse par rapport au auto_pthread_targ pour obtenir un certain nombre de pthreads qui
peut diviser uniformément l'une des dimensions filetées. Par exemple, si un PDL a threadé
dimensions de (9,2,2) et les auto_pthread_targ est 4, l'algorithme verra que non
la dimension est divisible par 4, puis ajustez la cible à 3, ce qui entraîne une division
la première dimension filetée (taille 9) en 3 fils.
Vitesse amélioration pourrait be moins que vous attendre.
Si vous avez une machine à 8 cœurs et appelez auto_pthread_targ avec 8 pour générer 8 parallèles
pthreads, vous n'obtiendrez probablement pas une amélioration de vitesse de 8 fois, en raison de la bande passante mémoire
problèmes. Même si vous disposez de 8 processeurs distincts qui traitent les données, vous aurez (par exemple)
architectures de machines les plus courantes) la RAM commune qui devient désormais votre goulot d'étranglement. Pour simple
calculs (par exemple des ajouts simples), vous pouvez rencontrer une limite de performance à environ
4 fils. Pour des calculs plus complexes, la limite sera plus élevée.
DROIT D'AUTEUR
Copyright 2011 John Cerney. Vous pouvez diffuser et/ou modifier ce document sous le même
termes comme la licence Perl actuelle.
Voir: http://dev.perl.org/licenses/
Utilisez PDL :: ParallelCPUp en ligne à l'aide des services onworks.net
