Python性能 - 最佳并行方法

时间：2016-10-24 15:58:57

标签： python multithreading performance multiprocessing gil

我正在实现一个Python脚本，需要在不到5秒的时间内并行发送1500多个数据包。

简而言之，我需要的是：

def send_pkts(ip):
    #craft packet
    while True:
        #send packet
        time.sleep(randint(0,3))

for x in list[:1500]:
    send_pkts(x)
    time.sleep(randint(1,5))

我尝试过简单的单线程，多线程，多处理和多处理+多线程表单，并遇到以下问题：

  1. 简单的单线程： ＆＃34; 延迟＆＃34;似乎妥协了＃5; 5秒＆＃34;依赖性。
  2. 多线程： 由于Python GIL的限制，我认为我无法实现我的目标。
  3. 多处理： 这是似乎有效的最佳方法。但是，由于进程数量过多，我运行脚本的VM会冻结（当然，1500进程正在运行）。因而变得不切实际。
  4. 多重处理多线程+： 在这种方法中，我创建了较少的进程，每个进程调用一些线程（假设：10进程每个调用150个线程）。很明显，VM没有像第3号方法一样快速冻结，但最常见的并发数据包发送＆＃34;我可以达到~800。 GIL限制？ VM限制？ 在这次尝试中，我也尝试使用Process Pool，但结果类似。

    5. 我可以用更好的方法来完成这项任务吗？

    [1]编辑1：

     def send_pkt(x):
     #craft pkt
     while True:
         #send pkt
         gevent.sleep(0)

 gevent.joinall([gevent.spawn(send_pkt, x) for x in list[:1500]])

    [2]编辑2（gevent monkey-patching）：

    from gevent import monkey; monkey.patch_all()

jobs = [gevent.spawn(send_pkt, x) for x in list[:1500]]
gevent.wait(jobs)
#for send_pkt(x) check [1]

    但是我收到以下错误：＆＃34; ValueError：filedescriptor超出了select（）＆＃34; 的范围。所以我检查了我的系统ulimit（软和硬都是最大值：65536）。 之后，我检查了它与Linux上的 select（）限制有关（最多1024 fds）。请检查：http://man7.org/linux/man-pages/man2/select.2.html（BUGS部分） - 为了解决这个问题，我应该使用 poll（）（http://man7.org/linux/man-pages/man2/poll.2.html）代替。但是使用 poll（）我会回到相同的限制：因为轮询是一种阻止方法＆＃34;。

    此致

5 个答案:

答案 0 :(得分：1)

在 Python 中使用并行性时，一个好的方法是使用 ThreadPoolExecutor 或 ProcessPoolExecutor 从 https://docs.python.org/3/library/concurrent.futures.html#module-concurrent.futures 根据我的经验，这些效果很好。

可以适应您使用的 threadedPoolExecutor 示例。

import concurrent.futures
import urllib.request
import time

IPs= ['168.212. 226.204',
        '168.212. 226.204',
        '168.212. 226.204',
        '168.212. 226.204',
        '168.212. 226.204']

def send_pkt(x):
  status = 'Failed'
  while True:
    #send pkt
    time.sleep(10)
    status = 'Successful'
    break
  return status

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    future_to_ip = {executor.submit(send_pkt, ip): ip for ip in IPs}
    for future in concurrent.futures.as_completed(future_to_ip):
        ip = future_to_ip[future]
        try:
            data = future.result()
        except Exception as exc:
            print('%r generated an exception: %s' % (ip, exc))
        else:
            print('%r send %s' % (url, data))

答案 1 :(得分：0)

您在选项3中的结果：“由于进程过多，我正在运行脚本的VM冻结（当然，正在运行1500个进程）”可能需要进一步调查。我认为，从到目前为止收集的信息来看，这是否可能更好地归因于多处理方法的缺点或VM的局限性。

一种相当简单明了的方法是进行扩展实验：不是让所有发送都来自单个进程，要么让所有发送都来自同一进程，请尝试使用中间值。将两个工作之间的工作负载分成两半（即4、8）的时间。

这样做的同时，最好在Windows上运行xperf或在Linux上运行oprofile之类的工具来记录这些不同的并行性选择是否导致不同类型的瓶颈，因为例如破坏CPU缓存，运行VM内存不足或其他人知道。最简单的说法就是尝试一下。

根据以前对这些类型问题的经验和一般经验法则，我希望当多处理进程的数量小于或等于可用CPU内核数量（在VM本身上）时，可以获得最佳性能。或在管理程序上）。但是，那是假设问题是受CPU限制的。如果在数据包发送过程中发生某些阻塞，并且与其他阻塞操作交错使用，则可以更好地利用CPU时间，那么与#cpu进程相比，性能可能仍会更高。再说一次，直到完成一些性能分析和/或缩放实验，我们才知道。

答案 2 :(得分：0)

您正确地认为python是单线程的，但是将您想要的任务（发送网络数据包）视为IO绑定操作，因此是多线程的理想选择。只要您在编写代码时就牢记异步，那么在数据包传输时，您的主线程不会很忙。

看看异步tcp网络上的python文档-https://docs.python.org/3/library/asyncio-protocol.html#tcp-echo-client。

答案 3 :(得分：0)

如果瓶颈是基于 http（“发送数据包”），那么 GIL 实际上不应该是太大的问题。

如果在 python 中也有计算，那么 GIL 可能会妨碍，正如你所说，基于进程的并行性将是首选。

每个任务不需要一个进程！这似乎是你思维中的疏忽。使用 python 的 Pool 类，您可以轻松创建一组将从队列中接收任务的工作线程。


import multiprocessing


def send_pkts(ip):
   ...


number_of_workers = 8

with multiprocessing.Pool(number_of_workers) as pool:
    pool.map(send_pkts, list[:1500])

您现在正在运行 number_of_workers + 1 个进程（worker + 原始进程）并且 N 个 worker 同时运行 send_pkts 函数。

答案 4 :(得分：0)

阻碍您实现所需性能的主要问题是 send_pkts() 方法。它不仅发送数据包，还制作数据包：

def send_pkts(ip):
#craft packet
while True:
    #send packet
    time.sleep(randint(0,3))

虽然发送数据包几乎肯定是 I/O 密集型任务，但制作数据包几乎肯定是 CPU 密集型任务。这个方法需要拆分成两个任务：

  1. 制作一个数据包
  2. 发送数据包

我编写了一个基本的套接字服务器和一个客户端应用程序，用于制作数据包并将其发送到服务器。这个想法是有一个单独的过程来制作数据包并将它们放入队列中。有一个线程池与数据包制作过程共享队列。这些线程从队列中取出数据包并将它们发送到服务器。他们还将服务器的响应粘贴到另一个共享队列中，但这仅用于我自己的测试，与您尝试执行的操作无关。当线程从队列中获得 None (poison pill) 时退出。

server.py:

import argparse
import socketserver
import time


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--host", type=str, help="bind to host")
    parser.add_argument("--port", type=int, help="bind to port")
    parser.add_argument("--packet-size", type=int, help="size of packets")
    args = parser.parse_args()
    HOST, PORT = args.host, args.port

    class MyTCPHandler(socketserver.BaseRequestHandler):
        def handle(self):
            time.sleep(1.5)
            data = self.request.recv(args.packet_size)
            self.request.sendall(data.upper())

    with socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler) as server:
        server.serve_forever()

client.py：

import argparse
import logging
import multiprocessing as mp
import os
import queue as q
import socket
import time
from threading import Thread


def get_logger():
    logger = logging.getLogger("threading_example")
    logger.setLevel(logging.INFO)

    fh = logging.FileHandler("client.log")
    fmt = '%(asctime)s - %(threadName)s - %(levelname)s - %(message)s'
    formatter = logging.Formatter(fmt)
    fh.setFormatter(formatter)

    logger.addHandler(fh)
    return logger


class PacketMaker(mp.Process):
    def __init__(self, result_queue, max_packets, packet_size, num_poison_pills, logger):
        mp.Process.__init__(self)
        self.result_queue = result_queue
        self.max_packets = max_packets
        self.packet_size = packet_size
        self.num_poison_pills = num_poison_pills
        self.num_packets_made = 0
        self.logger = logger

    def run(self):
        while True:
            if self.num_packets_made >= self.max_packets:
                for _ in range(self.num_poison_pills):
                    self.result_queue.put(None, timeout=1)
                self.logger.debug('PacketMaker exiting')
                return
            self.result_queue.put(os.urandom(self.packet_size), timeout=1)
            self.num_packets_made += 1


class PacketSender(Thread):
    def __init__(self, task_queue, result_queue, addr, packet_size, logger):
        Thread.__init__(self)
        self.task_queue = task_queue
        self.result_queue = result_queue
        self.server_addr = addr
        self.packet_size = packet_size
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect(addr)
        self.logger = logger

    def run(self):
        while True:
            packet = self.task_queue.get(timeout=1)
            if packet is None:
                self.logger.debug("PacketSender exiting")
                return
            try:
                self.sock.sendall(packet)
                response = self.sock.recv(self.packet_size)
            except socket.error:
                self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                self.sock.connect(self.server_addr)
                self.sock.sendall(packet)
                response = self.sock.recv(self.packet_size)
            self.result_queue.put(response)


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--num-packets', type=int, help='number of packets to send')
    parser.add_argument('--packet-size', type=int, help='packet size in bytes')
    parser.add_argument('--num-threads', type=int, help='number of threads sending packets')
    parser.add_argument('--host', type=str, help='name of host packets will be sent to')
    parser.add_argument('--port', type=int, help='port number of host packets will be sent to')
    args = parser.parse_args()

    logger = get_logger()
    logger.info(f"starting script with args {args}")
    
    packets_to_send = mp.Queue(args.num_packets + args.num_threads)
    packets_received = q.Queue(args.num_packets)
    producers = [PacketMaker(packets_to_send, args.num_packets, args.packet_size, args.num_threads, logger)]
    senders = [PacketSender(packets_to_send, packets_received, (args.host, args.port), args.packet_size, logger)
               for _ in range(args.num_threads)]
    start_time = time.time()
    logger.info("starting workers")
    for worker in senders + producers:
        worker.start()
    for worker in senders:
        worker.join()
    logger.info("workers finished")
    end_time = time.time()
    print(f"{packets_received.qsize()} packets received in {end_time - start_time} seconds")

run.sh:

#!/usr/bin/env bash

for i in "$@"
do
case $i in
    -s=*|--packet-size=*)
    packet_size="${i#*=}"
    shift 
    ;;
    -n=*|--num-packets=*)
    num_packets="${i#*=}"
    shift 
    ;;
    -t=*|--num-threads=*)
    num_threads="${i#*=}"
    shift 
    ;;
    -h=*|--host=*)
    host="${i#*=}"
    shift 
    ;;
    -p=*|--port=*)
    port="${i#*=}"
    shift 
    ;;
    *)
    ;;
esac
done

python3 server.py --host="${host}" \
                  --port="${port}" \
                  --packet-size="${packet_size}" &
server_pid=$!
python3 client.py --packet-size="${packet_size}" \
                  --num-packets="${num_packets}" \
                  --num-threads="${num_threads}" \
                  --host="${host}" \
                  --port="${port}"
kill "${server_pid}"
<块引用>

$ ./run.sh -s=1024 -n=1500 -t=300 -h=localhost -p=9999

在 4.70330023765564 秒内收到 1500 个数据包

$ ./run.sh -s=1024 -n=1500 -t=1500 -h=localhost -p=9999

在 1.5025699138641357 秒内收到 1500 个数据包

可以通过将 client.py 中的日志级别更改为 DEBUG 来验证此结果。请注意，脚本的完成时间确实比 4.7 秒要长得多。使用 300 个线程时需要大量拆卸，但日志清楚地表明线程在 4.7 秒内完成处理。

对所有性能结果持保留态度。我不知道你在什么系统上运行这个。我将提供我的相关系统统计信息： 2 至强 X5550 @2.67GHz 24MB DDR3 @1333MHz Debian 10 Python 3.7.3

我会通过您的尝试解决问题：

  1. 简单的单线程：由于 randint(0, 3) 延迟，这几乎保证至少需要 1.5 x num_packets 秒
  2. 多线程：GIL 可能是这里的瓶颈，但这可能是因为 craft packet 部分而不是 send packet
  3. 多处理：每个进程至少需要文件描述符，因此您可能会超出用户或系统限制，但如果您change the appropriate settings
  4. 多处理+多线程：由于与 #2 相同的原因，这会失败，制作数据包可能受 CPU 限制

经验法则是：I/O 限制 - 使用线程，CPU 限制 - 使用进程

相关问题
最新问题