माउंट: भारी लोड वाले सर्वरों के लिए सी भाषा

अभिवादन, खब्रोवित्स!



मैं अतिरिक्त भाषा टूल को शुरू करके C में सर्वर प्रोग्राम के लेखन को सरल बनाने के बारे में चर्चा के लिए विचार प्रस्तुत करना चाहता हूं। मेरा मानना ​​है कि यह विषय उन सभी डेवलपर्स के लिए दिलचस्पी का हो सकता है, जिन्हें मल्टीथ्रेडेड या एसिंक्रोनस कोड लिखने से निपटना पड़ा है।



फिलहाल, मैंने लगभग एक टूलकिट - एक पार्सर जनरेटर, एक सी पार्सर और आंशिक रूप से सी ++ लिखना पूरा कर लिया है - जो आपको भाषा एक्सटेंशन का समर्थन करने वाले अनुवादक लिखना शुरू करने की अनुमति देता है, जिसकी मैं यहां चर्चा करूंगा। लेकिन जारी रखने से पहले, मैं कार्यशाला में सहयोगियों के साथ परामर्श करना चाहूंगा और समान विचारधारा वाले लोगों को ढूंढूंगा।



यह बहु-थ्रेडेड एसिंक्रोनस सर्वरों के बारे में होगा। एसिंक्रोनस - जो कि ईवेंट-आधारित ग्राहक-सेवा तर्क (एपोल / केक्यूयू) का उपयोग कर रहा है, जिसमें एक समय में कई ग्राहकों को एक थ्रेड द्वारा सेवा दी जाती है। मल्टीथ्रेडेड - का अर्थ है आधुनिक मल्टीकोर प्रोसेसर का लाभ उठाने के लिए तैयार, एक ही प्रक्रिया के भीतर कई थ्रेड्स द्वारा कनेक्शन के समानांतर रखरखाव का प्रदर्शन करना।



अतुल्यकालिक सेवा मॉडल आपको ऐसे सर्वर बनाने की अनुमति देता है जो वास्तव में उच्च भार के साथ काम करने के लिए तैयार हैं। लेकिन एसिंक्रोनस (गैर-ब्लॉकिंग) कोड को सिंक्रोनस, ब्लॉकिंग कोड की तुलना में लिखना अधिक कठिन है। इसके अलावा, एसिंक्रोनस मल्टी-थ्रेडेड कोड लिखना बहुत अधिक कठिन है: साझा डेटा तक पहुंच को सिंक्रनाइज़ करते समय गलतियां करना बहुत आसान है, और ऐसी त्रुटियों का पता लगाना बहुत मुश्किल है। यह इस तथ्य की ओर जाता है कि व्यवहार में यह बहुधा समर्थन करने के लिए पूरी तरह से मना करने के लिए अक्सर समझदार होता है।



ऐसे कार्यक्रमों को लिखने में कुछ अनुभव प्राप्त करने के बाद, मैंने नोटिस करना शुरू किया कि थ्रेड सिंक्रोनाइज़ेशन की मुख्य समस्याओं का समाधान मानक तरीकों से हल किया जाता है, जिसका उपयोग भाषा के स्तर पर स्वचालित किया जा सकता है, जो डेवलपर के लिए कार्य को काफी सरल बनाता है। तब मैंने देखा कि एक समान दृष्टिकोण का उपयोग करके, आप अतुल्यकालिक घटना प्रसंस्करण कोड को सरल बना सकते हैं। यह समाधानों की स्पष्ट व्यापकता के कारण है कि मैं इन गैर-सीधे संबंधित कार्यों के लिए भाषा जोड़ का एक सेट प्रस्तावित करता हूं।



विचार काफी सरल हैं, इसलिए, जटिलता की भावना पैदा नहीं करने के लिए, मैं सी पर मुख्य बिंदुओं को सूचीबद्ध करूंगा। मैं इन परिवर्धन को "माउंट भाषा" कहूंगा।



तो माउंट है:

• वस्तुओं तक पहुंच को सिंक्रनाइज़ करने के लिए स्वचालित म्यूटेक्स नियंत्रण;
• अतुल्यकालिक प्रसंस्करण श्रृंखलाएं, जिन्हें सामान्य अनुक्रमिक कार्यों के रूप में लिखा जाता है;
• एनोटेशन - स्रोत ग्रंथों के स्थैतिक विश्लेषण के लिए कार्यक्रम तत्वों का एक अतिरिक्त विवरण;
• अंतर्निहित लिंक गिनती तंत्र;
• C ++ से सबसे उपयोगी सुविधाओं का उधार लेना;
• सी संगत, सी एबीआई के लिए तंग बंधन। प्रारंभिक कार्यान्वयन माउंट से सी के लिए एक अनुवादक है।

मुझे समझाएं कि C, और C ++ क्यों नहीं, को आधार के रूप में चुना गया था। मुख्य कारण स्रोत ग्रंथों के अर्थ विश्लेषण के संदर्भ में C ++ की उच्च उच्च जटिलता है। पिछले एक साल में, मैंने C ++ पार्सर और C ++ कोड के स्थैतिक विश्लेषण के लिए एक प्रणाली लिखने का प्रयास किया है। परिणाम - सी पार्सर और पार्सिंग सी-शैली शब्दार्थ बहुत आसान थे, लेकिन सी ++ पार्सिंग पूरी तरह से दूर है: काम की मात्रा बहुत बड़ी है। इसलिए, मैंने फैसला किया कि आप शुद्ध सी पर भरोसा करके और उन सी ++ विशेषताओं के साथ पूरक करके अच्छे व्यावहारिक परिणाम प्राप्त कर सकते हैं जो लागू करने के लिए काफी सरल हैं।



इसके बाद, मैं प्रत्येक जोड़ के बारे में अधिक विस्तार से बात करूंगा। मैं सी ++ में कोड के कुछ उदाहरण देता हूं, क्योंकि उन्हें माउंट में बराबर कोड के साथ सहसंबंधित करना आसान है।

1. स्वचालित म्यूटेक्स नियंत्रण

एक सामान्य अनुरोध प्रसंस्करण योजना पर विचार करें। मान लीजिए कि हमारे पास MyFrontend वर्ग की कुछ वस्तु है, जो हमारे सर्वर का कार्यान्वयन है। क्लाइंट से अनुरोध को प्राप्त करने और डिकोड करने के बाद, हम सर्वर ऑब्जेक्ट प्रक्रिया की विधि को कहते हैं। यह विधि कुछ ऑपरेशन करती है जो सर्वर की आंतरिक स्थिति में बदलाव का कारण बनती है। उदाहरण के लिए, मान लें कि अनुरोध संसाधित करने के परिणामस्वरूप, संख्या के अनुरोधों की संख्या num_requests बढ़ जाती है:



class MyFrontend

{

private :

Mutex state_mutex ;

unsigned num_requests ;



public :

void processRequest ( )

{

state_mutex. lock ( ) ;

++ num_requests ;

state_mutex. unlock ( ) ;

}

} ;







माउंट मैनुअल सिंक्रनाइज़ेशन की आवश्यकता को समाप्त करता है:



async object MyFrontend

{

private :

unsigned num_requests ;



public :

async void processRequest ( )

{

++ num_requests ;

}

} ;







async ऑब्जेक्ट ऑब्जेक्ट के थ्रेड सुरक्षित वर्ग की घोषणा करता है। ऐसी वस्तुओं को अतुल्यकालिक कहा जाएगा। दिए गए माउंट कोड उदाहरण को दिए गए C ++ उदाहरण के बराबर कोड में अनुवादित किया गया है।



अब मान लें कि अनुरोध को संसाधित करने के लिए, MyFrontend को MyBackend ऑब्जेक्ट के doSomething () विधि को कॉल करना चाहिए, इसे एक पैरामीटर के रूप में num_back बैकएंड एक्सेस काउंटर पास करना चाहिए। इसके अलावा, हम गतिरोध की संभावना के बारे में नहीं सोचना चाहते हैं और गैर-पुनरावर्ती म्यूटेक्स के साथ काम करना चाहते हैं। ऐसा करने के लिए, मुझे MyBackend तक पहुँचने से पहले State_mutex को खाली करना होगा:



class MyFrontend

{

private :

Mutex state_mutex ;

unsigned num_requests ;

unsigned num_back ;

MyBackend * backend ;



public :

void processRequest ( )

{

state_mutex. lock ( ) ;

++ num_back ;

unsigned tmp_num_back = tmp_num_back ;

state_mutex. unlock ( ) ;



backend - > doSomething ( tmp_num_back ) ;



state_mutex. lock ( ) ;

++ num_requests ;

state_mutex. unlock ( ) ;

}

} ;







माउंट पर एक ही बात:



async object MyFrontend

{

private :

unsigned num_requests ;

unsigned num_back ;

MyBackend * backend ;



public :

async void processRequest ( )

{

call backend - > doSomething ( ++ num_back ) ;

++ num_requests ;

}

} ;







माउंट अनुवादक स्वतंत्र रूप से state_mutex के साथ संचालन सम्मिलित करता है और पैरामीटर पारित करने के लिए एक अस्थायी चर में प्रवेश करता है। कॉल ऑपरेटर को इस बात पर जोर देने के लिए पेश किया गया था कि उस समय के लिए किसी अन्य ऑब्जेक्ट की एसिंक्रोनस विधि को कहा जाता है, हम State_mutex लॉक जारी करते हैं। इसके अलावा, यह अभिव्यक्ति में अतुल्यकालिक तरीकों को स्पष्ट रूप से प्रतिबंधित करने की अनुमति देता है।



उपरोक्त उदाहरणों के अलावा, तालों का उपयोग करने के कई अन्य मामले स्वचालित हैं: घटनाओं की प्रतीक्षा करना (घटनाओं को आमतौर पर प्रतीक्षा के पूरा होने के लिए स्थिति की रक्षा करने वाले म्यूटेक्स के साथ संयोजन में उपयोग किया जाता है), किसी वस्तु के अतुल्यकालिक विधि को उसी वस्तु के किसी अन्य तरीके से कॉल करना।



इस प्रकार, हम किसी वस्तु की स्थिति पर एक साधारण लॉक का प्रबंधन करते समय गलतियाँ करने के जोखिम को कम करते हैं। मेरी टिप्पणियों के अनुसार, यदि किसी वस्तु तक पहुंच का सिंक्रनाइज़ेशन एक नहीं, बल्कि कई तालों का उपयोग करके किया जाता है, तो सबसे अधिक संभावना है कि एक असफल डिजाइन है: आपको या तो वस्तु को कई स्वतंत्र वस्तुओं में विभाजित करना चाहिए, या ताले को एक में विलय करना चाहिए। इसलिए, एक म्यूटेक्स के साथ सबसे सरल मामले को स्वचालित करके, हम अधिकतर सिंक्रनाइज़ेशन समस्याओं को हल करते हैं। मैन्युअल रूप से सिंक्रनाइज़ करने और अन्य आदिम का उपयोग करने की क्षमता

बचा लिया।

2. अतुल्यकालिक प्रसंस्करण श्रृंखलाएं

मेरी राय में, यह सबसे दिलचस्प और असामान्य विचार है। मैं एक उदाहरण के साथ समझाऊंगा जो एक वास्तविक सेवा के संचालन को दर्शाता है।



मान लीजिए कि हमारा सर्वर फोटो होस्टिंग का फ्रंट एंड है। हम उपयोगकर्ताओं के फ़ोटो के साथ HTML- पृष्ठों के ग्राहकों को वापसी का एहसास करना चाहते हैं। पृष्ठ फ़ोटो स्वामी की प्रोफ़ाइल और फ़ोटो से ही जानकारी प्रदर्शित करता है। तस्वीरें केवल फोटो मालिकों के दोस्तों द्वारा देखी जा सकती हैं। इस प्रकार, HTTP अनुरोध का जवाब देने के लिए, आपको कई आंतरिक सेवाओं का सर्वेक्षण करके आवश्यक जानकारी एकत्र करने की आवश्यकता है।



अनुरोध प्रसंस्करण एल्गोरिथ्म:

1. उपयोगकर्ता (check_auth) की पहचान करने के लिए प्रमाणीकरण सर्वर पर कुकी कुकी भेजें;
2. प्राधिकरण की जाँच करने के बाद, उपयोगकर्ताओं को मित्र (check_friends) हैं यह जांचने के लिए सामाजिक ग्राफ़ परोसने वाले सर्वर को एक अनुरोध भेजें;
3. व्यक्तिगत डेटा रिपॉजिटरी (get_userinfo) के लिए फ़ोटो स्वामी को अनुरोध भेजें;
4. Check_friends और get_userinfo से उत्तर प्राप्त करने के बाद, एक HTML पृष्ठ बनाएं और इसे क्लाइंट को भेजें।

ऑपरेशन 2 अनुरोध के जवाब प्राप्त करने के बाद ही किया जा सकता है। अनुरोध 3 अनुरोध 1 और 2 पर निर्भर नहीं करता है और हम चाहते हैं कि इसे उनके साथ समानांतर में निष्पादित किया जाए।



चलो सी में कार्यान्वयन को स्केच करते हैं। आप इस उदाहरण की समझ नहीं पा सकते हैं। उनका काम यह दिखाना है कि इतनी सरल अतुल्यकालिक प्रसंस्करण श्रृंखला का मैनुअल कार्यान्वयन कितना बोझिल है:



// .

typedef struct {

// "" , .

MReferenced parent_referenced ;

// .

MMutex state_mutex ;



uint64_t owner_id ;

uint32_t photo_id ;



// 'true', .

bool cancel ;



// get_userinfo?

bool got_userinfo ;

// ( ).

uint32_t owner_carma ;



// check_friends?

bool got_friends ;

} HttpPhotoData ;



static void http_photo_data_init ( HttpPhotoData * data )

{

m_referenced_init ( ( MReferenced * ) data ) ;

m_mutex_init ( & data - > state_mutex ) ;



data - > cancel = false ;

data - > got_userinfo = false ;

data - > got_friends = false ;

}



static void http_photo__get_userinfo_ret ( uin32_t owner_carma,

void * _data ) ;



static void http_photo__check_auth_ret ( uint64_t client_id,

void * _data ) ;



static void http_photo__end ( HttpPhotoData * data ) ;



// .

void http_photo ( char * cookie_str,

uint64_t owner_id,

uint32_t photo_id )

{

HttpPhotoData * data = m_malloc ( sizeof ( HttpPhotoData ) ) ;

http_photo_data_init ( data ) ;



data - > owner_id = owner_id ;

data - > photo_id = photo_id ;



{

m_referenced_ref ( ( MReferenced * ) data ) ;



MCallbackDesc cb ;

m_callback_desc_init_refdata ( & cb, http_photod__get_userinfo_ret, data ) ;



get_userinfo ( & cb, owner_id ) ;

}



{

m_referenced_ref ( ( MReferenced * ) data ) ;



MCallbackDesc cb ;

m_callback_desc_init_refdata ( & cb, http_photod__check_auth_ret, data ) ;



check_auth ( & cb, cookie_str ) ;

}



m_referenced_unref ( ( MReferenced * ) data ) ;

}



// get_userinfo.

static void http_photo__get_userinfo_ret ( uint32_t owner_carma,

void * _data )

{

HttpPhotoData * data = ( HttpPhotoData * ) _data ;



m_mutex_lock ( & data - > state_mutex ) ;



if ( data - > cancel ) {

m_mutex_unlock ( & data - > state_mutex ) ;

return ;

}



data - > owner_carma = owner_carma ;

data - > got_userinfo = true ;



if ( data - > got_friends ) {

// , .

http_photo_end ( data ) ;

}



m_mutex_unlock ( & data - > state_mutex ) ;

}



// check_auth.

static void http_photo__check_auth_ret ( uint64_t client_id,

void * _data )

{

HttpPhotoData * data = ( HttpPhotoData * ) _data ;



m_referenced_ref ( ( MReferenced * ) data ) ;



MCallbackDesc cb ;

m_callback_desc_init_refdata ( & cb, http_photo__check_friends_ret, data ) ;



check_friends ( & cb, client_id, data - > owner_id ) ;

}



// check_friends.

static void http_photo__check_friends_ret ( bool friends,

void * _data )

{

HttpPhotoData * data = ( HttpPhotoData * ) _data ;



m_mutex_lock ( & data - > state_mutex ) ;

if ( data - > cancel ) {

m_mutex_unlock ( & data - > state_mutex ) ;

return ;

}



data - > got_friends = true ;



if ( ! friends ) {

// . .

data - > cancel = true ;

m_mutex_unlock ( & data - > state_mutex ) ;

return ;

}



if ( data - > got_userinfo ) {

// , .

http_photo_end ( data ) ;

}



m_mutex_unlock ( data - > state_mutex ) ;

}



// .

static void http_photo_end ( HttpPhotoData * data )

{

photo_send_page ( data - > owner_id, data - > photo_id, data - > owner_carma ) ;

}







परिणामी कोड जटिल है, इसे पढ़ना मुश्किल है। अधिकांश समय जब इसे लिखना परिचालन के आवश्यक क्रम के नियमित रखरखाव पर खर्च किया गया था।



माउंट पर समतुल्य कार्यान्वयन:



async chain void http_photo ( char * cookie_str,

uint64_t owner_id,

uint32_t photo_id )

{

async call GetUserinfoCall get_userinfo ( owner_id ) ;



async call check_auth ( cookie ) ;

gives uint64_t client_id ;



async call check_friends ( client_id, owner_id )

gives bool friends ;



if ( ! friends ) {

//

return ;

}



GetUserinfoCall gives uint32_t owner_carma ;



// HTTP- .

photo_send_page ( owner_id, photo_id, owner_carma ) ;

}







कृपया ध्यान दें कि हम निष्पादन के आवश्यक आदेश को व्यवस्थित करने के नियमित कार्य से लगभग पूरी तरह से मुक्त हो गए हैं। इसके अलावा, उत्पन्न सी कोड का उपयोग बहु-थ्रेडेड कार्यक्रमों में किया जा सकता है।



उपरोक्त उदाहरण में, दो नए ऑपरेटरों का उपयोग किया जाता है:

• Async कॉल स्टेटमेंट एक एसिंक्रोनस कॉल का वर्णन करता है। इस ऑपरेटर के साथ उपयोग किए जा सकने वाले फ़ंक्शंस में एक विशेष हस्ताक्षर होना चाहिए: पहला पैरामीटर कॉलबैक है, जिसे कॉल समाप्त होने पर कॉल किया जाएगा। कॉलबैक समाप्ति को आवश्यक रूप से किसी भी परिणाम पर बुलाया जाना चाहिए, चाहे वह एक सफल कॉल, एक आंतरिक त्रुटि, या एक समयबाह्य हो।
• यह कथन उस बिंदु को सेट करता है जिस पर निर्दिष्ट एसिंक्रोनस कॉल के पूरा होने की प्रतीक्षा करनी है। कॉल के द्वारा लौटाए गए मानों की सूची को दायरे में पेश करता है। यदि एसिंक्स कॉल और स्टेटमेंट्स देना आवश्यक है, तो एसिंक्स कॉल में कॉल का नाम दिया गया है और कॉल का नाम संकेत में दिया गया है (उपरोक्त उदाहरण में GetUserinfoCall देखें)।

दिखाए गए ऑपरेटरों के अलावा, अतुल्यकालिक कॉल के परिणामों को जल्दी से संसाधित करना संभव है ताकि यदि हम संबंधित विफल ऑपरेटर कॉल को प्राप्त करने से पहले कोई त्रुटि होती है तो श्रृंखला बाधित हो सकती है। आप श्रृंखला की राज्य संरचना में शामिल डेटा के लिए एक अतिरिक्त विध्वंसक भी निर्दिष्ट कर सकते हैं।



C में अतुल्यकालिक जंजीरों का अनुवाद करते समय माउंट जो मुख्य काम करता है वह इस प्रकार है:

• श्रृंखला राज्य संरचना (HttpPhotoData) में संग्रहीत किए जाने वाले चर का एक सेट परिभाषित करता है;
• फ़ंक्शन को छोटे वाले में विभाजित करता है। विराम बिंदु async कॉल स्टेटमेंट हैं;
• यह सी बयानों को परिवर्तित करके आवश्यक निष्पादन आदेश प्रदान करता है जो कि एसिंक्स कॉल द्वारा उल्लंघन किया जाता है और निर्धारित नियमों के अनुसार समान अतुल्यकालिक निर्माणों में बयान देता है।

यह दिखाया जा सकता है कि इनमें से प्रत्येक ऑपरेशन स्वचालन के लिए अच्छी तरह से उधार देता है।



माउंट में एकल फ़ंक्शन द्वारा प्रतिनिधित्व नहीं किए जा सकने वाले संचालन की जटिल श्रृंखलाओं के समानांतर निष्पादन को कई अलग-अलग अतुल्यकालिक श्रृंखलाओं का उपयोग करके लागू किया जा सकता है। यही है, यदि श्रृंखला में शाखाएं इतनी जटिल हैं कि उन्हें एक फ़ंक्शन द्वारा वर्णित नहीं किया जा सकता है, तो आप कई कार्यों की संरचना के रूप में विवरण का निर्माण कर सकते हैं।



माउंट की मदद से, हम नियमित कोड लिखते समय समान और समान रूप में, अतुल्यकालिक कॉल से जवाब की प्रतीक्षा करके टूटे हुए छोरों और सशर्त कूदता का वर्णन कर सकते हैं। मान लें कि हम बदले में तीन स्वतंत्र कैश में एक मूल्य देखना चाहते हैं:



async chain void search ( int key )

{

for ( int i = 0 ; i < 3 ; i ++ ) {

async call search_cache ( key, i /* cache id */ )

gives int value ;



if ( value > 0 ) {

printf ( "VALUE: %d \n " , value ) ;

break ;

}

}

}







इस प्रकार, अतुल्यकालिक प्रसंस्करण श्रृंखलाओं के लिए, माउंट सी की तुलना में व्यक्त और प्रयोज्य में एक क्वांटम छलांग प्रदान कर सकता है।

3. एनोटेशन

एनोटेशन, एनोटेटिंग शब्दों का उपयोग करके अतिरिक्त सहायक जानकारी के कोड का एक परिचय है। एनोटेटिंग शब्द जहां भी खड़े हो सकते हैं, वहीं कास्ट और वाष्पशील क्वालिफायर खड़े हो सकते हैं। सभी एनोटेटिंग शब्द अक्षर '$' से शुरू होते हैं। उदाहरण:

int * $nonnull ptr ; // NULL

MyObject * $heap myobj ; //







माउंट अनुवादक एक स्थिर कोड सत्यापन प्रणाली के लिए भी आधार है जो अतिरिक्त जांच के लिए एनोटेशन का उपयोग करता है।

4. उधार सी + + सुविधाएँ

अनुवादक कार्यान्वयन के दृष्टिकोण से, C की तुलना में C ++ की सबसे जटिल विशेषता डेटा प्रकार के तर्कों पर भाषा के निर्माण के अर्थ अर्थ की निर्भरता है। यह चिंता, सबसे पहले, फ़ंक्शन नामों को ओवरलोड करने के लिए नियम (ऑपरेटर ओवरलोडिंग सहित) और टेम्पलेट चुनने के लिए नियम, आंशिक विशेषज्ञता को ध्यान में रखते हुए। इस तरह की निर्भरता का अर्थ है कि यह निर्धारित करने के लिए कि किस फ़ंक्शन या टेम्पलेट का उपयोग जलसेक में किया गया है, आपको फ़ंक्शन या टेम्पलेट के सभी प्रकार के डेटा प्रकार प्राप्त करने की आवश्यकता है। यह बदले में, प्रकार रूपांतरण नियमों के पूर्ण और सटीक कार्यान्वयन की आवश्यकता है। यह सब काम की एक महत्वपूर्ण राशि बनाता है।



इसी समय, नाम अधिभार भाषा की एक विवादास्पद संपत्ति है। उदाहरण के लिए, गो भाषा के रचनाकारों ने इसे अस्वीकार कर दिया, क्योंकि FAQ में एक सार्थक प्रविष्टि है ।



माउंट फ़ंक्शन नाम और ऑपरेटर अधिभार, एकाधिक विरासत, अपवाद, RTTI को अधिभार नहीं देगा। आंशिक विशेषज्ञता के बिना टेम्पलेट्स को लागू करना इतना मुश्किल नहीं है, और यह सामान्यीकृत कंटेनर कक्षाएं बनाने के लिए पर्याप्त है, इसलिए यह भाषा में टेम्पलेट्स को शामिल करने के लिए समझ में आता है। ओवरलोडिंग के नाम की अनुपस्थिति में, टेम्प्लेट एक बहुत सरल और लेकोनिक उपकरण बन जाएगा: C ++ जैसी कोई मेटाप्रोग्रामिंग क्षमताएं नहीं होंगी।

5. लिंक और कमजोर लिंक

ऑपरेटर ओवरलोडिंग की अनुपस्थिति माउंट में "स्मार्ट पॉइंटर्स" के सुविधाजनक एनालॉग्स को लागू करना असंभव बना देती है, जैसे कि std :: auto_ptr और boost :: shared_ptr। इसके बजाय, भाषा स्तर पर एक लिंक गिनती तंत्र प्रस्तावित है:

int @a ; //

int @@b ; //







मूल संस्करण सरल संदर्भ गिनती का उपयोग करता है। लिंक काउंटर बिल्ट-इन

प्रत्येक सिंक्रोनस या एसिंक्रोनस माउंट ऑब्जेक्ट (ऑब्जेक्ट और एसिंक्स ऑब्जेक्ट) में। लिंक प्रबंधन के इस दृष्टिकोण के साथ, प्रोग्रामर को परिपत्र लिंक बनाने से बचना चाहिए जो मेमोरी लीक की ओर ले जाते हैं। कमजोर लिंक का उपयोग छोरों को तोड़ने के लिए किया जाता है। भविष्य में, आप अधिक जटिल कचरा कलेक्टर का उपयोग करने की संभावना पर विचार कर सकते हैं, लेकिन अब मुझे इसकी आवश्यकता नहीं दिखती है।



ऑपरेटर ओवरलोडिंग की अनुपस्थिति में, माउंट में सी ++ लिंक (फॉर्म इंट & ए) का समर्थन करने की आवश्यकता नहीं है।



मैं ध्यान देता हूं कि भाषा के स्तर पर लिंक के कार्यान्वयन से आप C ++ टेम्प्लेट पर बनाए जा सकने वाले से अधिक पूर्ण और सुविधाजनक तंत्र प्राप्त कर सकते हैं।

निष्कर्ष

मैंने उन मुख्य विशेषताओं को रेखांकित किया है जिन्हें मैं माउंट में शामिल करने का इरादा रखता हूं। उनके अलावा, विकास को सरल बनाने और कार्यक्रमों में अपेक्षित त्रुटियों को कम करने के उद्देश्य से विकास में अन्य विचार हैं।



माउंट भाषा अनुवादक एक ओपन सोर्स प्रोजेक्ट है। वर्तमान में, यह C ++ भाषा के पार्सटर के एक उपसमुच्चय के रूप में मौजूद है और कामकाजी नाम " स्क्रूफी " के तहत svn रिपॉजिटरी mync.svn.sourceforge.net/svnroot/mync/trunk में रहता है।



यदि आपके पास C / C ++ भाषाओं के कुछ गुणों को जोड़ने या बदलने पर विचार हैं, तो मैं उन्हें आवाज़ देने का सुझाव देता हूं: शायद उनके व्यावहारिक परीक्षण का समय आ गया है।



मैं आपको परियोजना में भाग लेने के लिए आमंत्रित करता हूं। यदि आप स्वतंत्र काम के लिए एक विषय की तलाश कर रहे हैं, जो नया ज्ञान और अनुभव दे सके, और यदि उच्च गुणवत्ता और सफल उत्पाद में सफल हो जाए, तो एक नई भाषा संकलक एक उत्कृष्ट विकल्प हो सकता है। यदि माउंट पर जिन समस्याओं का उद्देश्य है, वे आपके लिए बहुत प्रासंगिक नहीं हैं, तो आप सी ++ पार्सर और सी / सी ++ कार्यक्रमों के स्थैतिक विश्लेषण के लिए एक प्रणाली विकसित करने में रुचि रख सकते हैं।



साथ में हम और अधिक कर सकते हैं!



आपका ध्यान देने के लिए धन्यवाद।