Python multitraitement utilise un seul noyau

Je suis en train de sortir d'un fragment de code de la standard de python de la documentation pour apprendre à utiliser le module multiprocessing. Le code est copié à la fin de ce message.
Je suis à l'aide de Python 2.7.1 sur Ubuntu 11.04 sur un quad core de la machine (qui, selon le système de moniteur me donne huit cœurs en raison de l'hyper threading)

Problème: l'Ensemble de la charge de travail semble être prévue pour juste un noyau, qui est proche de 100% d'utilisation, malgré le fait que plusieurs processus sont lancés. Parfois tous de la charge de travail migre vers une autre base, mais la charge de travail n'est jamais distribué parmi eux.

Des idées pourquoi est-ce si?

Cordialement,

Paul

#
# Simple example which uses a pool of workers to carry out some tasks.
#
# Notice that the results will probably not come out of the output
# queue in the same in the same order as the corresponding tasks were
# put on the input queue.  If it is important to get the results back
# in the original order then consider using `Pool.map()` or
# `Pool.imap()` (which will save on the amount of code needed anyway).
#
# Copyright (c) 2006-2008, R Oudkerk
# All rights reserved.
#
import time
import random
from multiprocessing import Process, Queue, current_process, freeze_support
#
# Function run by worker processes
#
def worker(input, output):
for func, args in iter(input.get, 'STOP'):
result = calculate(func, args)
output.put(result)
#
# Function used to calculate result
#
def calculate(func, args):
result = func(*args)
return '%s says that %s%s = %s' % \
(current_process().name, func.__name__, args, result)
#
# Functions referenced by tasks
#
def mul(a, b):
time.sleep(0.5*random.random())
return a * b
def plus(a, b):
time.sleep(0.5*random.random())
return a + b
def test():
NUMBER_OF_PROCESSES = 4
TASKS1 = [(mul, (i, 7)) for i in range(500)]
TASKS2 = [(plus, (i, 8)) for i in range(250)]
# Create queues
task_queue = Queue()
done_queue = Queue()
# Submit tasks
for task in TASKS1:
task_queue.put(task)
# Start worker processes
for i in range(NUMBER_OF_PROCESSES):
Process(target=worker, args=(task_queue, done_queue)).start()
# Get and print results
print 'Unordered results:'
for i in range(len(TASKS1)):
print '\t', done_queue.get()
# Add more tasks using `put()`
for task in TASKS2:
task_queue.put(task)
# Get and print some more results
for i in range(len(TASKS2)):
print '\t', done_queue.get()
# Tell child processes to stop
for i in range(NUMBER_OF_PROCESSES):
task_queue.put('STOP')
test()
  • Ce post pourrait être utile à vous, stackoverflow.com/questions/5784389/...
  • Copier et coller votre code Maxed d'un processeur Intel Pentium D 3.4 GHZ en deux/deux proc écrans.
  • Avec ces dort() là, ce ne sera pas générer beaucoup de charge CPU à tous.
  • Vrai. J'ai supprimé l'dort et augmenté le nombre d'emplois à 10000, mais la charge de travail est encore jamais distribué entre les cœurs. Si je commence à 4 processus-je obtenir trois de couchage processus et un pleinement utilisées. Merci de votre aide les gars, mais je ne pouvais pas obtenir beaucoup hors de Devrajs lien. Je comprends que, à partir de 4 processus n'est pas une garantie qu'ils seront divisés entre les cœurs, mais la cause de cette polarisée comportement que tous les processus sauf un est le sommeil n'est pas clair pour moi.
  • Encore, avec 10000 emplois, n'est-ce pas le travail fait ici allé assez vite ? Quand je fais un peu de mesure sur ce programme (assurez-vous de retirer tous vos boucles d'imprimer quelque chose, vous ne pas vous voulez à mesure de l'impression à l'écran...), ce programme passe énormément de temps à faire la liste de compréhension, et la farce des choses sur le task_queue. Qui prend 100% du CPU d'un processeur pendant un certain temps. Quand vous commencez à les travailleurs, les choses commencent à utiliser les autres processeurs, Mais avec seulement 10000 les itmes, qui va être fait sur une seconde ou deux, essayez de 200000.
  • tout d'abord, créez un nouveau script Python et à la conception d'une fonction qui s'exécute sur un seul thread/processus, qui prend 100% du CPU lors de l'exécution, et qui ne prend que quelques secondes. Après cela, utilisez cette fonction avec multiprocessing.

InformationsquelleAutor Paul | 2011-08-01