સમાંતર શક્તિને અનલૉક કરવી: પાયથોનની મલ્ટિપ્રોસેસિંગ શેર્ડ મેમરીનો ઊંડાણપૂર્વક અભ્યાસ

મલ્ટી-કોર પ્રોસેસર્સના યુગમાં, સમાંતર રીતે કાર્યો કરી શકે તેવા સોફ્ટવેર લખવું હવે કોઈ વિશિષ્ટ કૌશલ્ય નથી—તે ઉચ્ચ-પ્રદર્શન એપ્લિકેશન્સ બનાવવા માટે એક આવશ્યકતા છે. પાયથોનનું multiprocessing મોડ્યુલ આ કોરોનો લાભ લેવા માટે એક શક્તિશાળી સાધન છે, પરંતુ તે એક મૂળભૂત પડકાર સાથે આવે છે: પ્રોસેસ, તેની ડિઝાઇન મુજબ, મેમરી શેર કરતી નથી. દરેક પ્રોસેસ તેની પોતાની અલગ મેમરી સ્પેસમાં કાર્ય કરે છે, જે સલામતી અને સ્થિરતા માટે ઉત્તમ છે પરંતુ જ્યારે તેમને સંચાર અથવા ડેટા શેર કરવાની જરૂર પડે ત્યારે સમસ્યા ઊભી કરે છે.

અહીં જ શેર્ડ મેમરીનો ઉપયોગ થાય છે. તે વિવિધ પ્રોસેસને મેમરીના સમાન બ્લોકને એક્સેસ અને સંશોધિત કરવાની પદ્ધતિ પૂરી પાડે છે, જે કાર્યક્ષમ ડેટા વિનિમય અને સંકલનને સક્ષમ કરે છે. multiprocessing મોડ્યુલ આને પ્રાપ્ત કરવા માટે ઘણા માર્ગો પ્રદાન કરે છે, પરંતુ સૌથી સામાન્ય છે Value, Array, અને બહુમુખી Manager ઓબ્જેક્ટ્સ. આ સાધનો વચ્ચેનો તફાવત સમજવો નિર્ણાયક છે, કારણ કે ખોટી પસંદગી પર્ફોર્મન્સ બોટલનેક અથવા અતિશય જટિલ કોડ તરફ દોરી શકે છે.

આ માર્ગદર્શિકા આ ત્રણ પદ્ધતિઓનું વિગતવાર અન્વેષણ કરશે, સ્પષ્ટ ઉદાહરણો અને તમારા વિશિષ્ટ ઉપયોગના કેસ માટે કયું યોગ્ય છે તે નક્કી કરવા માટે એક વ્યવહારુ માળખું પ્રદાન કરશે.

મલ્ટિપ્રોસેસિંગમાં મેમરી મોડેલને સમજવું

ટૂલ્સમાં ઊંડા ઉતરતા પહેલાં, આપણને તેની શા માટે જરૂર છે તે સમજવું આવશ્યક છે. જ્યારે તમે multiprocessing નો ઉપયોગ કરીને નવી પ્રોસેસ શરૂ કરો છો, ત્યારે ઓપરેટિંગ સિસ્ટમ તેના માટે સંપૂર્ણપણે અલગ મેમરી સ્પેસ ફાળવે છે. આ ખ્યાલ, જેને પ્રોસેસ આઇસોલેશન તરીકે ઓળખવામાં આવે છે, તેનો અર્થ એ છે કે એક પ્રોસેસમાંનો વેરિયેબલ બીજી પ્રોસેસમાં સમાન નામના વેરિયેબલથી સંપૂર્ણપણે સ્વતંત્ર છે.

આ મલ્ટી-થ્રેડિંગથી મુખ્ય તફાવત છે, જ્યાં સમાન પ્રોસેસની અંદરના થ્રેડ્સ ડિફૉલ્ટ રૂપે મેમરી શેર કરે છે. જોકે, પાયથોનમાં, ગ્લોબલ ઇન્ટરપ્રીટર લૉક (GIL) ઘણીવાર થ્રેડ્સને CPU-બાઉન્ડ કાર્યો માટે સાચી સમાંતરતા પ્રાપ્ત કરતા અટકાવે છે, જે મલ્ટિપ્રોસેસિંગને ગણતરીની દ્રષ્ટિએ સઘન કાર્યો માટે પસંદગીનો વિકલ્પ બનાવે છે. તેનો ગેરલાભ એ છે કે આપણે આપણી પ્રોસેસ વચ્ચે ડેટા કેવી રીતે શેર કરવો તે વિશે સ્પષ્ટ રહેવું જોઈએ.

પદ્ધતિ 1: સરળ પ્રિમિટિવ્સ - `Value` અને `Array`

multiprocessing.Value અને multiprocessing.Array ડેટા શેર કરવાની સૌથી સીધી અને કાર્યક્ષમ રીતો છે. તે અનિવાર્યપણે નીચા-સ્તરના C ડેટા પ્રકારોની આસપાસના રેપર્સ છે જે ઓપરેટિંગ સિસ્ટમ દ્વારા સંચાલિત શેર્ડ મેમરી બ્લોકમાં રહે છે. આ સીધો મેમરી એક્સેસ જ તેમને અતિશય ઝડપી બનાવે છે.

multiprocessing.Value સાથે ડેટાના એક ટુકડાને શેર કરવું

નામ સૂચવે છે તેમ, Value નો ઉપયોગ એક જ, પ્રિમિટિવ વેલ્યુ, જેમ કે પૂર્ણાંક, ફ્લોટ અથવા બુલિયન શેર કરવા માટે થાય છે. જ્યારે તમે Value બનાવો છો, ત્યારે તમારે C ડેટા પ્રકારોને અનુરૂપ ટાઇપ કોડનો ઉપયોગ કરીને તેનો પ્રકાર સ્પષ્ટ કરવો આવશ્યક છે.

ચાલો એક ઉદાહરણ જોઈએ જ્યાં બહુવિધ પ્રોસેસ એક શેર્ડ કાઉન્ટરમાં વધારો કરે છે.

            
import multiprocessing

def worker(shared_counter, lock):
    for _ in range(10000):
        # Use a lock to prevent race conditions
        with lock:
            shared_counter.value += 1

if __name__ == "__main__":
    # 'i' for signed integer, 0 is the initial value
    counter = multiprocessing.Value('i', 0)
    lock = multiprocessing.Lock()

    processes = []
    for _ in range(10):
        p = multiprocessing.Process(target=worker, args=(counter, lock))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

    print(f"Final counter value: {counter.value}")
    # Expected output: Final counter value: 100000

            

              
                Copy
              
            
          

મુખ્ય મુદ્દાઓ:

• ટાઇપ કોડ્સ: અમે સાઇન્ડ ઇન્ટિજર માટે 'i' નો ઉપયોગ કર્યો. અન્ય સામાન્ય કોડ્સમાં ડબલ-પ્રિસિઝન ફ્લોટ માટે 'd' અને એક અક્ષર માટે 'c' નો સમાવેશ થાય છે.
• .value એટ્રિબ્યુટ: તમારે અંતર્ગત ડેટાને એક્સેસ કરવા અથવા સંશોધિત કરવા માટે .value એટ્રિબ્યુટનો ઉપયોગ કરવો આવશ્યક છે.
• સિંક્રોનાઇઝેશન મેન્યુઅલ છે: multiprocessing.Lock ના ઉપયોગ પર ધ્યાન આપો. લૉક વિના, બહુવિધ પ્રોસેસ કાઉન્ટરની કિંમત વાંચી શકે છે, તેને વધારી શકે છે, અને તેને એકસાથે પાછી લખી શકે છે, જે રેસ કન્ડિશન તરફ દોરી જાય છે જ્યાં કેટલાક ઇન્ક્રીમેન્ટ્સ ખોવાઈ જાય છે. Value અને Array કોઈ ઓટોમેટિક સિંક્રોનાઇઝેશન પ્રદાન કરતા નથી; તમારે તેને જાતે જ મેનેજ કરવું પડશે.

multiprocessing.Array સાથે ડેટાના સંગ્રહને શેર કરવું

Array એ Value ની જેમ જ કામ કરે છે પરંતુ તમને એક જ પ્રિમિટિવ પ્રકારની નિશ્ચિત-કદની એરે શેર કરવાની મંજૂરી આપે છે. તે આંકડાકીય ડેટા શેર કરવા માટે અત્યંત કાર્યક્ષમ છે, જે તેને વૈજ્ઞાનિક અને ઉચ્ચ-પ્રદર્શન કમ્પ્યુટિંગમાં મુખ્ય બનાવે છે.

            
import multiprocessing

def square_elements(shared_array, lock, start_index, end_index):
    for i in range(start_index, end_index):
        # A lock isn't strictly needed here if processes work on different indices,
        # but it's crucial if they might modify the same index.
        with lock:
            shared_array[i] = shared_array[i] * shared_array[i]

if __name__ == "__main__":
    # 'i' for signed integer, initialized with a list of values
    initial_data = list(range(10))
    shared_arr = multiprocessing.Array('i', initial_data)
    lock = multiprocessing.Lock()

    p1 = multiprocessing.Process(target=square_elements, args=(shared_arr, lock, 0, 5))
    p2 = multiprocessing.Process(target=square_elements, args=(shared_arr, lock, 5, 10))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print(f"Final array: {list(shared_arr)}")
    # Expected output: Final array: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

            

              
                Copy
              
            
          

મુખ્ય મુદ્દાઓ:

• નિશ્ચિત કદ અને પ્રકાર: એકવાર બનાવ્યા પછી, Array નું કદ અને ડેટા પ્રકાર બદલી શકાતો નથી.
• ડાયરેક્ટ ઇન્ડેક્સિંગ: તમે પ્રમાણભૂત લિસ્ટ-જેવા ઇન્ડેક્સિંગ (દા.ત., shared_arr[i]) નો ઉપયોગ કરીને તત્વોને એક્સેસ અને સંશોધિત કરી શકો છો.
• સિંક્રોનાઇઝેશન નોંધ: ઉપરના ઉદાહરણમાં, કારણ કે દરેક પ્રોસેસ એરેના એક અલગ, નોન-ઓવરલેપિંગ સ્લાઇસ પર કામ કરે છે, લૉક બિનજરૂરી લાગી શકે છે. જોકે, જો બે પ્રોસેસ સમાન ઇન્ડેક્સ પર લખવાની કોઈ શક્યતા હોય, અથવા જો એક પ્રોસેસને સુસંગત સ્થિતિ વાંચવાની જરૂર હોય જ્યારે બીજી લખી રહી હોય, તો ડેટાની અખંડિતતા સુનિશ્ચિત કરવા માટે લૉક એકદમ આવશ્યક છે.

`Value` અને `Array` ના ફાયદા અને ગેરફાયદા

• ફાયદા:
  • ઉચ્ચ પ્રદર્શન: ન્યૂનતમ ઓવરહેડ અને સીધા મેમરી એક્સેસને કારણે ડેટા શેર કરવાની સૌથી ઝડપી રીત.
  • ઓછી મેમરી ફૂટપ્રિન્ટ: પ્રિમિટિવ પ્રકારો માટે કાર્યક્ષમ સંગ્રહ.
• ગેરફાયદા:
  • મર્યાદિત ડેટા પ્રકારો: ફક્ત સરળ C-સુસંગત ડેટા પ્રકારોને હેન્ડલ કરી શકે છે. તમે પાયથોન ડિક્શનરી, લિસ્ટ અથવા કસ્ટમ ઓબ્જેક્ટને સીધો સ્ટોર કરી શકતા નથી.
  • મેન્યુઅલ સિંક્રોનાઇઝેશન: રેસ કન્ડિશન્સને રોકવા માટે લૉક્સ લાગુ કરવાની જવાબદારી તમારી છે, જે ભૂલ-સંભવિત હોઈ શકે છે.
  • બિન-લવચીક: Array નું કદ નિશ્ચિત છે.

પદ્ધતિ 2: લવચીક પાવરહાઉસ - `Manager` ઓબ્જેક્ટ્સ

જો તમારે વધુ જટિલ પાયથોન ઓબ્જેક્ટ્સ, જેમ કે રૂપરેખાંકનોની ડિક્શનરી અથવા પરિણામોની સૂચિ શેર કરવાની જરૂર હોય તો શું? અહીં જ multiprocessing.Manager ચમકે છે. મેનેજર પ્રોસેસમાં પ્રમાણભૂત પાયથોન ઓબ્જેક્ટ્સ શેર કરવાની ઉચ્ચ-સ્તરીય, લવચીક રીત પ્રદાન કરે છે.

મેનેજર ઓબ્જેક્ટ્સ કેવી રીતે કાર્ય કરે છે: સર્વર પ્રોસેસ મોડેલ

Value અને Array જે સીધી શેર્ડ મેમરીનો ઉપયોગ કરે છે તેનાથી વિપરીત, Manager અલગ રીતે કાર્ય કરે છે. જ્યારે તમે મેનેજર શરૂ કરો છો, ત્યારે તે એક વિશેષ સર્વર પ્રોસેસ શરૂ કરે છે. આ સર્વર પ્રોસેસ વાસ્તવિક પાયથોન ઓબ્જેક્ટ્સ (દા.ત., વાસ્તવિક ડિક્શનરી) ધરાવે છે.

તમારી અન્ય વર્કર પ્રોસેસને આ ઓબ્જેક્ટની સીધી એક્સેસ મળતી નથી. તેના બદલે, તેમને એક વિશેષ પ્રોક્સી ઓબ્જેક્ટ મળે છે. જ્યારે વર્કર પ્રોસેસ પ્રોક્સી પર કોઈ ઓપરેશન કરે છે (જેમ કે shared_dict['key'] = 'value'), ત્યારે પડદા પાછળ નીચે મુજબ થાય છે:

1. મેથડ કૉલ અને તેના આર્ગ્યુમેન્ટ્સને સિરિયલાઈઝ (પિકલ્ડ) કરવામાં આવે છે.
2. આ સિરિયલાઈઝ્ડ ડેટાને કનેક્શન (જેમ કે પાઇપ અથવા સોકેટ) દ્વારા મેનેજરની સર્વર પ્રોસેસમાં મોકલવામાં આવે છે.
3. સર્વર પ્રોસેસ ડેટાને ડિસિરિયલાઈઝ કરે છે અને વાસ્તવિક ઓબ્જેક્ટ પર ઓપરેશન ચલાવે છે.
4. જો ઓપરેશન કોઈ મૂલ્ય પરત કરે છે, તો તેને સિરિયલાઈઝ કરીને વર્કર પ્રોસેસને પાછું મોકલવામાં આવે છે.

મહત્વપૂર્ણ રીતે, મેનેજર પ્રોસેસ તમામ જરૂરી લોકીંગ અને સિંક્રોનાઇઝેશનને આંતરિક રીતે સંભાળે છે. આનાથી વિકાસ નોંધપાત્ર રીતે સરળ અને રેસ કન્ડિશનની ભૂલોથી ઓછો સંભવિત બને છે, પરંતુ તે સંચાર અને સિરિયલાઇઝેશન ઓવરહેડને કારણે પર્ફોર્મન્સના ભોગે આવે છે.

જટિલ ઓબ્જેક્ટ્સ શેર કરવા: `Manager.dict()` અને `Manager.list()`

ચાલો આપણે આપણા કાઉન્ટર ઉદાહરણને ફરીથી લખીએ, પરંતુ આ વખતે આપણે બહુવિધ કાઉન્ટર્સ સ્ટોર કરવા માટે `Manager.dict()` નો ઉપયોગ કરીશું.

            
import multiprocessing

def worker(shared_dict, worker_id):
    # Each worker has its own key in the dictionary
    key = f'worker_{worker_id}'
    shared_dict[key] = 0
    for _ in range(1000):
        shared_dict[key] += 1

if __name__ == "__main__":
    with multiprocessing.Manager() as manager:
        # The manager creates a shared dictionary
        shared_data = manager.dict()

        processes = []
        for i in range(5):
            p = multiprocessing.Process(target=worker, args=(shared_data, i))
            processes.append(p)
            p.start()

        for p in processes:
            p.join()

        print(f"Final shared dictionary: {dict(shared_data)}")
        # Expected output might look like:
        # Final shared dictionary: {'worker_0': 1000, 'worker_1': 1000, 'worker_2': 1000, 'worker_3': 1000, 'worker_4': 1000}

            

              
                Copy
              
            
          

મુખ્ય મુદ્દાઓ:

• કોઈ મેન્યુઅલ લૉક્સ નથી: Lock ઓબ્જેક્ટની ગેરહાજરી નોંધો. મેનેજરના પ્રોક્સી ઓબ્જેક્ટ્સ થ્રેડ-સેફ અને પ્રોસેસ-સેફ છે, જે તમારા માટે સિંક્રોનાઇઝેશનને સંભાળે છે.
• પાયથોનિક ઇન્ટરફેસ: તમે manager.dict() અને manager.list() સાથે એવી જ રીતે ક્રિયા-પ્રતિક્રિયા કરી શકો છો જેવી રીતે તમે નિયમિત પાયથોન ડિક્શનરીઓ અને લિસ્ટ સાથે કરો છો.
• સપોર્ટેડ પ્રકારો: મેનેજર્સ list, dict, Namespace, Lock, Event, Queue અને વધુના શેર્ડ વર્ઝન બનાવી શકે છે, જે અકલ્પનીય વર્સેટિલિટી પ્રદાન કરે છે.

`Manager` ઓબ્જેક્ટ્સના ફાયદા અને ગેરફાયદા

• ફાયદા:
  • જટિલ ઓબ્જેક્ટ્સને સપોર્ટ કરે છે: લગભગ કોઈપણ પ્રમાણભૂત પાયથોન ઓબ્જેક્ટને શેર કરી શકે છે જેને પિકલ કરી શકાય છે.
  • ઓટોમેટિક સિંક્રોનાઇઝેશન: આંતરિક રીતે લોકીંગને હેન્ડલ કરે છે, જે કોડને સરળ અને સુરક્ષિત બનાવે છે.
  • ઉચ્ચ લવચીકતા: લિસ્ટ અને ડિક્શનરી જેવી ગતિશીલ ડેટા સ્ટ્રક્ચર્સને સપોર્ટ કરે છે જે વધી કે ઘટી શકે છે.
• ગેરફાયદા:
  • ઓછું પ્રદર્શન: સર્વર પ્રોસેસ, ઇન્ટર-પ્રોસેસ કમ્યુનિકેશન (IPC), અને ઓબ્જેક્ટ સિરિયલાઇઝેશનના ઓવરહેડને કારણે Value/Array કરતાં નોંધપાત્ર રીતે ધીમું.
  • વધુ મેમરી વપરાશ: મેનેજર પ્રોસેસ પોતે સંસાધનોનો વપરાશ કરે છે.

સરખામણી કોષ્ટક: `Value`/`Array` vs. `Manager`

વ્યવહારુ માર્ગદર્શન: ક્યારે કોનો ઉપયોગ કરવો?

યોગ્ય સાધન પસંદ કરવું એ પ્રદર્શન અને સુવિધા વચ્ચેનો ક્લાસિક એન્જિનિયરિંગ ટ્રેડ-ઓફ છે. અહીં એક સરળ નિર્ણય લેવાની ફ્રેમવર્ક છે:

તમારે Value અથવા Array નો ઉપયોગ ત્યારે કરવો જોઈએ જ્યારે:

• પ્રદર્શન તમારી પ્રાથમિક ચિંતા છે. તમે વૈજ્ઞાનિક ગણતરી, ડેટા વિશ્લેષણ, અથવા રીઅલ-ટાઇમ સિસ્ટમ્સ જેવા ક્ષેત્રમાં કામ કરી રહ્યા છો જ્યાં દરેક માઇક્રોસેકન્ડ મહત્વપૂર્ણ છે.
• તમે સરળ, આંકડાકીય ડેટા શેર કરી રહ્યા છો. આમાં કાઉન્ટર્સ, ફ્લેગ્સ, સ્ટેટસ ઇન્ડિકેટર્સ, અથવા નંબરોની મોટી એરે (દા.ત., NumPy જેવી લાઇબ્રેરીઓ સાથે પ્રોસેસિંગ માટે) નો સમાવેશ થાય છે.
• તમે લૉક્સ અથવા અન્ય પ્રિમિટિવ્સનો ઉપયોગ કરીને મેન્યુઅલ સિંક્રોનાઇઝેશનની જરૂરિયાત સાથે આરામદાયક છો અને સમજો છો.

તમારે Manager નો ઉપયોગ ત્યારે કરવો જોઈએ જ્યારે:

• વિકાસની સરળતા અને કોડની વાંચનક્ષમતા કાચી ગતિ કરતાં વધુ મહત્વપૂર્ણ છે.
• તમારે ડિક્શનરીઓ, સ્ટ્રિંગ્સની લિસ્ટ, અથવા નેસ્ટેડ ઓબ્જેક્ટ્સ જેવા જટિલ અથવા ગતિશીલ પાયથોન ડેટા સ્ટ્રક્ચર્સ શેર કરવાની જરૂર છે.
• શેર કરવામાં આવતો ડેટા અત્યંત ઊંચી આવર્તન પર અપડેટ થતો નથી, જેનો અર્થ છે કે IPC નો ઓવરહેડ તમારી એપ્લિકેશનના વર્કલોડ માટે સ્વીકાર્ય છે.
• તમે એવી સિસ્ટમ બનાવી રહ્યા છો જ્યાં પ્રોસેસને સામાન્ય સ્થિતિ શેર કરવાની જરૂર છે, જેમ કે રૂપરેખાંકન ડિક્શનરી અથવા પરિણામોની કતાર.

વિકલ્પો પર એક નોંધ

જ્યારે શેર્ડ મેમરી એક શક્તિશાળી મોડેલ છે, ત્યારે પ્રોસેસ માટે સંચાર કરવાનો તે એકમાત્ર રસ્તો નથી. `multiprocessing` મોડ્યુલ `Queue` અને `Pipe` જેવી મેસેજ-પાસિંગ પદ્ધતિઓ પણ પ્રદાન કરે છે. તમામ પ્રોસેસને સામાન્ય ડેટા ઓબ્જેક્ટની ઍક્સેસ હોવાને બદલે, તેઓ અલગ સંદેશા મોકલે છે અને મેળવે છે. આ ઘણીવાર સરળ, ઓછી જોડાયેલ ડિઝાઇન તરફ દોરી શકે છે અને ઉત્પાદક-ઉપભોક્તા પેટર્ન અથવા પાઇપલાઇનના તબક્કાઓ વચ્ચે કાર્યો પસાર કરવા માટે વધુ યોગ્ય હોઈ શકે છે.

નિષ્કર્ષ

પાયથોનનું multiprocessing મોડ્યુલ સમાંતર એપ્લિકેશન્સ બનાવવા માટે એક મજબૂત ટૂલકિટ પ્રદાન કરે છે. જ્યારે ડેટા શેર કરવાની વાત આવે છે, ત્યારે નીચા-સ્તરના પ્રિમિટિવ્સ અને ઉચ્ચ-સ્તરના એબ્સ્ટ્રેક્શન્સ વચ્ચેની પસંદગી એક મૂળભૂત ટ્રેડ-ઓફને વ્યાખ્યાયિત કરે છે.

• Value અને Array શેર્ડ મેમરીમાં સીધો એક્સેસ પ્રદાન કરીને અપ્રતિમ ગતિ પ્રદાન કરે છે, જે તેમને સરળ ડેટા પ્રકારો સાથે કામ કરતી પ્રદર્શન-સંવેદનશીલ એપ્લિકેશન્સ માટે આદર્શ પસંદગી બનાવે છે.
• Manager ઓબ્જેક્ટ્સ પ્રદર્શન ઓવરહેડના ભોગે, ઓટોમેટિક સિંક્રોનાઇઝેશન સાથે જટિલ પાયથોન ઓબ્જેક્ટ્સને શેર કરવાની મંજૂરી આપીને શ્રેષ્ઠ લવચીકતા અને ઉપયોગમાં સરળતા પ્રદાન કરે છે.

આ મુખ્ય તફાવતને સમજીને, તમે એક જાણકાર નિર્ણય લઈ શકો છો, એવી એપ્લિકેશન્સ બનાવવા માટે યોગ્ય સાધન પસંદ કરી શકો છો જે ફક્ત ઝડપી અને કાર્યક્ષમ જ નહીં, પણ મજબૂત અને જાળવણી યોગ્ય પણ હોય. ચાવી એ છે કે તમારી વિશિષ્ટ જરૂરિયાતોનું વિશ્લેષણ કરવું — તમે જે પ્રકારનો ડેટા શેર કરી રહ્યાં છો, એક્સેસની આવર્તન, અને તમારી પ્રદર્શનની આવશ્યકતાઓ — જેથી પાયથોનમાં સમાંતર પ્રોસેસિંગની સાચી શક્તિને અનલૉક કરી શકાય.