---

खिलौना प्रदर्शन का उदाहरण चलाने के बाद, अब हम कुछ हद तक पीछे हटेंगे और प्रदर्शन की तुलना
से करेंगे। कुछ पायथन कार्यान्वयन। सबसे पहले आइए गणनाओं के लिए चरण तैयार करें, और कमांडलाइन प्रदान करें
पायथन लिपि की क्षमताएं।

import argparse
import time
import math
import numpy as np
import os
from numba import njit
from joblib import Parallel, delayed

parser = argparse.ArgumentParser()
parser.add_argument("--workers", type=int, default=8)
parser.add_argument("--arraysize", type=int, default=100_000_000)
args = parser.parse_args()
# Set the number of threads to 1 for different libraries
print("=" * 80)
print(
    f"\nStarting the benchmark for {args.arraysize} elements "
    f"using {args.workers} threads/workers\n"
)

# Generate the data structures for the benchmark
array0 = [np.random.rand() for _ in range(args.arraysize)]
array1 = array0.copy()
array2 = array0.copy()
array_in_np = np.array(array1)
array_in_np_copy = array_in_np.copy()

और यहां हमारे प्रतियोगी हैं:

• बेस पायथन

  for i in range(len(array0)):
    array0[i] = math.cos(math.sin(math.sqrt(array0[i])))

• नम्पी (सिंगल थ्रेडेड)

np.sqrt(array_in_np, out=array_in_np)
np.sin(array_in_np, out=array_in_np)
np.cos(array_in_np, out=array_in_np)

• जॉब्लिब (ध्यान दें कि यह उदाहरण सही जगह पर नहीं है, लेकिन मैं इसे आउट तर्कों का उपयोग करके चलाने में सक्षम नहीं हूं)

def compute_inplace_with_joblib(chunk):
    return np.cos(np.sin(np.sqrt(chunk))) #parallel function for joblib

chunks = np.array_split(array1, args.workers)  # Split the array into chunks
numresults = Parallel(n_jobs=args.workers)(
        delayed(compute_inplace_with_joblib)(chunk) for chunk in chunks
    )# Process each chunk in a separate thread
array1 = np.concatenate(numresults)  # Concatenate the results

• नुम्बा

@njit
def compute_inplace_with_numba(array):
    np.sqrt(array,array)
    np.sin(array,array)
    np.cos(array,array)
    ## njit will compile this function to machine code
compute_inplace_with_numba(array_in_np_copy)

और यहां समय परिणाम हैं:

In place in (  base Python): 11.42 seconds
In place in (Python Joblib): 4.59 seconds
In place in ( Python Numba): 2.62 seconds
In place in ( Python Numpy): 0.92 seconds

सुंबा आश्चर्यजनक रूप से धीमा है!? क्या यह संकलन के ओवरहेड के कारण हो सकता है जैसा कि इस मुद्दे के बारे में आईआरसी एक्सचेंज में मोहॉक2 द्वारा बताया गया है?
इसका परीक्षण करने के लिए, हमें बेंचमार्क निष्पादित करने से पहले एक बार compute_inplace_with_numba को कॉल करना चाहिए। ऐसा करने से पता चलता है कि नुम्बा अब नम्पी से तेज़ है।

स्थान में (बेस पायथन): 11.89 सेकंड (पायथन जॉबलिब) में स्थान पर: 4.42 सेकंड (पायथन नम्पी) में जगह पर: 0.93 सेकंड (पायथन नुम्बा) में जगह पर: 0.49 सेकंड

In place in (  base Python): 11.89 seconds
In place in (Python Joblib): 4.42 seconds
In place in ( Python Numpy): 0.93 seconds
In place in ( Python Numba): 0.49 seconds

आखिरकार, मैंने उसी उदाहरण में सवारी के लिए आधार आर लेने का फैसला किया:

nIn place in ( base Python): 11.89 seconds In place in (Python Joblib): 4.42 seconds In place in ( Python Numpy): 0.93 seconds In place in ( Python Numba): 0.49 seconds जिससे निम्नलिखित समय परिणाम प्राप्त हुआ:

आधार आर में समय: 1.30 सेकंड

In place in (  base Python): 11.89 seconds
In place in (Python Joblib): 4.42 seconds
In place in ( Python Numpy): 0.93 seconds
In place in ( Python Numba): 0.49 seconds

पर्ल परिणामों की तुलना में हम इस उदाहरण के बारे में निम्नलिखित नोट करते हैं:

बेस पायथन में इनप्लेस ऑपरेशन पर्ल की तुलना में ~3.5
• धीमे थे
सिंगल थ्रेडेड पीडीएल और न्यूम्पी ने लगभग समान परिणाम दिए, इसके बाद बेस आर का स्थान रहा
नुम्बा के संकलन ओवरहेड का हिसाब देने में विफलता से
• गलत धारणा बनती है कि यह नम्पी की तुलना में धीमी है। संकलन ओवरहेड के लिए लेखांकन करते समय, नंबा, नम्पी की तुलना में x2 तेज़ है
जॉबलिब के साथ समानांतरीकरण ने बेस पायथन पर सुधार किया, लेकिन अभी भी सिंगल थ्रेड पर्ल कार्यान्वयन से कमतर था
मल्टी-थ्रेडेड पीडीएल (और ओपनएमपी) सभी भाषाओं में हर दूसरे कार्यान्वयन को कुचल दिया गया (दुर्घटनाग्रस्त नहीं हुआ!)। आशा है कि यह पोस्ट विचार के लिए कुछ भोजन उपलब्ध कराता है आपके अगले डेटा/गणना गहन ऑपरेशन के लिए उपयोग की जाने वाली भाषा। इस श्रृंखला का अगला भाग सी में सरणियों का उपयोग करके उसी उदाहरण पर गौर करेगा। यह अंतिम किस्त (उम्मीद है) मेमोरी इलाके के प्रभाव और गतिशील रूप से टाइप की गई भाषाओं का उपयोग करके किए गए ओवरहेड के बारे में कुछ अंतर्दृष्टि प्रदान करेगी।