एक साधारण llvm / libjit परीक्षण भाग II, वही + ग्नू लाइटनिंग

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



यह लेख ठीक उसी समस्या को हल करता है - एक और जेआईटी लाइब्रेरी - जीएनयू लाइटनिंग का उपयोग करके एराटोस्थनीज की छलनी।



गन्न बिजली के बारे में कुछ शब्द - वास्तव में, यह एक पुस्तकालय नहीं है, बल्कि मैक्रोज़ का एक सेट है जो एक निष्पादन योग्य बफर बनाता है।



तो उसी के साथ समाधान

जीएनयू लाइटनिंग

001 : #include <stdio.h>

002: #include <lightning.h>

003: #include <math.h>

004: #include <string.h>

005:

006: static jit_insn codeErato[ 1024 ];

007: static jit_insn codemain[ 1024 ];

008:

009: typedef int ( * pifi)( int ); /* Pointer to Int Function of Int */

010: typedef void ( * pvfv)( void ); /* Pointer to void Function of void */

011: char a[ 100000 ];

012:

013: int main ()

014: {

015: pifi erato = (pifi) (jit_set_ip(codeErato).iptr);

016: pvfv func_main;

017: int n, ii;

018: jit_insn * for_cond, * for_end, * end_if, * while_cond, * while_end,

019: * main_for_beg, * main_for_end;

020:

021: jit_prolog( 1 );

022: n = jit_arg_i(); /* n = arg_i */

023:

024: jit_getarg_ui(JIT_V0, n); /* V0 = n */

025: jit_extr_i_f(JIT_FPR0, JIT_V0);

026: jit_prepare( 1 );

027: jit_pusharg_f( JIT_FPR0);

028: jit_finish( sqrtf);

029: jit_retval(JIT_FPR0);

030: jit_roundr_f_i(JIT_V1, JIT_FPR0); /* V1 = q */

031:

032: jit_movi_p(JIT_V2, a); /* V2 = a*/

033: jit_movi_i(JIT_R0, 1 );

034: jit_prepare( 3 );

035: jit_pusharg_i(JIT_V0); /* size_t n */

036: jit_pusharg_i(JIT_R0); /* int c - fillcahr */

037: jit_pusharg_p(JIT_V2); /* array to fill */

038: jit_finish(memset);

039:

040: jit_movi_ui(JIT_R0, 2 ); /* i = 1 (R0)*/

041: for_cond = jit_get_label();

042: for_end = jit_bgtr_ui(jit_forward(), JIT_R0, JIT_V1);

043: jit_ldxr_c(JIT_R2, JIT_V2, JIT_R0);

044: end_if = jit_beqi_ui(jit_forward(), JIT_R2, 0 );

045: jit_mulr_ui(JIT_R1, JIT_R0, JIT_R0); /* j = R1 */

046: while_cond = jit_get_label();

047: while_end = jit_bgtr_ui(jit_forward(), JIT_R1, JIT_V0);

048: jit_stxr_c(JIT_V2, JIT_R1, 0 );

049: jit_addr_ui(JIT_R1, JIT_R1, JIT_R0);

050: jit_jmpi(while_cond);

051: jit_patch(while_end);

052: jit_patch(end_if);

053: jit_addi_ui(JIT_R0, JIT_R0, 1 );

054: jit_jmpi(for_cond);

055: jit_patch(for_end);

056:

057: jit_movr_ui(JIT_RET, JIT_R1);

058: jit_ret();

059: jit_flush_code(codeErato, jit_get_ip().ptr);

060:

061: func_main = (pvfv) (jit_set_ip(codemain).iptr);

062: jit_prolog( 0 );

063: jit_movi_ui(JIT_V0, 1 );

064: main_for_beg = jit_get_label();

065: main_for_end = jit_bgti_ui(jit_forward(), JIT_V0, 100000 );

066: jit_movi_ui(JIT_R0, 50000 );

067: jit_prepare( 1 );

068: jit_pusharg_ui( JIT_R0);

069: jit_finish(erato);

070: jit_addi_ui(JIT_V0,JIT_V0, 1 );

071: jit_jmpi(main_for_beg);

072: jit_patch(main_for_end);

073: jit_ret();

074: jit_flush_code(codemain, jit_get_ip().ptr);

075:

076: puts( "Go" );

077: func_main();

078: return 0 ;

079: }

080:

संकलित करें और चलाएं:

$ gcc lightest.c -lm -o lightest

$ for i in `seq 1 10`; do /usr/bin/time -f '%U' ./lightest ; done

32.80

32.59

32.57

32.55

32.53

32.59

32.53

32.69

32.54

32.53









कुल औसत लीड टाइम 32.59



पिछले लेख में प्राप्त किए गए परिणामों के साथ संयोजन:

जित पुस्तकालय	सेकंड में निष्पादन का समय, (कम = बेहतर)
LLVM	13.77
LIBJIT	14.17
GNU लाइटिंग	32.59
और सिर्फ जानकारी के लिए:
gcc -O0	50.09
gcc -O1	13.79

यही है, आग की दर में गुन बिजली के परिणाम लगभग "बिना" और "के साथ" अनुकूलन सी कार्यक्रम के साथ संकलित हैं।

मुझे कहना होगा कि gnu lighning llvm और libjit की तुलना में बहुत निचले स्तर का इंटरफ़ेस प्रस्तुत करता है। प्रोग्रामर के विवेक पर कई चीजें बनी हुई हैं। उदाहरण के लिए, रजिस्टरों का आवंटन (बिजली ऐसा नहीं करता है, इंट के लिए सिर्फ 6 रजिस्टर हैं और फ्लोट / डबल के लिए 6 हैं, और जैसा आप चाहते हैं स्पिन)। उदाहरण के लिए, अनुकूलन।



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



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

नैतिकता।

मैं GNU लाइटनिंग का उपयोग केवल तभी करूंगा जब परिणामी प्रोग्राम मेमोरी और डिस्क स्थान के संदर्भ में बहुत गंभीर परिस्थितियों में काम करे। अन्य सभी मामलों में - libjit या llvm उद्देश्यपूर्ण रूप से बेहतर और सुरक्षित है।