การประมวลผลหลายขั้นตอน: การแบ่งปันวัตถุอ่านอย่างเดียวขนาดใหญ่ระหว่างกระบวนการ?

กระบวนการย่อยเกิดขึ้นผ่านอ็อบเจ็กต์การแชร์แบบมัลติโพรเซสเซอร์ที่สร้างขึ้นก่อนหน้านี้ในโปรแกรมหรือไม่

ฉันมีการตั้งค่าต่อไปนี้:

do_some_processing(filename):
    for line in file(filename):
        if line.split(',')[0] in big_lookup_object:
            # something here

if __name__ == '__main__':
    big_lookup_object = marshal.load('file.bin')
    pool = Pool(processes=4)
    print pool.map(do_some_processing, glob.glob('*.data'))

ฉันกำลังโหลดวัตถุขนาดใหญ่ลงในหน่วยความจำจากนั้นสร้างกลุ่มคนงานที่ต้องใช้ประโยชน์จากวัตถุขนาดใหญ่นั้น วัตถุขนาดใหญ่สามารถเข้าถึงได้แบบอ่านอย่างเดียวฉันไม่จำเป็นต้องผ่านการปรับเปลี่ยนระหว่างกระบวนการ

คำถามของฉันคือ: วัตถุขนาดใหญ่ถูกโหลดลงในหน่วยความจำที่ใช้ร่วมกันหรือไม่เช่นเดียวกับที่ฉันสร้างกระบวนการใน unix / c หรือแต่ละกระบวนการโหลดสำเนาของวัตถุขนาดใหญ่ของตัวเองหรือไม่

อัปเดต: เพื่อชี้แจงเพิ่มเติม - big_lookup_object เป็นวัตถุการค้นหาที่ใช้ร่วมกัน ฉันไม่จำเป็นต้องแยกมันและประมวลผลแยกกัน ฉันต้องการเก็บสำเนาไว้หนึ่งชุด งานที่ฉันต้องแยกคือการอ่านไฟล์ขนาดใหญ่อื่น ๆ จำนวนมากและค้นหารายการในไฟล์ขนาดใหญ่เหล่านั้นเทียบกับวัตถุการค้นหา

อัปเดตเพิ่มเติม: ฐานข้อมูลเป็นทางออกที่ดี memcached อาจเป็นทางออกที่ดีกว่าและไฟล์บนดิสก์ (Shelve หรือ dbm) อาจดีกว่า ในคำถามนี้ฉันสนใจเป็นพิเศษเกี่ยวกับโซลูชันหน่วยความจำ สำหรับวิธีแก้ปัญหาขั้นสุดท้ายฉันจะใช้ hadoop แต่ฉันต้องการดูว่าฉันสามารถมีเวอร์ชันในหน่วยความจำในเครื่องได้หรือไม่

"กระบวนการย่อยเกิดจากออบเจ็กต์การแชร์แบบมัลติโพรเซสเซอร์ที่สร้างขึ้นก่อนหน้านี้ในโปรแกรมหรือไม่"

ไม่ใช่ (python ก่อน 3.8) และใช่ใน 3.8 ( https://docs.python.org/3/library/multiprocessing.shared_memory.html#module-multiprocessing.shared_memory )

โปรเซสมีพื้นที่หน่วยความจำอิสระ

โซลูชันที่ 1

เพื่อให้ได้ประโยชน์สูงสุดจากโครงสร้างขนาดใหญ่ที่มีคนงานจำนวนมากให้ทำเช่นนี้

1. เขียนคนงานแต่ละคนเป็น "ตัวกรอง" - อ่านผลลัพธ์ระดับกลางจาก stdin ทำงานเขียนผลลัพธ์ระดับกลางบน stdout

2. เชื่อมต่อคนงานทั้งหมดเป็นท่อ:

   process1 <source | process2 | process3 | ... | processn >result

แต่ละกระบวนการอ่านทำงานและเขียน

สิ่งนี้มีประสิทธิภาพอย่างน่าทึ่งเนื่องจากกระบวนการทั้งหมดกำลังทำงานพร้อมกัน การเขียนและการอ่านส่งผ่านบัฟเฟอร์ที่ใช้ร่วมกันโดยตรงระหว่างกระบวนการ

โซลูชันที่ 2

ในบางกรณีคุณมีโครงสร้างที่ซับซ้อนมากขึ้นซึ่งมักจะเป็นโครงสร้างแบบ "พัดลมออก" ในกรณีนี้คุณมีพ่อแม่ที่มีลูกหลายคน

1. ผู้ปกครองเปิดข้อมูลต้นทาง ผู้ปกครองเลี้ยงเด็กจำนวนหนึ่ง

2. พาเรนต์อ่านซอร์สฟาร์มบางส่วนของซอร์สให้กับเด็กแต่ละคนที่ทำงานพร้อมกัน

3. เมื่อผู้ปกครองถึงจุดสิ้นสุดให้ปิดท่อ เด็กจบไฟล์และเสร็จสิ้นตามปกติ

ส่วนของเด็กนั้นน่าเขียนเพราะเด็ก ๆ แต่ละคนอ่านได้ง่าย sys.stdinได้ง่าย

พ่อแม่มีเท้าที่น่าสนใจเล็กน้อยในการวางไข่เด็ก ๆ ทุกคนและยึดท่ออย่างเหมาะสม แต่ก็ไม่เลวร้ายเกินไป

Fan-in เป็นโครงสร้างที่ตรงกันข้าม กระบวนการที่ทำงานอย่างอิสระจำนวนมากจำเป็นต้องแทรกข้อมูลเข้าไว้ในกระบวนการทั่วไป นักสะสมไม่ใช่เรื่องง่ายที่จะเขียนเนื่องจากต้องอ่านจากหลายแหล่ง

การอ่านจากท่อที่มีชื่อหลาย ๆ ท่อมักจะทำโดยใช้selectโมดูลเพื่อดูว่าท่อใดมีอินพุตที่รอดำเนินการอยู่

โซลูชันที่ 3

การค้นหาที่ใช้ร่วมกันคือคำจำกัดความของฐานข้อมูล

โซลูชัน 3A - โหลดฐานข้อมูล ให้คนงานประมวลผลข้อมูลในฐานข้อมูล

โซลูชัน 3B - สร้างเซิร์ฟเวอร์ที่ง่ายมากโดยใช้werkzeug (หรือคล้ายกัน) เพื่อจัดเตรียมแอปพลิเคชัน WSGI ที่ตอบสนองต่อ HTTP GET เพื่อให้ผู้ปฏิบัติงานสามารถสืบค้นเซิร์ฟเวอร์ได้

โซลูชันที่ 4

อ็อบเจ็กต์ระบบไฟล์ที่แชร์ Unix OS นำเสนออ็อบเจ็กต์หน่วยความจำที่ใช้ร่วมกัน ไฟล์เหล่านี้เป็นเพียงไฟล์ที่แมปกับหน่วยความจำเพื่อให้การแลกเปลี่ยน I / O เสร็จสิ้นแทนที่จะเป็นการอ่านบัฟเฟอร์ตามแบบแผนเพิ่มเติม

คุณสามารถทำได้จากบริบท Python ได้หลายวิธี

1. เขียนโปรแกรมเริ่มต้นที่ (1) แบ่งวัตถุขนาดมหึมาเดิมของคุณให้เป็นวัตถุขนาดเล็กและ (2) เริ่มต้นคนงานโดยแต่ละชิ้นมีวัตถุขนาดเล็ก วัตถุขนาดเล็กอาจเป็นวัตถุ Python เพื่อประหยัดเวลาในการอ่านไฟล์เล็กน้อย

2. เขียนโปรแกรมเริ่มต้นที่ (1) อ่านออบเจ็กต์ขนาดยักษ์ดั้งเดิมของคุณและเขียนไฟล์ที่มีโครงสร้างหน้าโดยใช้รหัสไบต์โดยใช้seekการดำเนินการเพื่อให้มั่นใจว่าแต่ละส่วนนั้นหาได้ง่ายด้วยการค้นหาง่ายๆ นี่คือสิ่งที่เอ็นจินฐานข้อมูลทำ - แบ่งข้อมูลออกเป็นเพจทำให้แต่ละเพจค้นหาได้ง่ายผ่านไฟล์seek.

   วางไข่คนงานที่สามารถเข้าถึงไฟล์ที่มีโครงสร้างเพจขนาดใหญ่นี้ คนงานแต่ละคนสามารถแสวงหาส่วนที่เกี่ยวข้องและทำงานที่นั่นได้

กระบวนการย่อยเกิดขึ้นผ่านอ็อบเจ็กต์การแชร์แบบมัลติโพรเซสเซอร์ที่สร้างขึ้นก่อนหน้านี้ในโปรแกรมหรือไม่

มันขึ้นอยู่กับ. สำหรับตัวแปรแบบอ่านอย่างเดียวทั่วโลกมักจะพิจารณาเช่นนั้น (นอกเหนือจากหน่วยความจำที่ใช้ไป) อย่างอื่นก็ไม่ควร

เอกสารของการประมวลผลหลายขั้นตอนกล่าวว่า:

Better to inherit than pickle/unpickle

ใน Windows หลายประเภทจากการประมวลผลหลายกระบวนการจำเป็นต้องสามารถเลือกได้เพื่อให้กระบวนการย่อยสามารถใช้งานได้ อย่างไรก็ตามโดยทั่วไปควรหลีกเลี่ยงการส่งวัตถุที่ใช้ร่วมกันไปยังกระบวนการอื่นโดยใช้ไปป์หรือคิว แต่คุณควรจัดเรียงโปรแกรมเพื่อให้กระบวนการที่ต้องการเข้าถึงทรัพยากรที่ใช้ร่วมกันที่สร้างขึ้นจากที่อื่นสามารถสืบทอดจากกระบวนการบรรพบุรุษ

Explicitly pass resources to child processes

บน Unix กระบวนการลูกสามารถใช้ประโยชน์จากทรัพยากรที่ใช้ร่วมกันที่สร้างขึ้นในกระบวนการหลักโดยใช้ทรัพยากรส่วนกลาง อย่างไรก็ตามจะเป็นการดีกว่าที่จะส่งผ่านวัตถุเป็นอาร์กิวเมนต์ไปยังตัวสร้างสำหรับกระบวนการลูก

นอกเหนือจากการทำให้รหัส (อาจ) เข้ากันได้กับ Windows แล้วสิ่งนี้ยังช่วยให้มั่นใจได้ว่าตราบใดที่กระบวนการลูกยังมีชีวิตอยู่วัตถุจะไม่ถูกเก็บรวบรวมในกระบวนการหลัก สิ่งนี้อาจมีความสำคัญหากทรัพยากรบางส่วนถูกปลดปล่อยเมื่อวัตถุเป็นขยะที่รวบรวมในกระบวนการหลัก

Global variables

โปรดทราบว่าหากโค้ดทำงานในกระบวนการลูกพยายามเข้าถึงตัวแปรส่วนกลางค่าที่เห็น (ถ้ามี) อาจไม่เหมือนกับค่าในกระบวนการหลักในขณะที่เรียกว่า Process.start () .

ตัวอย่าง

บน Windows (CPU เดี่ยว):

#!/usr/bin/env python
import os, sys, time
from multiprocessing import Pool

x = 23000 # replace `23` due to small integers share representation
z = []    # integers are immutable, let's try mutable object

def printx(y):
    global x
    if y == 3:
       x = -x
    z.append(y)
    print os.getpid(), x, id(x), z, id(z) 
    print y
    if len(sys.argv) == 2 and sys.argv[1] == "sleep":
       time.sleep(.1) # should make more apparant the effect

if __name__ == '__main__':
    pool = Pool(processes=4)
    pool.map(printx, (1,2,3,4))

ด้วยsleep:

$ python26 test_share.py sleep
2504 23000 11639492 [1] 10774408
1
2564 23000 11639492 [2] 10774408
2
2504 -23000 11639384 [1, 3] 10774408
3
4084 23000 11639492 [4] 10774408
4

ไม่มีsleep:

$ python26 test_share.py
1148 23000 11639492 [1] 10774408
1
1148 23000 11639492 [1, 2] 10774408
2
1148 -23000 11639324 [1, 2, 3] 10774408
3
1148 -23000 11639324 [1, 2, 3, 4] 10774408
4

ส. ล็อตถูกต้อง ทางลัดการประมวลผลหลายขั้นตอนของ Python ช่วยให้คุณมีหน่วยความจำที่แยกจากกันและซ้ำซ้อนได้อย่างมีประสิทธิภาพ

ในระบบ * nix ส่วนใหญ่ใช้การโทรระดับล่างไปที่ os.fork()จะทำให้คุณมีหน่วยความจำ copy-on-write ซึ่งอาจเป็นสิ่งที่คุณคิด ตามทฤษฎีแล้ว AFAIK ในโปรแกรมที่เรียบง่ายที่สุดเท่าที่จะเป็นไปได้คุณสามารถอ่านจากข้อมูลนั้นได้โดยไม่ต้องทำซ้ำ

อย่างไรก็ตามสิ่งต่าง ๆ ไม่ง่ายอย่างนั้นในล่าม Python ข้อมูลออบเจ็กต์และข้อมูลเมตาจะถูกเก็บไว้ในเซ็กเมนต์หน่วยความจำเดียวกันดังนั้นแม้ว่าอ็อบเจ็กต์จะไม่เปลี่ยนแปลง แต่สิ่งที่เหมือนกับตัวนับอ้างอิงสำหรับอ็อบเจ็กต์ที่เพิ่มขึ้นจะทำให้เกิดการเขียนหน่วยความจำดังนั้นจึงเป็นสำเนา โปรแกรม Python เกือบทุกโปรแกรมที่ทำมากกว่า "พิมพ์" สวัสดี "จะทำให้เกิดการเพิ่มขึ้นของจำนวนอ้างอิงดังนั้นคุณจะไม่มีทางตระหนักถึงประโยชน์ของการคัดลอกเมื่อเขียน

แม้ว่าจะมีคนจัดการแฮ็กโซลูชันหน่วยความจำที่ใช้ร่วมกันใน Python ได้ แต่การพยายามประสานการรวบรวมขยะในกระบวนการต่างๆอาจเป็นเรื่องที่เจ็บปวด

หากคุณทำงานภายใต้ Unix พวกเขาอาจใช้อ็อบเจ็กต์เดียวกันร่วมกันเนื่องจากวิธีการทำงานของ fork (กล่าวคือกระบวนการย่อยมีหน่วยความจำแยกกัน แต่เป็นการคัดลอกเมื่อเขียนดังนั้นจึงอาจแชร์ได้ตราบเท่าที่ไม่มีใครแก้ไข) ฉันลองทำสิ่งต่อไปนี้:

import multiprocessing

x = 23

def printx(y):
    print x, id(x)
    print y

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    pool.map(printx, (1,2,3,4))

และได้ผลลัพธ์ต่อไปนี้:

$ ./mtest.py
23 22995656
1
23 22995656
2
23 22995656
3
23 22995656
4

แน่นอนว่านี่ไม่ได้พิสูจน์ว่ายังไม่ได้ทำสำเนา แต่คุณควรจะตรวจสอบได้ว่าในสถานการณ์ของคุณโดยดูที่ผลลัพธ์psเพื่อดูว่าแต่ละกระบวนการย่อยใช้หน่วยความจำจริงเท่าใด

กระบวนการต่างๆมีพื้นที่ที่อยู่ที่แตกต่างกัน เช่นเดียวกับการเรียกใช้อินสแตนซ์ต่างๆของล่าม นั่นคือสิ่งที่ IPC (การสื่อสารระหว่างกระบวนการ) มีไว้สำหรับ

คุณสามารถใช้คิวหรือท่อเพื่อจุดประสงค์นี้ คุณยังสามารถใช้ rpc บน tcp ได้หากคุณต้องการแจกจ่ายกระบวนการผ่านเครือข่ายในภายหลัง

http://docs.python.org/dev/library/multiprocessing.html#exchanging-objects-between-processes

ไม่เกี่ยวข้องโดยตรงกับการประมวลผลหลายขั้นตอนต่อ se แต่จากตัวอย่างของคุณดูเหมือนว่าคุณสามารถใช้โมดูลชั้นวางหรืออะไรทำนองนั้นได้ "big_lookup_object" ต้องอยู่ในหน่วยความจำอย่างสมบูรณ์จริง ๆ หรือไม่?

ไม่ได้ แต่คุณสามารถโหลดข้อมูลเป็นกระบวนการย่อยและอนุญาตให้แชร์ข้อมูลกับลูกคนอื่น ๆ ดูด้านล่าง

import time
import multiprocessing

def load_data( queue_load, n_processes )

    ... load data here into some_variable

    """
    Store multiple copies of the data into
    the data queue. There needs to be enough
    copies available for each process to access. 
    """

    for i in range(n_processes):
        queue_load.put(some_variable)


def work_with_data( queue_data, queue_load ):

    # Wait for load_data() to complete
    while queue_load.empty():
        time.sleep(1)

    some_variable = queue_load.get()

    """
    ! Tuples can also be used here
    if you have multiple data files
    you wish to keep seperate.  
    a,b = queue_load.get()
    """

    ... do some stuff, resulting in new_data

    # store it in the queue
    queue_data.put(new_data)


def start_multiprocess():

    n_processes = 5

    processes = []
    stored_data = []

    # Create two Queues
    queue_load = multiprocessing.Queue()
    queue_data = multiprocessing.Queue()

    for i in range(n_processes):

        if i == 0:
            # Your big data file will be loaded here...
            p = multiprocessing.Process(target = load_data,
            args=(queue_load, n_processes))

            processes.append(p)
            p.start()   

        # ... and then it will be used here with each process
        p = multiprocessing.Process(target = work_with_data,
        args=(queue_data, queue_load))

        processes.append(p)
        p.start()

    for i in range(n_processes)
        new_data = queue_data.get()
        stored_data.append(new_data)    

    for p in processes:
        p.join()
    print(processes)    

สำหรับแพลตฟอร์ม Linux / Unix / MacOS forkmap เป็นวิธีแก้ปัญหาที่รวดเร็วและสกปรก