মাল্টিপ্রসেসিং: প্রক্রিয়াগুলির মধ্যে একটি বড় পঠনযোগ্য বস্তু ভাগ করে নেওয়া?

Question

চাইল্ড প্রসেস মাধ্যমে উত্পন্ন হওয়া না মাল্টিপ্রসেসিং ভাগ প্রোগ্রামে পূর্বে নির্মিত বস্তু?

আমার নিম্নলিখিত সেটআপ আছে:

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'))

আমি স্মৃতিতে কিছু বড় বস্তু লোড করছি, তারপরে কর্মীদের একটি পুল তৈরি করা দরকার যা সেই বড় অবজেক্টটি ব্যবহার করা দরকার। বড় অবজেক্টটি কেবল পঠনযোগ্য অ্যাক্সেস করা হয়েছে, প্রক্রিয়াগুলির মধ্যে আমার এটির পরিবর্তনগুলি পাস করার দরকার নেই।

আমার প্রশ্ন হ'ল বড় বস্তুটি কি ভাগ করা স্মৃতিতে লোড হয়, এটি যদি আমি ইউনিক্স / সি-তে কোনও প্রক্রিয়া তৈরি করি, বা প্রতিটি প্রক্রিয়া বড় অবজেক্টের নিজস্ব অনুলিপি লোড করে?

আপডেট করুন: আরও স্পষ্ট করতে - big_lookup_object একটি ভাগ করা লুকআপ অবজেক্ট। আমার এটিকে আলাদা করে আলাদাভাবে প্রক্রিয়া করার দরকার নেই। আমার এটির একটি একক অনুলিপি রাখা দরকার। আমার যে কাজটি এটি বিভক্ত করতে হবে তা হ'ল প্রচুর অন্যান্য বৃহত ফাইল পড়ে এবং সেই বৃহত ফাইলগুলিতে আইটেমগুলি অনুসন্ধানের অবজেক্টের বিপরীতে অনুসন্ধান করা।

আরও আপডেট: ডাটাবেস একটি সূক্ষ্ম সমাধান, মেমক্যাচ করা ভাল সমাধান হতে পারে এবং ডিস্কে ফাইল (তাক বা ডিবিএম) আরও ভাল হতে পারে। এই প্রশ্নে আমি বিশেষত স্মৃতি সমাধানে আগ্রহী ছিলাম। চূড়ান্ত সমাধানের জন্য আমি হ্যাডোপ ব্যবহার করব, তবে আমি দেখতে চেয়েছিলাম যে স্থানীয় একটি মেমোরি সংস্করণও থাকতে পারে কিনা।

Comments

লিখিত হিসাবে আপনার কোড marshal.loadপিতামাতার জন্য এবং প্রতিটি সন্তানের জন্য কল করবে (প্রতিটি প্রক্রিয়া মডিউল আমদানি করে)।

— jfs

ঠিক বলেছেন, সংশোধন করেছেন।

— পরান্দ

"স্থানীয় ইন-মেমোরি" এর জন্য এবং যদি আপনি নিম্নলিখিতটি অনুলিপি করা এড়াতে চান তবে ডকস.পাইথন.আর.

— লিবারিয়ান

শেয়ার নং প্রসারিত প্রক্রিয়াগুলি (যেমন কাঁটাচামচ বা এক্সিকিউট উদাহরণস্বরূপ) কলিং প্রক্রিয়াটির সঠিক নকল ... তবে বিভিন্ন মেমরিতে। অন্য প্রক্রিয়াটির সাথে কথা বলার জন্য আপনার কোনও আন্তঃসম্পর্ক যোগাযোগ বা আইপিসি পড়া / লেখার কিছু ভাগ করে নেওয়া মেমরির অবস্থান প্রয়োজন।

— রন

Answer 1

"প্রোগ্রামটিতে শিশুদের প্রক্রিয়াগুলি কি বহু পূর্বে ভাগ করা বস্তুর মাধ্যমে তৈরি হয়েছিল?"

না (3.8 এর আগে অজগর), এবং হ্যাঁ 3.8 এ ( https://docs.python.org/3/library/m মাল্টিপ্রসেসিং.শার্ড_মেমরি। Html# মডুল- মাল্টিপ্রসেসিং.শ্রেড_মেমরি )

প্রক্রিয়াগুলির স্বাধীন মেমরির স্থান রয়েছে।

সমাধান 1

প্রচুর শ্রমিকের সাথে একটি বৃহত কাঠামোর সর্বোত্তম ব্যবহার করতে, এটি করুন।

1. প্রতিটি কর্মীকে "ফিল্টার" হিসাবে লিখুন - স্টিডিনের মধ্যবর্তী ফলাফলগুলি পড়ে, কাজ করে, স্টাডাউটে মধ্যবর্তী ফলাফল লিখেন।

2. পাইপলাইন হিসাবে সমস্ত কর্মীদের সংযুক্ত করুন:

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

প্রতিটি প্রক্রিয়া পড়ে, কাজ করে এবং লেখায়।

এটি উল্লেখযোগ্যভাবে দক্ষ কারণ সমস্ত প্রক্রিয়া একই সাথে চলমান। প্রক্রিয়াগুলির মধ্যে ভাগ করা বাফারগুলির মাধ্যমে সরাসরি লেখাগুলি এবং পাসগুলি পাস করে।

---

সমাধান 2

কিছু ক্ষেত্রে, আপনার আরও জটিল কাঠামো রয়েছে - প্রায়শই একটি "ফ্যান-আউট" কাঠামো। এক্ষেত্রে আপনার একাধিক বাচ্চা সহ একটি পিতা বা মাতা আছে।

1. পিতামাতার উত্স ডেটা খোলে। অভিভাবকরা বেশ কয়েকটি শিশুকে কাঁটাচামচ করেন।

2. পিতামাতাই উত্স পড়েন, উত্সের অংশগুলি প্রতিটি একযোগে চলমান শিশুর বাইরে থাকে।

3. পিতা-মাতার শেষের দিকে পৌঁছে, পাইপটি বন্ধ করুন। শিশু ফাইলের শেষ হয় এবং সাধারণত শেষ হয়।

সন্তানের অংশগুলি লিখতে মনোরম কারণ প্রতিটি শিশু খালি পড়ে sys.stdin।

সমস্ত বাচ্চা তৈরি এবং পাইপগুলি সঠিকভাবে বজায় রাখতে পিতামাতার কিছুটা অভিনব পদক্ষেপ রয়েছে তবে এটি খুব খারাপ নয়।

ফ্যান-ইন বিপরীত কাঠামো। বেশ কয়েকটি স্বতন্ত্রভাবে চলমান প্রক্রিয়াগুলির একটি সাধারণ প্রক্রিয়াতে তাদের ইনপুটগুলি ইন্টারলিভ করা দরকার। সংগ্রাহক লেখার পক্ষে তেমন সহজ নয়, কারণ এটি অনেক উত্স থেকে পড়তে হয়।

selectকোন পাইপগুলির ইনপুট মুলতুবি রয়েছে তা দেখতে অনেকগুলি নামযুক্ত পাইপ থেকে পড়া প্রায়শই মডিউলটি ব্যবহার করে করা হয়।

---

সমাধান 3

শেয়ারড লুকআপ হ'ল একটি ডাটাবেসের সংজ্ঞা।

সমাধান 3 এ - একটি ডাটাবেস লোড করুন। কর্মীদের ডাটাবেসে ডেটা প্রক্রিয়া করতে দিন।

সলিউশন 3 বি - ডাব্লুএসজিআই অ্যাপ্লিকেশনগুলি সরবরাহ করতে ডাব্লুএসজিআই অ্যাপ্লিকেশন সরবরাহ করতে খুব সহজ সার্ভার তৈরি করুন যা কর্মীরা সার্ভারকে জিজ্ঞাসা করতে পারে।

---

সমাধান 4

ভাগ করা ফাইল সিস্টেম অবজেক্ট। ইউনিক্স ওএস শেয়ার করা মেমরি অবজেক্ট দেয়। এগুলি কেবল মেমরিতে ম্যাপ করা ফাইলগুলি যাতে আরও কনভেনশন বাফার রিডের পরিবর্তে আই / ও অদলবদল করা যায়।

আপনি এটি পাইথন প্রসঙ্গে বিভিন্ন উপায়ে করতে পারেন

1. একটি স্টার্টআপ প্রোগ্রাম লিখুন যা (1) আপনার আসল বিশালাকার বস্তুটিকে ছোট ছোট বস্তুতে বিভক্ত করে এবং (2) কর্মীদের শুরু করে, প্রতিটি একটি ছোট বস্তু দিয়ে। অল্প অল্প পরিমাণে ফাইল পড়ার সময় পাইথন অবজেক্টগুলিকে সংযুক্ত করা যেতে পারে।

2. একটি প্রারম্ভিক প্রোগ্রাম লিখুন যা (1) আপনার মূল বিশালাকার বস্তুটি পড়ে এবং একটি পৃষ্ঠার কাঠামোগত, বাইট-কোডড ফাইলটি seekঅপারেশন ব্যবহার করে নিশ্চিত করে যাতে পৃথক বিভাগগুলি সহজ সন্ধানের সাথে সন্ধান করা সহজ। এটি একটি ডাটাবেস ইঞ্জিন করে - পৃষ্ঠাগুলিতে ডেটা ভাঙ্গা, প্রতিটি পৃষ্ঠাকে একটি মাধ্যমে সনাক্ত করা সহজ করে seek।

   এই বড় পৃষ্ঠা-কাঠামোগত ফাইলটিতে অ্যাক্সেস সহ স্প্যান কর্মীরা। প্রতিটি শ্রমিক প্রাসঙ্গিক অংশগুলি অনুসন্ধান করতে এবং সেখানে তাদের কাজ করতে পারে।

Comments

আমার প্রক্রিয়াগুলি আসলেই উপযুক্ত নয়; তারা সব একই, কেবলমাত্র ডেটা বিভিন্ন টুকরা প্রক্রিয়াজাত।

— পরান্দা

এগুলি প্রায়শই ফিল্টার হিসাবে কাঠামোগত করা যায়। তারা তাদের ডেটা টুকরা পড়ে, তাদের কাজ করে, এবং পরবর্তী প্রক্রিয়া করার জন্য তাদের ফলাফল লিখুন।

— এস .লট

আমি আপনার সমাধানটি পছন্দ করি, তবে আই / ও ব্লক করে কী ঘটে? যদি অভিভাবকরা তার কোনও সন্তানের / থেকে লেখা পড়া / লিখতে বাধা দেন? নির্বাচন আপনাকে অবহিত করতে পারে যে আপনি লিখতে পারেন, তবে এটি কতটুকু তা বলে না। পড়ার জন্য একই।

— ক্রিশ্চিয়ান সিউপিতু

এগুলি পৃথক প্রক্রিয়া - পিতামাতা এবং শিশুরা একে অপরের সাথে হস্তক্ষেপ করে না। পাইপের এক প্রান্তে উত্পাদিত প্রতিটি বাইট অবিলম্বে অন্য প্রান্তে খাওয়ার জন্য পাওয়া যায় - একটি পাইপ একটি ভাগ করা বাফার। এই প্রসঙ্গে আপনার প্রশ্নের অর্থ কী তা নিশ্চিত নয়।

— এস .লট

এস.লোট কী বলেছিল তা আমি যাচাই করতে পারি। আমার একই ক্রিয়াকলাপগুলি একটি ফাইলে করা দরকার। সুতরাং প্রথম কর্মী প্রতিটি লাইনে% 2 == 0 সংখ্যার সাথে তার কাজটি চালিয়ে একটি ফাইলে সংরক্ষণ করে এবং অন্যান্য লাইনগুলি পরবর্তী পাইপ প্রসেসে প্রেরণ করে (যা একই স্ক্রিপ্ট ছিল)। রানটাইম অর্ধেক নেমে গেছে। এটি সামান্য হ্যাকি তবে মাল্টিপ্রসেসিং মডিউলটিতে ওভারহেড মানচিত্র / পোপের চেয়ে অনেক হালকা।

— ভিনস

Answer 2

প্রোগ্রামে শিশুদের প্রক্রিয়াগুলি কি বহু পূর্বে ভাগ করা বস্তুর মাধ্যমে তৈরি হয়েছিল ?

এটা নির্ভর করে. গ্লোবাল রিড-ওনো ভেরিয়েবলের জন্য এটি প্রায়শই তাই বিবেচনা করা যেতে পারে (স্মৃতি ব্যতীত অন্যথায়) অন্যথায় এটি করা উচিত নয়।

মাল্টিপ্রসেসিংয়ের ডকুমেন্টেশন বলে:

Better to inherit than pickle/unpickle

উইন্ডোজে মাল্টিপ্রসেসিং থেকে বহু প্রকারের বাছাইযোগ্য হওয়া দরকার যাতে শিশু প্রক্রিয়াগুলি সেগুলি ব্যবহার করতে পারে। তবে সাধারণত পাইপ বা সারি ব্যবহার করে অন্য প্রক্রিয়াগুলিতে ভাগ করা অবজেক্টগুলি প্রেরণ করা উচিত। পরিবর্তে আপনার প্রোগ্রামটি সাজানো উচিত যাতে কোনও প্রক্রিয়া যাতে অন্য কোথাও তৈরি করা একটি ভাগ করা সংস্থার অ্যাক্সেসের প্রয়োজন হয় এটি পূর্বপুরুষ প্রক্রিয়া থেকে উত্তরাধিকারী হতে পারে।

Explicitly pass resources to child processes

ইউনিক্সে একটি শিশু প্রক্রিয়া বিশ্বব্যাপী সংস্থান ব্যবহার করে পিতামাতার প্রক্রিয়ায় তৈরি করা একটি ভাগ করা সংস্থান ব্যবহার করতে পারে। যাইহোক, শিশু প্রক্রিয়াটির জন্য কনস্ট্রাক্টরের পক্ষে একটি আর্গুমেন্ট হিসাবে বস্তুটি পাস করা ভাল।

উইন্ডোজের সাথে কোডটি (সম্ভাব্য) সামঞ্জস্যপূর্ণ করা ছাড়াও এটিও নিশ্চিত করে যে শিশু প্রক্রিয়াটি যতদিন বেঁচে থাকবে ততক্ষণ পিতামাতার প্রসেসে অবজেক্ট সংগ্রহ করা হবে না। অভিভাবক প্রক্রিয়াতে যখন অবজেক্টটি আবর্জনা সংগ্রহ করা হয় তখন কিছু সংস্থান মুক্ত হলে এটি গুরুত্বপূর্ণ হতে পারে।

Global variables

মনে রাখবেন যে কোনও শিশু প্রক্রিয়াতে কোড চালানো যদি কোনও বৈশ্বিক চলক অ্যাক্সেস করার চেষ্টা করে, তবে প্রসেস.স্টার্ট () নামক সময়টির সময় প্যারেন্ট প্রসেসে যে মানটি দেখা যায় (যদি থাকে তবে) একই মান নাও থাকতে পারে called ।

উদাহরণ

উইন্ডোজে (একক সিপিইউ):

#!/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

Comments

তাই না? প্রক্রিয়া জুড়ে জেড কীভাবে ভাগ হচ্ছে?

— cbare

@ কেবার: ভালো প্রশ্ন! z প্রকৃতপক্ষে ভাগ করা হয় না, যেমন শোয়ের সাথে আউটপুট। ঘুম ছাড়া আউটপুট দেখায় যে একটি একক প্রক্রিয়া সমস্ত কাজ পরিচালনা করে (পিআইডি = 1148); আমরা শেষ উদাহরণে যা দেখতে পাই তা হ'ল এই একক প্রক্রিয়ার z এর মান।

— এরিক হে লেবিগোট

এই উত্তরটি দেখায় যে zভাগ করা হয়নি। এটি এইভাবে এই প্রশ্নের উত্তর দেয়: "না, কমপক্ষে উইন্ডোজের অধীনে, পিতামাতার পরিবর্তনগুলি বাচ্চাদের মধ্যে ভাগ করা যায় না"।

— এরিক হে লেবিগোট

@ ইওল: প্রযুক্তিগতভাবে আপনি সঠিক আছেন তবে বাস্তবে যদি তথ্যটি কেবল পঠনযোগ্য হয় ( zক্ষেত্রে বিপরীতে ) তবে এটি ভাগ করা হিসাবে বিবেচনা করা যেতে পারে।

— jfs

কেবল স্পষ্ট করার জন্য, বিবৃতিটি মনে রাখবেন যে কোনও শিশু প্রক্রিয়াতে কোড চালিত হলে কোনও বিশ্বব্যাপী পরিবর্তনশীল অ্যাক্সেস করার চেষ্টা করা হয় ... ২.7 ডক্সে উইন্ডোজ অধীনে থাকা পাইথনকে বোঝায়।

— ব্যবহারকারী 1071847

Answer 3

এস.লট সঠিক। পাইথনের মাল্টিপ্রসেসিং শর্টকাট কার্যকরভাবে আপনাকে মেমরির একটি পৃথক, নকল করা অংশ দেয়।

বেশিরভাগ * নিক্স সিস্টেমে, নিম্ন-স্তরের কলটি os.fork()ইচ্ছামত ব্যবহার করে, আসলে আপনাকে অনুলিপি মেমরি দেয়, যা আপনি যা ভাবছেন তা হতে পারে। আফাইক, তাত্ত্বিকভাবে, সম্ভাব্য প্রোগ্রামগুলির সর্বাধিক সরলতায় আপনি সেই তথ্যটি নকল না করেই পড়তে পারেন।

তবে পাইথন ইন্টারপ্রেটারে জিনিসগুলি এতটা সহজ নয়। অবজেক্ট ডেটা এবং মেটা-ডেটা একই মেমোরি বিভাগে সংরক্ষণ করা হয়, সুতরাং এমনকি যদি বস্তুটি কখনও পরিবর্তন না হয় তবে object বস্তুর জন্য রেফারেন্স কাউন্টারের মতো কিছু বর্ধিত হওয়ার কারণে একটি মেমরি লেখার কারণ হতে পারে এবং তাই একটি অনুলিপি। প্রায় কোনও পাইথন প্রোগ্রাম যা "মুদ্রণ 'হ্যালো'" এর চেয়ে বেশি কাজ করছে তা রেফারেন্স গণনা বৃদ্ধির কারণ হতে পারে, তাই আপনি অনুলিপি-অন-লিখনের সুবিধা কখনই বুঝতে পারবেন না।

এমনকি যদি পাইথনে কেউ একটি ভাগ করা-মেমরি সমাধান হ্যাক করতে সক্ষম হন, তবে প্রক্রিয়াগুলিতে আবর্জনা সংগ্রহের সমন্বয় করার চেষ্টা করা সম্ভবত বেশ বেদনাদায়ক হবে।

Comments

সেক্ষেত্রে কেবলমাত্র রেফের গণনার মেমরি অঞ্চলই অনুলিপি করা হবে, অগত্যা বড় পঠনযোগ্য কেবল ডেটা নয়, তাই না?

— কাওয়িং-চিউ

Answer 4

আপনি যদি ইউনিক্সের অধীনে চলতে থাকেন তবে কাঁটাচামচ কীভাবে কাজ করে তার কারণে তারা একই বস্তু ভাগ করতে পারে (যেমন, শিশু প্রক্রিয়াগুলির পৃথক মেমরি থাকে তবে এটি অনুলিপি- রচনায় লিখিত হয়, তাই যতক্ষণ না কেউ এটিকে পরিবর্তন না করে) এটি ভাগ করা যেতে পারে। আমি নিম্নলিখিত চেষ্টা করেছিলাম:

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প্রতিটি সাবপ্রসেসি কতটা প্রকৃত মেমরি ব্যবহার করছে তা দেখার জন্য আউটপুট দেখে আপনার অবস্থাতে আপনার যাচাই করতে সক্ষম হওয়া উচিত ।

Comments

আবর্জনা সংগ্রহকারীর কী হবে? এটি যখন চলে তখন কী ঘটে? স্মৃতি বিন্যাস পরিবর্তন হয় না?

— ক্রিশ্চিয়ান সিউপিতু

এটি একটি বৈধ উদ্বেগ। এটি প্যারানডকে প্রভাবিত করবে কিনা তার উপর নির্ভর করবে তিনি কীভাবে এই সমস্ত ব্যবহার করছেন এবং এই কোডটি কতটা নির্ভরযোগ্য হতে হবে। যদি এটি তার পক্ষে কাজ না করে থাকে তবে আমি আরও নিয়ন্ত্রণের জন্য এমএমএপি মডিউলটি ব্যবহার করার পরামর্শ দেব (ধরে নিই যে তিনি এই প্রাথমিক পদ্ধতির সাথে আঁকতে চান)।

— জ্যাকব গ্যাব্রিয়েলসন 21

: আমি আপনার উদাহরণ একটি আপডেট পোস্ট করেছেন stackoverflow.com/questions/659865/...

— JFS

@ জ্যাকবগ্যাব্রিয়েলসন: অনুলিপিটি তৈরি করা হয়েছে। মূল প্রশ্নটি অনুলিপিটি তৈরি করা হয়েছে কিনা তা নিয়ে।

— অভিনবকুলকার্নি

Answer 5

বিভিন্ন প্রক্রিয়াতে আলাদা আলাদা ঠিকানা স্পেস থাকে। দোভাষী এর বিভিন্ন দৌড়ানোর মতো। এটিই আইপিসি (ইন্টারপ্রসেস যোগাযোগ)।

আপনি এই উদ্দেশ্যে সারি বা পাইপ উভয়ই ব্যবহার করতে পারেন। আপনি যদি পরে কোনও নেটওয়ার্কের মাধ্যমে প্রক্রিয়াগুলি বিতরণ করতে চান তবে আপনি আরসিসি ওভার টিসিপিও ব্যবহার করতে পারেন।

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

Comments

আমি মনে করি না আইপিসি এর পক্ষে উপযুক্ত হবে; এটি কেবলমাত্র পঠনযোগ্য ডেটা যা প্রত্যেকের অ্যাক্সেসের প্রয়োজন। প্রক্রিয়াগুলির মধ্যে এটি পাস করার কোনও ধারণা নেই; দুর্ভাগ্যবশত প্রতিটি তার নিজস্ব অনুলিপি পড়তে পারেন। আমি প্রতিটি প্রক্রিয়াতে পৃথক অনুলিপি না রেখে স্মৃতি সঞ্চয় করার চেষ্টা করছি।

— পরানন্দ

অন্যান্য স্লেভ প্রসেসগুলিতে কাজ করার জন্য আপনার কাছে মাস্টার প্রসেস ডেটা টুকরো টুকরো টুকরো করতে পারে। হয় ক্রীতদাসরা ডেটা চাইতে পারে বা এটি ডেটা ঠেলে দিতে পারে। এই পদ্ধতিতে প্রতিটি প্রক্রিয়াতে পুরো বস্তুর অনুলিপি থাকে না।

— ভাসিল

@ ভ্যাসিল: যদি প্রতিটি প্রক্রিয়াটির পুরো ডেটা সেট প্রয়োজন হয় এবং কেবল এটির উপর একটি ভিন্ন অপারেশন চলছে?

— উইল

Answer 6

প্রতি সেপ্টেম্বর মাল্টিপ্রসেসিংয়ের সাথে সরাসরি সম্পর্কিত নয়, তবে আপনার উদাহরণ থেকে মনে হয় আপনি কেবল তাক মডিউল বা এর মতো কিছু ব্যবহার করতে পারেন। "বিগ_লকআপ_বজেক্ট" কি আসলেই পুরোপুরি স্মৃতিতে থাকতে হবে?

Comments

ভাল কথা, আমি স্মৃতিতে বনাম অন ডিস্কের পারফরম্যান্সের সাথে সরাসরি তুলনা করি না। আমি ধরে নিয়েছিলাম যে এখানে একটি বড় পার্থক্য হবে, তবে আমি আসলে পরীক্ষা করিনি।

— পরান্দ

Answer 7

না, তবে আপনি একটি শিশু প্রক্রিয়া হিসাবে আপনার ডেটা লোড করতে এবং এটি অন্যান্য বাচ্চার সাথে এটির ডেটা ভাগ করার অনুমতি দিতে পারেন। নিচে দেখ.

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)    

Answer 8

লিনাক্স / ইউনিক্স / ম্যাকোস প্ল্যাটফর্মের জন্য, ফর্মম্যাপটি একটি দ্রুত এবং মলিন সমাধান।