मैं छद्म कोड में लिखता हूं, यह PHP में काम करता है

मैं छद्म कोड में प्रोग्राम लिख सकता हूं और उन्हें PHP कोड में बदल सकता हूं। या पोर्टेबल सी में। या कुछ और। सूची को अद्यतन किया जाएगा।



प्रोजेक्ट का वह भाग जो "PHP में कनवर्ट किया गया है" पूरी तरह से तैयार नहीं है। लेकिन मैं अब एक लेख लिख रहा हूं:

• यह पता करें कि परियोजना में और कौन रुचि रखता है;
• अनुभवी phpshniks से पूछें कि मेरे PHP कोड को कैसे सुधारें और कैसे मापें जो वास्तव में धीमा हो।

एक उदाहरण और तकनीकी विवरण हैबरकोट के तहत।



कार्यक्रम का उदाहरण:



( display "Hello, world!\n")







या अधिक जटिल:



( define (- -)

( lambda () ( display -)))

( define - ( - "!\n"))

( - )







इस उदाहरण में, एक फ़ंक्शन एक फ़ंक्शन देता है। PHP में, कोड इस तरह दिखेगा (काम नहीं करता है):



function _($_) {

return function () {

print $_;

}

}

$_ = _ ("!\n");

$ _ ();







अन्य उदाहरणों को जीथब पर या संग्रह में देखा जा सकता है। टेस्ट काम करता है कि काम करता है



* कम से कम कुछ (उदाहरण "हैलो, दुनिया")

* पुनरावृत्ति (तथ्यात्मक, दंतकथाएं, एकरमैन)

* सर्किट

* निरंतरता



सभी महत्वपूर्ण चीजें काम करती हैं। R5RS मानक के पूर्ण कार्यान्वयन तक, यह केवल आदिम बनाने के लिए बनी हुई है। अरे हाँ, दुर्घटना से मेरा छद्म कोड योजना R5RS भाषा से मेल खाता है।



अपने प्रोजेक्ट के लिए, मैं Gambit स्कीमा कंपाइलर का उपयोग करता हूं। इसके अंदर एक रजिस्टर-स्टैक वर्चुअल मशीन GVM ( कुशल योजना संकलन के लिए एक समानांतर आभासी मशीन ) है। जब GVM की बात आती है तो यह हमारा उदाहरण बन जाता है:



; +N: N

; -N: N

; : +1, +2 ..

; +1

; continuation-passing style, - +0

; , escape sequences

;

; #1

#1 0 entry-point 0 ()

; "-"

|~#-| = '#<procedure |~#-|>

-1 = +0

+1 = '"!\n"

+0 = #3

; #2

jump* 4 #2

#2 4

; . +0 #3, , +1 ()

jump$ 4 |~#-| 1

#3 4 return-point

|~#-| = +1

+0 = -1

jump* 4 #4

#4 4

jump$ 0 |~#-| 0



**** #<procedure |~#-|> =

#1 0 entry-point 1 ()

; --

close -1 = (#2 +1)

+1 = -1

jump 0 +0

;

#2 0 closure-entry-point 0 ()

; +4 , +4(1) --

+1 = +4(1)

jump* 0 #3

#3 0

jump$ 0 display 1









GVM को PHP में अनुवाद करने का परिणाम:



function glo_x20hellowr () {

global $reg0, $reg1, $reg2, $reg3, $reg4, $pc, $fp, $stack, $nargs;

$ GLOBALS['glo_-'] = 'glo__';

$ stack[$fp+1] = $reg0;

$ reg1 = "!\n";

$ reg0 = 'lbl_x20hellowr_3';

$ pc = 'lbl_x20hellowr_2';

$ fp = $fp+4;

}

function lbl_x20hellowr_2 () {

global $reg0, $reg1, $reg2, $reg3, $reg4, $pc, $fp, $stack, $nargs;

$nargs = 1;

$ pc = $GLOBALS['glo_-'];

}

function lbl_x20hellowr_3 () {

global $reg0, $reg1, $reg2, $reg3, $reg4, $pc, $fp, $stack, $nargs;

$ GLOBALS['glo_-'] = $reg1;

$ reg0 = $stack[$fp-3];

$ pc = 'lbl_x20hellowr_4';

}

function lbl_x20hellowr_4 () {

global $reg0, $reg1, $reg2, $reg3, $reg4, $pc, $fp, $stack, $nargs;

$nargs = 0;

$ pc = $GLOBALS['glo_-'];

$ fp = $fp-4;

}

// procedure - =

function glo__ () {

global $reg0, $reg1, $reg2, $reg3, $reg4, $pc, $fp, $stack, $nargs;

$ stack[$fp+1] = array('lbl___2', $reg1);

$ reg1 = $stack[$fp+1];

$ pc = $reg0;

}

function lbl___2 () {

global $reg0, $reg1, $reg2, $reg3, $reg4, $pc, $fp, $stack, $nargs;

$ reg1 = $reg4[1];

$ pc = 'lbl___3';

}

function lbl___3 () {

global $reg0, $reg1, $reg2, $reg3, $reg4, $pc, $fp, $stack, $nargs;

$nargs = 1;

$ pc = $GLOBALS['glo_display'];

}

exec_scheme_code(' glo_x20hellowr ');



1) गोटो को कैसे लागू किया जाए?

प्रत्येक GVM ब्लॉक (लेबल से संक्रमण तक) एक PHP फ़ंक्शन बन जाता है जो कि गोटो को वापस जाना चाहिए। कार्यक्रम का निष्पादक "exec_scheme_code ($ pc)" कुछ इस तरह दिखता है:



$ reg0 = 'glo_exit';

जबकि (1) {

$ पीसी = $ पीसी ()

}



संकलक के बजाय, एक दुभाषिया यहां बनाया गया था। प्रदर्शन से ग्रस्त हैं।



वैकल्पिक?

2) सुपरग्लोबल्स

प्रत्येक फ़ंक्शन को समान वैश्विक चर को सूचीबद्ध करना होता है। शायद PHP को बताने का एक तरीका है कि वे डिफ़ॉल्ट रूप से वैश्विक हैं?

3) ढेर

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



कैसे करें तेज स्टैक?

4) प्रदर्शन

स्वाभाविक रूप से, ऐसे PHP कोड धीमा हो जाते हैं। उदाहरण के लिए, एकरमैन फ़ंक्शन के मैनुअल कार्यान्वयन की तुलना में, यह 30 गुना धीमा है। मुझे संदेह है कि (अंडर-गोटो और स्टैक) क्यों, लेकिन यह सुनिश्चित करना चाहते हैं।



क्या उपकरण को मापने के लिए, जो धीमा हो जाता है?