def client(ip, port):
# Creo una socket e provo a connettermi al server all'indirizzo IP
# e porta PORT.
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((ip, port))
except Exception as e:
print("Client: server closed ... leaving")
sys.exit(0)
try:
# Leggo la lista di numeri da fattorizzare, serializzata da
# PACK e la de-serializzo con UNPACK.
data = sock.recv(1024)
if not data:
return
data = unpack(data)
print("Client %s\ngot range: %d-%d" % (os.getpid(), data[0], data[-1]))
# Calcolo i fattori, li metto nel dizionario come valori dei
# numeri, serializzo tutto, lo mando al server e poi saluto e
# vado.
d = dict()
for n in data:
ff = factorize_naive(n)
d.update({n: ff}) # dict via comprehension!
sock.send(pack(d)) # deserializzo
finally:
sock.close()
def client(ip, port):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((ip, port))
except Exception as e:
print("Client: server closed ... leaving")
sys.exit(0)
try:
# Leggo la lista di numeri da fattorizzare, rappresentata come
# stringa da "repr".
data = sock.recv(1024)
if not data:
return
# Passo dalla stringa all'oggetto (undo di repr)
data = eval(data)
print("Client %s\ngot range: %d-%d" % (os.getpid(), data[0], data[-1]))
# Calcolo i fattori, li metto nel dizionario come valori dei
# numeri, poi mando il repr del dizionario al server e poi
# saluto e vado.
d = dict()
for n in data:
ff = factorize_naive(n)
d.update({n: ff})
sock.send(repr(d))
finally:
sock.close()
def worker(nums, outdict):
""" The worker function, invoked in a thread. 'nums' is a
list of numbers to factor. The results are placed in
outdict.
"""
for n in nums:
outdict[n] = factorize_naive(n)
def factorizer_worker(job_q, res_q):
while not job_q.empty():
try:
job = job_q.get()
out_dict = {n: factorize_naive(n) for n in job}
res_q.put(out_dict)
except Queue.Empty:
return
def factorizer_worker(job_q, result_q):
myname = multiprocessing.current_process().name
while True:
try:
job = job_q.get_nowait()
#print '%s got %s nums...' % (myname, len(job))
outdict = {n: factorize_naive(n) for n in job}
result_q.put(outdict)
#print ' %s done' % myname
except Queue.Empty:
return
def factorizer_worker(job_q, res_q):
# Prendo da JOB_Q i numeri da fattorizzare, ne calcolo i fattori
# con factorize_naive ed inserisco il risultato (un dizionario)
# nella coda RES_Q. Questa è una semplice funzione che non ha
# nulla a che vedere con multi processi.
while True:
try:
job = job_q.get_nowait()
out_dict = {n: factorize_naive(n) for n in job}
res_q.put(out_dict)
except Queue.Empty:
return
def client(ip, port):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip, port))
try:
data = sock.recv(1024)
if not data:
return
data = eval(data)
print("Client %s\ngot: '%s'" % (os.getpid(), data))
d = dict()
for n in data:
ff = factorize_naive(n)
# print (ff)
d.update({n: ff})
sock.send(repr(d))
finally:
sock.close()
def server(port, max_queue=5):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("", port))
sock.listen(max_queue)
while 1:
conn, addr = sock.accept()
try:
print("Got connection from %s" % str(addr))
while 1:
data = conn.recv(1024).strip()
print("Server got: '%s'" % data)
if not data:
break
if data == "quit":
conn.close()
return
data = factorize_naive(int(data))
conn.send(repr(data))
finally:
conn.close()
return
def serial_factorizer(nums):
return {n: factorize_naive(n) for n in nums}