பைத்தானில் ஆழமான பரம்பரை செயல்திறன் தாக்கத்தை பகுப்பாய்வு செய்தல்

விரிவான வர்க்க பரம்பரை செலவை ஆராய்தல்

பொருள் சார்ந்த நிரலாக்கத்தில், பரம்பரை என்பது ஒரு சக்திவாய்ந்த பொறிமுறையாகும், இது குறியீடு மறுபயன்பாடு மற்றும் படிநிலை கட்டமைப்பை அனுமதிக்கிறது. இருப்பினும், ஒரு வர்க்கம் மிகப் பெரிய எண்ணிக்கையிலான பெற்றோர் வகுப்புகளிலிருந்து பெறும்போது என்ன நடக்கும்? Set அத்தகைய அமைப்பின் செயல்திறன் தாக்கங்கள் சிக்கலான மற்றும் அற்பமானவை.

பைதான், ஒரு மாறும் மொழியாக இருப்பதால், முறை தீர்மானம் வரிசை (எம்.ஆர்.ஓ) மூலம் பண்புக்கூறு தேடல்களை தீர்க்கிறது. இதன் பொருள் ஒரு நிகழ்வு ஒரு பண்புக்கூறு அணுகும்போது, ​​பைதான் அதன் பரம்பரை சங்கிலி வழியாக தேடுகிறது. ஆனால் பெற்றோர் வகுப்புகளின் எண்ணிக்கை அணுகல் வேகத்தை கணிசமாக பாதிக்கிறதா?

இதற்கு பதிலளிக்க, அதிகரிக்கும் பரம்பரை அளவைக் கொண்ட பல வகுப்புகளை உருவாக்குவதன் மூலம் ஒரு பரிசோதனையை மேற்கொண்டோம். பண்புகளை அணுக எடுக்கப்பட்ட நேரத்தை அளவிடுவதன் மூலம், செயல்திறன் வீழ்ச்சி நேரியல், பல்லுறுப்புறுப்பு அல்லது அதிவேகதா என்பதை தீர்மானிப்பதை நோக்கமாகக் கொண்டுள்ளோம். .

ஆழ்ந்த பரம்பரை கட்டமைப்புகளுடன் பெரிய அளவிலான பயன்பாடுகளை வடிவமைக்கும் டெவலப்பர்களுக்கு இந்த கண்டுபிடிப்புகள் முக்கியமானவை. இந்த செயல்திறன் பண்புகளைப் புரிந்துகொள்வது தகவலறிந்த கட்டடக்கலை முடிவுகளை எடுக்க உதவும். தரவுகளில் முழுக்குள் மற்றும் முடிவுகளை ஆராய்வோம்! .

ஆழமான பரம்பரை செயல்திறன் தாக்கத்தைப் புரிந்துகொள்வது

மேலே வழங்கப்பட்ட ஸ்கிரிப்ட்கள் ஆழ்ந்த மரபுசெய்யப்பட்ட வகுப்புகளின் செயல்திறன் தாக்கத்தை மதிப்பிடுவதை நோக்கமாகக் கொண்டுள்ளன பைதான். சோதனை என்பது வெவ்வேறு பரம்பரை கட்டமைப்புகளைக் கொண்ட பல வகுப்புகளை உருவாக்குவது மற்றும் அவற்றின் பண்புகளை அணுக தேவையான நேரத்தை அளவிடுவது ஆகியவை அடங்கும். துணைப்பிரிவுகளின் அதிகரிப்பு a க்கு வழிவகுக்கிறதா என்பதை தீர்மானிப்பதே முக்கிய யோசனை நேரியல், பல்லுறுப்புறுப்பு, அல்லது பண்புக்கூறு மீட்டெடுப்பில் அதிவேக மந்தநிலை. இதைச் செய்ய, நாங்கள் வகுப்புகளை மாறும் வகையில் உருவாக்குகிறோம், பண்புகளை ஒதுக்குகிறோம், செயல்திறன் தரப்படுத்தல் நுட்பங்களைப் பயன்படுத்துகிறோம். .

பயன்படுத்தப்படும் முக்கிய கட்டளைகளில் ஒன்று வகை (), இது வகுப்புகளை மாறும் வகையில் உருவாக்க அனுமதிக்கிறது. 260 வெவ்வேறு வகுப்புகளை கைமுறையாக வரையறுப்பதற்கு பதிலாக, அவற்றை பறக்கும்போது சுழல்களைப் பயன்படுத்துகிறோம். ஒவ்வொரு வகுப்பையும் கைமுறையாக எழுதுவது திறமையற்றதாக இருக்கும் என்பதால், இது அளவிடக்கூடிய தன்மைக்கு முக்கியமானது. மாறும் உருவாக்கப்பட்ட வகுப்புகள் துணைப்பிரிவு பெயர்களைப் பயன்படுத்தி பல பெற்றோர் வகுப்புகளிலிருந்து பெறுகின்றன. பண்புக்கூறு தேடல் ஒரு நீண்ட பரம்பரைச் சங்கிலியைக் கடக்க வேண்டியிருக்கும் போது பைதானின் முறை தீர்மானம் (எம்.ஆர்.ஓ) செயல்திறனை எவ்வாறு பாதிக்கிறது என்பதை ஆராய இந்த அமைப்பு நம்மை அனுமதிக்கிறது.

செயல்திறனை அளவிட, நாங்கள் பயன்படுத்துகிறோம் நேரம் () இருந்து நேரம் தொகுதி. 2.5 மில்லியன் முறை பண்புகளை அணுகுவதற்கு முன்னும் பின்னும் நேர முத்திரைகளைப் பிடிப்பதன் மூலம், பைதான் மதிப்புகளை எவ்வளவு விரைவாக மீட்டெடுக்கிறது என்பதை நாம் தீர்மானிக்க முடியும். கூடுதலாக, getattr () நேரடி பண்புக்கூறு அணுகலுக்கு பதிலாக பயன்படுத்தப்படுகிறது. பண்புக்கூறு பெயர்கள் ஹார்ட்கோட் செய்யப்படாமல் ஆனால் மாறும் வகையில் மீட்டெடுக்கக்கூடிய நிஜ உலக காட்சிகளை நாங்கள் அளவிடுவதை இது உறுதி செய்கிறது. எடுத்துக்காட்டாக, வலை கட்டமைப்புகள் அல்லது ORM அமைப்புகள் போன்ற பெரிய அளவிலான பயன்பாடுகளில், உள்ளமைவுகள் அல்லது தரவுத்தளங்களிலிருந்து பண்புக்கூறுகள் மாறும் வகையில் அணுகப்படலாம். .

கடைசியாக, வெவ்வேறு வர்க்க கட்டமைப்புகளை அவற்றின் தாக்கத்தை பகுப்பாய்வு செய்ய ஒப்பிடுகிறோம். மந்தநிலை ஓரளவு நேர்கோட்டுடன் இருக்கும்போது, ​​செயல்திறன் எதிர்பாராத விதமாக குறையும் முரண்பாடுகள் உள்ளன என்பதை முடிவுகள் வெளிப்படுத்துகின்றன, இது பைத்தானின் அடிப்படை மேம்படுத்தல்கள் ஒரு பாத்திரத்தை வகிக்கக்கூடும் என்று கூறுகிறது. ஆழ்ந்த பரம்பரை கொண்ட சிக்கலான அமைப்புகளை உருவாக்க டெவலப்பர்களுக்கு இந்த நுண்ணறிவுகள் பயனுள்ளதாக இருக்கும். பரம்பரை மீது கலவை அல்லது சிறந்த செயல்திறனுக்காக அகராதி அடிப்படையிலான பண்புக்கூறு சேமிப்பு போன்ற மாற்று அணுகுமுறைகளைப் பயன்படுத்துவது நல்லது.

from time import time
TOTAL_ATTRS = 260
attr_names = [f"a{i}" for i in range(TOTAL_ATTRS)]
all_defaults = {name: i + 1 for i, name in enumerate(attr_names)}
class Base: pass
subclasses = [type(f"Sub_{i}", (Base,), {attr_names[i]: all_defaults[attr_names[i]]}) for i in range(TOTAL_ATTRS)]
MultiInherited = type("MultiInherited", tuple(subclasses), {})
instance = MultiInherited()
t = time()
for _ in range(2_500_000):
    for attr in attr_names:
        getattr(instance, attr)
print(f"Access time: {time() - t:.3f}s")

from time import time
TOTAL_ATTRS = 260
attr_names = [f"a{i}" for i in range(TOTAL_ATTRS)]
class Optimized:
    def __init__(self):
        self.attrs = {name: i + 1 for i, name in enumerate(attr_names)}
instance = Optimized()
t = time()
for _ in range(2_500_000):
    for attr in attr_names:
        instance.attrs[attr]
print(f"Optimized access time: {time() - t:.3f}s")

பெரிய பரம்பரை வரிசைமுறைகளில் பைதான் செயல்திறனை மேம்படுத்துதல்

பைத்தானின் பரம்பரை அமைப்பின் ஒரு முக்கியமான அம்சம், பல பெற்றோர் வகுப்புகளில் உள்ள பண்புகளை இது எவ்வாறு தீர்க்கிறது என்பதுதான். இந்த செயல்முறை பின்வருமாறு முறை தீர்மான ஆணை (எம்.ஆர்.ஓ), இது ஒரு பொருளின் பரம்பரை மரத்தில் ஒரு பண்புக்கூறைத் தேடும் வரிசையை ஆணையிடுகிறது. ஒரு வர்க்கம் பல பெற்றோரிடமிருந்து பெறும்போது, ​​பைதான் பண்புகளைக் கண்டறிய ஒரு நீண்ட பாதையில் செல்ல வேண்டும், இது செயல்திறனை பாதிக்கும். .

பண்புக்கூறு தேடலுக்கு அப்பால், மற்றொரு சவால் நினைவக பயன்பாட்டுடன் எழுகிறது. பைத்தானில் உள்ள ஒவ்வொரு வகுப்பிலும் ஒரு அகராதி உள்ளது __dict__ அது அதன் பண்புகளை சேமிக்கிறது. பல வகுப்புகளிலிருந்து மரபுரிமையாக இருக்கும்போது, ​​நினைவக தடம் வளர்கிறது, ஏனெனில் பைத்தான் அனைத்து பரம்பரை பண்புகளையும் முறைகளையும் கண்காணிக்க வேண்டும். இது நினைவக நுகர்வுக்கு வழிவகுக்கும், குறிப்பாக ஆயிரக்கணக்கான துணைப்பிரிவுகள் சம்பந்தப்பட்ட சந்தர்ப்பங்களில்.

ஆழ்ந்த பரம்பரை ஒரு நடைமுறை மாற்று பரம்பரை மீது கலவை. Instead of creating deeply nested class structures, developers can use object composition, where a class contains instances of other classes instead of inheriting from them. This method reduces complexity, improves maintainability, and often leads to better performance. For example, in a game engine, instead of having a deep hierarchy like `Vehicle -> Car ->. ஆழமான உள்ளமைக்கப்பட்ட வர்க்க கட்டமைப்புகளை உருவாக்குவதற்கு பதிலாக, டெவலப்பர்கள் பொருள் அமைப்பைப் பயன்படுத்தலாம், அங்கு ஒரு வகுப்பில் பிற வகுப்புகளின் நிகழ்வுகள் அவற்றில் இருந்து மரபுரிமையாக இருப்பதற்கு பதிலாக உள்ளன. இந்த முறை சிக்கலைக் குறைக்கிறது, பராமரிப்பை மேம்படுத்துகிறது, மேலும் பெரும்பாலும் சிறந்த செயல்திறனுக்கு வழிவகுக்கிறது. எடுத்துக்காட்டாக, ஒரு விளையாட்டு இயந்திரத்தில், `வாகனம் -> கார் -> எலக்ட்ரிக் காரை` போன்ற ஆழமான படிநிலைக்கு பதிலாக, ஒரு` வாகனம்` வகுப்பில் `மோட்டார்` பொருளை உள்ளடக்கியிருக்கலாம், இது மிகவும் மட்டுப்படுத்தப்பட்டதாகவும் திறமையாகவும் இருக்கும். .