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

मैं उम्मीद कर रहा था कि कोई भी इस पर ध्यान नहीं देगा, लेकिन मुझे लगता है कि यह मेरे लिए यथार्थवादी नहीं था :)

यह उससे अधिक मजेदार है; यह वास्तव में आपको JIT को काम पर देखने देता है, क्योंकि इसे निष्पादन तक हल नहीं किया जाता है:

julia> function f2()
       a
       end

julia> function f1()
       f2()
       end

julia> function f2()
       2
       end

julia> f1()
2

हालाँकि, मुझे डर है कि इससे REPL में कुछ अप्रत्याशित परिणाम हो सकते हैं, हालाँकि मैं वास्तव में इससे निपटने का सबसे अच्छा तरीका नहीं जानता। हालाँकि मैंने नाटकीय फैशन में अंतर दिखाने के लिए एक त्रुटि का उपयोग किया, यह भी हो सकता है अगर मैं एक आंतरिक समीकरण या निरंतरता को बदलने के प्रभाव को देखने की कोशिश कर रहा था!

दो प्रकार के स्थान हैं जिन्हें किसी विधि में परिवर्तन करने पर अद्यतन करने की आवश्यकता हो सकती है:

• वे स्थान जहाँ विधि को फ़ंक्शन के रूप में स्पष्ट रूप से कहा जाता है (कॉल / रिट)
• उन स्थानों पर जहां विधि को इनलाइन किया गया है

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

वास्तव में हम सब कर सकते हैं कोड को छोड़ दें, क्योंकि भले ही कोई विधि किसी भी फ़ंक्शन को इनलाइन नहीं करती है, जो इसे कॉल करती है वह उस प्रकार के व्यवहार पर निर्भर हो सकती है जो विधि बदल सकती है। यह ज्यादातर संवादात्मक मामलों के लिए होता है इसलिए कोड को फिर से संकलित करना कोई बड़ी बात नहीं है।
अंक 47 के समान कार्य की आवश्यकता है।

ओह। खैर, चूंकि यह मुख्य रूप से उत्तर है जो प्रभावित है, धीरे-धीरे सही काम करना ठीक है। रन-टाइम में, यह लगभग कभी भी किक नहीं करना चाहिए - कोई व्यक्ति किसी चीज को परिभाषित क्यों करेगा और फिर इसे अंतःक्रियात्मक रूप से छोड़कर फिर से परिभाषित कर सकता है? यदि समाधान समाप्त हो जाता है, तो बहुत सारे उपरि को प्रेरित करना संभव है कि यह एक वैकल्पिक हो और स्वचालित रूप से उत्तर में किया जाए?

हमें यह दस्तावेज करने की आवश्यकता है कि यह वर्तमान में अपरिभाषित है।

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

एप्पल के एलएलवीएम / एलएलडीबी कर्मचारियों से ग्रेग क्लेटन दस्तावेज़ के लिए पर्याप्त थे कि एलिसिट कैसे करें (एलएलडीबी पुस्तकालयों के साथ, llvm का एक उपप्रोजेक्ट) एम्बेडेड प्रतीक जानकारी (प्रतीक आयात) से द्विआधारी की निर्भरता निर्धारित करने के लिए आवश्यक जानकारी; बाइनरी द्वारा निर्यात किए गए उन प्रतीकों के साथ-साथ (पूर्ण निर्भरता ग्राफ के निर्माण के लिए आवश्यक)।

• जेसन

31 मार्च 2012 को, 11:02 बजे, जेसन ई। एटेन ने लिखा:

प्रिय LLDB उत्साही,

अगर मैं OSX पर चलने वाले कुछ कोड को बदलने के लिए मैं lldb लाइब्रेरी / लाइब्रेरीज़ का उपयोग कर सकता हूँ तो सोच रहा हूँ कि अब प्रतीकों की दो सूचियाँ लौटें- (dyldinfo -lazy_bind -exports) के आउटपुट के समान); यानी मुझे बाइनरी शेयर्ड ऑब्जेक्ट या बंडल द्वारा आयात और निर्यात किए गए प्रतीकों को सूचीबद्ध करना होगा।

मेरी आशा थी कि एक lldb पुस्तकालय का उपयोग करके, मैं OSX पर उसी क्लाइंट कोड का उपयोग करने में सक्षम होऊंगा, जैसा कि लिनक्स पर है। (कोड का लिनक्स संस्करण वर्तमान में एक ही काम करने के लिए libbfd और libdld का उपयोग करता है, लेकिन बाद में थोड़ा प्यार / रखरखाव हो रहा है)।

मैं शामिल / lldb / के माध्यम से देख रहा हूं, क्योंकि ऐसा लगता है कि कार्य करने के लिए lldb को इसी जानकारी (आयातित प्रतीक सूची, और निर्यात की गई चिह्न सूची) की आवश्यकता होगी, लेकिन यह स्पष्ट नहीं है कि किस एपीआई का उपयोग करना है। Lldb में कोड उदाहरण के लिए सभी सुझावों / संकेत का स्वागत किया जाएगा!

धन्यवाद।
जेसन

यदि यह स्पष्ट नहीं है कि dyldinfo क्या करता है, तो यहां एक उदाहरण है: (लेकिन मुझे केवल प्रतीक नामों की आवश्यकता है, पते या खंड या अनुभाग की नहीं):

$ फ़ाइल / tmp / sample_bundle
/ tmp / sample_bundle: Mach-O 64-बिट बंडल x86_64

$ dyldinfo -lazy_bind -export / tmp / sample_bundle

आलसी बाध्यकारी जानकारी (dyld जानकारी के lazy_bind भाग से):
खंड खंड पता सूचकांक dylib प्रतीक
__DATA __la_symbol_ptr 0x00001030 0x0000 फ्लैट-नामस्थान __mm_pop_chunk
__DATA __la_symbol_ptr 0x00001038 0x0015 फ्लैट-नामस्थान _dh_define
निर्यात जानकारी (trie से):
0x000008A0 _C_ipair
0x00000920 _init_ipair
0x00000BC0 _C_iprot
0x00000C40 _C_ipi2
0x00000CC0 _C_ipi1
0x00001040 _K_ipair_R43808f40
0x00001160 _K_ipi1_R5cb4475d
0x00001260 _K_ipi2_R5cb4475d
0x00001360 _K_iprot_Rfc8fe739
0x00001460 _majver_ipair
0x00001464 _minver_ipair

सोम, 2 अप्रैल, 2012 को 3:13 बजे, ग्रेग क्लेटन [email protected] ने लिखा:

Yes you can do this with LLDB. If you load a binary and dump its symbol table, you will see the information you want. For symbols that are lazily bound, you can look for "Trampoline" symbols:

cd lldb/test/lang/objc/foundation
make
lldb a.out
(lldb) target modules dump symtab a.out
Symtab, file = .../lldb/test/lang/objc/foundation/a.out, num_symbols = 54:
              Debug symbol
              |Synthetic symbol
              ||Externally Visible
              |||
Index   UserID DSX Type         File Address/Value Load Address       Size               Flags      Name
------- ------ --- ------------ ------------------ ------------------ ------------------ ---------- ----------------------------------
[    0]      0 D   SourceFile   0x0000000000000000                    Sibling -> [   15] 0x00640000 /Volumes/work/gclayton/Documents/src/lldb/test/lang/objc/foundation/main.m
[    1]      2 D   ObjectFile   0x000000004f79f1ca                    0x0000000000000000 0x00660001 /Volumes/work/gclayton/Documents/src/lldb/test/lang/objc/foundation/main.o
[    2]      4 D   Code         0x00000001000010f0                    0x00000000000000c0 0x000e0000 -[MyString initWithNSString:]
[    3]      8 D   Code         0x00000001000011b0                    0x0000000000000090 0x000e0000 -[MyString dealloc]
[    4]     12 D   Code         0x0000000100001240                    0x00000000000000a0 0x000e0000 -[MyString description]
[    5]     16 D   Code         0x00000001000012e0                    0x0000000000000020 0x000e0000 -[MyString descriptionPauses]
[    6]     20 D   Code         0x0000000100001300                    0x0000000000000030 0x000e0000 -[MyString setDescriptionPauses:]
[    7]     24 D   Code         0x0000000100001330                    0x0000000000000030 0x000e0000 -[MyString str_property]
[    8]     28 D   Code         0x0000000100001360                    0x0000000000000050 0x000e0000 -[MyString setStr_property:]
[    9]     32 D   Code         0x00000001000013b0                    0x0000000000000040 0x000f0000 Test_Selector
[   10]     36 D   Code         0x00000001000013f0                    0x0000000000000130 0x000f0000 Test_NSString
[   11]     40 D   Code         0x0000000100001520                    0x0000000000000120 0x000f0000 Test_MyString
[   12]     44 D   Code         0x0000000100001640                    0x00000000000001b0 0x000f0000 Test_NSArray
[   13]     48 D   Code         0x00000001000017f0                    0x00000000000000e1 0x000f0000 main
[   14]     56 D X Data         0x0000000100002680                    0x0000000000000000 0x00200000 my_global_str
[   15]     58 D   SourceFile   0x0000000000000000                    Sibling -> [   19] 0x00640000 /Volumes/work/gclayton/Documents/src/lldb/test/lang/objc/foundation/my-base.m
[   16]     60 D   ObjectFile   0x000000004f79f1ca                    0x0000000000000000 0x00660001 /Volumes/work/gclayton/Documents/src/lldb/test/lang/objc/foundation/my-base.o
[   17]     62 D   Code         0x00000001000018e0                    0x0000000000000020 0x000e0000 -[MyBase propertyMovesThings]
[   18]     66 D   Code         0x0000000100001900                    0x000000000000001f 0x000e0000 -[MyBase setPropertyMovesThings:]
[   19]     82     Data         0x0000000100002000                    0x0000000000000460 0x000e0000 pvars
[   20]     83     ObjCIVar     0x0000000100002518                    0x0000000000000148 0x001e0000 MyBase.propertyMovesThings
[   21]     84   X Data         0x0000000100002660                    0x0000000000000008 0x000f0000 NXArgc
[   22]     85   X Data         0x0000000100002668                    0x0000000000000008 0x000f0000 NXArgv
[   23]     86   X ObjCClass    0x00000001000024d8                    0x0000000000000028 0x000f0000 MyBase
[   24]     87   X ObjCClass    0x0000000100002460                    0x0000000000000028 0x000f0000 MyString
[   25]     88   X ObjCIVar     0x0000000100002510                    0x0000000000000008 0x000f0000 MyString._desc_pauses
[   26]     89   X ObjCIVar     0x0000000100002508                    0x0000000000000008 0x000f0000 MyString.date
[   27]     90   X ObjCIVar     0x0000000100002500                    0x0000000000000008 0x000f0000 MyString.str
[   28]     91   X ObjCMetaClass 0x00000001000024b0                    0x0000000000000028 0x000f0000 MyBase
[   29]     92   X ObjCMetaClass 0x0000000100002488                    0x0000000000000028 0x000f0000 MyString
[   30]     97   X Data         0x0000000100002678                    0x0000000000000008 0x000f0000 __progname
[   31]     98   X Data         0x0000000100000000                    0x00000000000010b0 0x000f0010 _mh_execute_header
[   32]     99   X Data         0x0000000100002670                    0x0000000000000008 0x000f0000 environ
[   33]    101   X Data         0x0000000100002680                    0x0000000000000000 0x000f0000 my_global_str
[   34]    102   X Code         0x00000001000010b0                    0x0000000000000040 0x000f0000 start
[   35]    103     Trampoline   0x0000000100001938                    0x0000000000000006 0x00010200 NSLog
[   36]    104   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010400 OBJC_CLASS_$_NSArray
[   37]    105   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010200 OBJC_CLASS_$_NSAutoreleasePool
[   38]    106   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010400 OBJC_CLASS_$_NSDate
[   39]    107   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010400 OBJC_CLASS_$_NSObject
[   40]    108   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010200 OBJC_CLASS_$_NSString
[   41]    109   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010400 OBJC_METACLASS_$_NSObject
[   42]    110   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010400 __CFConstantStringClassReference
[   43]    111   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010100 _objc_empty_cache
[   44]    112   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010100 _objc_empty_vtable
[   45]    113     Trampoline   0x000000010000193e                    0x0000000000000006 0x00010300 exit
[   46]    114     Trampoline   0x0000000100001920                    0x0000000000000006 0x00010100 objc_getProperty
[   47]    115     Trampoline   0x0000000100001926                    0x0000000000000006 0x00010100 objc_msgSend
[   48]    116     Trampoline   0x000000010000192c                    0x0000000000000006 0x00010100 objc_msgSendSuper2
[   49]    117   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010100 objc_msgSend_fixup
[   50]    118     Trampoline   0x0000000100001932                    0x0000000000000006 0x00010100 objc_setProperty
[   51]    119     Trampoline   0x0000000100001944                    0x0000000000000006 0x00010300 printf
[   52]    120     Trampoline   0x000000010000194a                    0x0000000000000006 0x00010300 usleep
[   53]    121   X Undefined    0x0000000000000000                    0x0000000000000000 0x00010300 dyld_stub_binder
(lldb)


All lazily bound symbols will have type Trampoline:

[   45]    113     Trampoline   0x000000010000193e                    0x0000000000000006 0x00010300 exit
[   46]    114     Trampoline   0x0000000100001920                    0x0000000000000006 0x00010100 objc_getProperty
[   47]    115     Trampoline   0x0000000100001926                    0x0000000000000006 0x00010100 objc_msgSend
[   48]    116     Trampoline   0x000000010000192c                    0x0000000000000006 0x00010100 objc_msgSendSuper2
[   50]    118     Trampoline   0x0000000100001932                    0x0000000000000006 0x00010100 objc_setProperty
[   51]    119     Trampoline   0x0000000100001944                    0x0000000000000006 0x00010300 printf
[   52]    120     Trampoline   0x000000010000194a                    0x0000000000000006 0x00010300 usleep

The other symbols that are exernal are marked with an "X" (which is a boolean flag on each symbol).

The symbols can be accessed via the SBModule:

   size_t
   SBModule::GetNumSymbols ();

   lldb::SBSymbol
   SBModule::GetSymbolAtIndex (size_t idx);

And then you can get the symbol type from each SBSymbol:

   SymbolType
   SBSymbol::GetType ();


I just added the ability to see if a symbol is externally visible:
% svn commit
Sending        include/lldb/API/SBSymbol.h
Sending        scripts/Python/interface/SBSymbol.i
Sending        source/API/SBSymbol.cpp
Transmitting file data ...
Committed revision 153893.


   bool
   SBSymbol::IsExternal();


So your flow should be:

SBDebugger::Initialize();
SBDebugger debugger(SBDebugger::Create());
SBTarget target (debugger.CreateTarget (const char *filename,
                                       const char *target_triple,
                                       const char *platform_name,
                                       bool add_dependent_modules,
                                       lldb::SBError& error));

SBFileSpec exe_file_spec (filename);
SBModule exe_module (target.FindModule(exe_file_spec));
if (exe_module.IsValid()
{
   const size_t num_symbols = exe_module. GetNumSymbols();
   for (size_t i=0; i<num_symbols; ++i)
   {
       SBSymbol symbol (exe_module. GetSymbolAtIndex(i));
       if (symbol.IsExternal())
       {
       }

       if (symbol.GetType() == lldb::eSymbolTypeTrampoline)
       {
       }
   }
}




> _______________________________________________
> lldb-dev mailing list
> [email protected]
> http://lists.cs.uiuc.edu/mailman/listinfo/lldb-dev

सोम, 2 अप्रैल 2012 को शाम 4:05 बजे, ग्रेग क्लेटन [email protected] ने लिखा:

A quick clarification on the args to CreateTarget:

"filename" is just a full path to the local object file you want to observer. "target_triple" is your <arch>-<vendor>-<os>, or something like "x86_64-apple-darwin" or "i386-pc-linux" and can be NULL if the file is only a single architecture. "platform_name" can be NULL. "add_dependent_modules" should be false, since you are only interested in seeing the one object file itself, an SBError instance  should be created and passed in.

देव-सूची चर्चा यहां: https://groups.google.com/forum/?fromgroups=# -topic/julia -dev / snnGKJul4vg।

यह आश्चर्यजनक रूप से पुराने धागे को तोड़ रहा है, लेकिन मुझे एहसास हुआ कि मैं संभवतः अपने कोडेक्स बेंचमार्किंग कोड के साथ इस समस्या के किनारों के आसपास छेड़खानी कर रहा हूं। मैं बार-बार Core.include() फाइल करता हूं जिसमें दो कार्य होते हैं, listTests() और runTests() । मैं तब listTests() और runTests() कॉल करता हूं, जिससे फिर से नया स्वरूप तैयार होता है और हर बार जब मैं एक नई बेंचमार्क फ़ाइल लोड करता हूं। क्योंकि मैं 2-स्तरीय कार्यों को पुनर्परिभाषित नहीं कर रहा हूं, मुझे नहीं लगता कि मैं यहां सूचीबद्ध समस्याओं में भाग लूंगा, लेकिन एक ही "एपीआई" के साथ कई फाइलों में लोड होने के बारे में इस तरह से चीजों को फिर से परिभाषित कर रहा है?

उन्हें मॉड्यूल में बार-बार शामिल करना बेहतर हो सकता है, लेकिन मुझे एहसास है कि अनाम मॉड्यूल समस्या के खिलाफ उठता है जो कि देव सूची पर भी उठाया गया है। इस मामले में, यह ठीक हो सकता है, हालांकि, चूंकि आप एक ही मॉड्यूल को कई बार परिभाषित कर सकते हैं और चेतावनी को अनदेखा कर सकते हैं।

शायद एक पुराना धागा, लेकिन हमेशा की तरह प्रासंगिक।
शायद एक और दृष्टिकोण evalfile का उपयोग करना है और फ़ाइल को "रिटर्न" कार्यों का एक प्रकार है। अनाम मॉड्यूल समस्या क्या है?

मैं इसका उल्लेख कर रहा था: https://github.com/JuliaLang/julia/issues/3661

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

यह उतना ही उचित है जितना कि कोई प्रयास करना। यदि आप इसे करने के लिए प्रेरित महसूस कर रहे हैं, तो मैं कहूंगा कि आगे बढ़ो और चलो देखते हैं कि क्या होता है!

यदि कॉलली के पुनर्संयोजन से ट्रिगर के _execution_ क्या होता है?

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

_method_cache = Dict()
function myfunction(A::AbstractArray)
    N = ndims(A)
    if !haskey(_method_cache, N)
        func = eval(<an expression that generates the function definition for N dimensions>)
        _method_cache[N] = func
    else
        func = _method_cache[N]
    end
    return func(A)
end

तो पहली बार myfunction को 4-आयामी सरणी के लिए निष्पादित किया जाता है, यह पहली बार 4 आयामों के लिए विशिष्ट संस्करण को परिभाषित करता है, इसे _method_cache जोड़ता है, और फिर इनपुट पर नए फ़ंक्शन का मूल्यांकन करता है। 4-आयामी सरणी के साथ myfunction भविष्य के कॉल पर, यह केवल शब्दकोश से परिभाषा को पुनर्प्राप्त करता है और इसका मूल्यांकन करता है। _method_cache जूलिया की अपनी आंतरिक विधि तालिका के समानांतर एक प्रकार की "छाया विधि तालिका" है, एक जो इस विशेष फ़ंक्शन के लिए उपयोग की जाती है। (इसे निजी रखने के लिए, इसे आमतौर पर let द्वारा समझाया जाता है।)

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

ऐसा करने का एक बेहतर तरीका निम्नलिखित हो सकता है:

function myfunction(A::AbstractArray)
    bodyexpr = <an expression for the body of the function specific for N dimensions>
    f = <strong i="17">@eval</strong> begin
        function myfunction(A::$(typeof(A)))
            $bodyexpr
        end
    end
    return f(A)
end

यहाँ, myfunction का निष्पादन इन विशेष इनपुट प्रकारों के लिए myfunction _more विशिष्ट_ संस्करण उत्पन्न करता है। इस नई परिभाषा के उपलब्ध होने के बाद संकलित किया गया कोड लागू होने पर इस नए संस्करण का उपयोग करेगा; ऊपर दिया गया संस्करण उन मामलों के लिए सामान्य "फ़ॉलबैक" बन जाता है, जहाँ आपने पहले से कुछ अधिक विशिष्ट परिभाषित नहीं किया है। नतीजतन, यह मंचन कार्यों को बनाने का एक तरीका होगा जो जूलिया के अपने आंतरिक विधि-तालिका तंत्रों का शोषण करता है, और इसलिए एक कुशल कोड उत्पन्न करने की अनुमति देगा।

वर्तमान में, यह एक महत्वपूर्ण कारण के लिए काम नहीं करता है: जो कुछ भी myfunction पहले ही संकलित किया गया है, इसलिए यह नई परिभाषा के बारे में नहीं जानता है। नतीजतन, यह विशेष कॉलर हमेशा myfunction eval myfunction का उपयोग करके एक नया नया संस्करण उत्पन्न करेगा, जो कि देव-भयानक धीमी गति से होगा।

तो कॉल करने वाले को फिर से जोड़ने के लिए चाल होगी, लेकिन ध्यान दें कि यह होने की जरूरत है _ इसके बजाय यह निष्पादन के बीच में है। क्या होने जा रहा है?

# 5395 भी देखें।

अमूर्त प्रकारों के साथ एक संबंधित समस्या है जो वास्तव में विधि पुनर्वितरण में शामिल नहीं है लेकिन इसी तरह के उपचार की आवश्यकता है। विचार करें:

abstract A
immutable B <: A; end
immutable C <: A; end

g(x::Vector{A}) = f(x[1])

f(::B) = 1
g(A[B()])

f(::C) = 0.5
g(A[C()])

अंतिम पंक्ति 4602678819172646912 । हमें g के लिए कोड बाहर फेंकने की आवश्यकता है क्योंकि f(::A) लिए प्रकार की पुष्टि अब मान्य नहीं है।

हां, यह काफी स्पष्ट है। हम जानते हैं कि प्रतिस्थापन के तरीके केवल एक विशेष मामला है। लेकिन इसमें हमेशा नई पद्धति की परिभाषाएं शामिल होती हैं।

ऐसा लगता है कि वर्तमान स्थिति किसी तरह से अस्पष्ट हो सकती है

f() = x()
x() = 1
println(f())
x() = 2
println(f())

देता है

1
1

जबकि

g() = y()
precompile(g, ())
y() = 1
println(g())
y() = 2
println(g())

देता है

1
2

ऐसा लगता है कि बाद में मामला संभव हो सकता है कॉलर पुनर्मिलन अनुकरण करने के लिए एक समाधान के रूप में इस्तेमाल किया जा सकता है (मुझे पता है कि यह वास्तव में पुनर्संयोजन नहीं है)।

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

@ omer4d उस विचार के साथ एक समस्या यह है कि जूलिया बहुत सारे छोटे कार्य करता है, इसलिए हमें अभी भी एक निश्चित फ़ंक्शन पर सभी "आश्रितों" को देखने का एक तरीका चाहिए।

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

मेरा मानना ​​है कि कई कारण हैं कि दृष्टिकोण व्यवहार्य नहीं है। प्रथम,
एनोटेशन वास्तव में एक उपद्रव है, खासकर जब उन्हें हैक करने की आवश्यकता होती है
इस तरह के कार्यान्वयन के विवरण के आसपास। यदि एनोटेशन का उपयोग 2 को हल करने के लिए किया जाता है
या 3 समस्याओं, वे काफी ढेर करने के लिए शुरू करते हैं। दूसरा, कोई नहीं है
एक समारोह के लिए सही एनोटेशन लेने का अच्छा तरीका है। कोई नहीं है
इस बात के बीच कि क्या आप कुछ चाहते हैं, और क्या आप चाहते हैं
इसे अंतःक्रियात्मक रूप से विकसित करना। तीसरा, अन्य कार्यों में कटौती टाइप करें
बदलने की आवश्यकता हो सकती है, इसलिए यह सिर्फ कॉल साइट्स नहीं है। वास्तव में हम वर्तमान में हैं
कम से कम प्रकार की जानकारी प्राप्त करने से हम संभावित रूप से चीजें बना सकते हैं
इस मुद्दे के सामने सुरक्षित है।

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

@JeffBezanson मैं शायद सबसे आसान मामले में कम से कम पहली बार में दिलचस्पी लेना चाहूंगा। मुझे परवाह नहीं है कि बहुत अधिक चलने वाला कोड अपडेट हो जाता है, क्योंकि eval (जैसे REPL प्रॉम्प्ट पर दर्ज) के माध्यम से एक्सेस की गई चीज़ों के विपरीत। आखिरकार, यह भी महत्वपूर्ण होगा जैसे कि पुनर्निर्धारित होने पर display का सही संस्करण प्राप्त करना। लेकिन मेरा मानना ​​है कि वृद्धिशील संकलन करने के लिए हमें तेजी से करीब आना चाहिए।

मैं इस समस्या को जानने के लिए थोड़ा सर्प्राइज़्ड था, इसलिए नहीं कि मुझे लगता है कि इसे संभालना आसान है, बल्कि इसलिए कि निम्नलिखित उम्मीद के मुताबिक काम करता है।

julia> f(a, b) = a + b
f (generic function with 1 method)

julia> g(args...) = f(args...)
g (generic function with 1 method)

julia> g(1, 2)
3

julia> f(a::Int, b::Int) = a - b
f (generic function with 2 methods)

julia> g(1, 2)
-1

संपादित करें: वास्तव में यह वररग इनपुट के लिए एक विशेष मामले की तरह दिखता है ..... क्या इसका मतलब यह है कि एक वार्ग फ़ंक्शन को हर बार फिर से कहा जाता है? या क्या यह स्मार्ट है जब आवश्यक हो केवल recompile करने के लिए? और क्या यह उसी तरह से अन्य कार्यों का इलाज करना संभव है?

julia> f(a, b) = a + b
f (generic function with 1 method)

julia> g(a, b) = f(a, b)
g (generic function with 1 method)

julia> g(1, 2)
3

julia> f(a::Int, b::Int) = a - b
f (generic function with 2 methods)

julia> g(1, 2)
3

दरअसल, फ़ंक्शन सही परिणाम देता है लेकिन @code_typed गलत परिणाम देता है .....

julia> f(a, b) = a + b
f (generic function with 1 method)

julia> g(args...) = f(args...)
g (generic function with 1 method)

julia> g(1, 2)
3

julia> <strong i="7">@code_typed</strong> g(1, 2)
1-element Array{Any,1}:
 :($(Expr(:lambda, Any[:(args::(top(apply_type))(Vararg,Any)::Any::Any)], Any[Any[],Any[Any[:args,(Int64,Int64),0]],Any[]], :(begin  # none, line 1:
        return (top(box))(Int64,(top(add_int))((top(tupleref))(args::(Int64,Int64),1)::Int64,(top(tupleref))(args::(Int64,Int64),2)::Int64))
    end::Int64))))

julia> f(a::Int, b::Int) = a - b
f (generic function with 2 methods)

julia> g(1, 2)
-1

julia> <strong i="8">@code_typed</strong> g(1, 2)
1-element Array{Any,1}:
 :($(Expr(:lambda, Any[:(args::(top(apply_type))(Vararg,Any)::Any::Any)], Any[Any[],Any[Any[:args,(Int64,Int64),0]],Any[]], :(begin  # none, line 1:
        return (top(box))(Int64,(top(add_int))((top(tupleref))(args::(Int64,Int64),1)::Int64,(top(tupleref))(args::(Int64,Int64),2)::Int64))
    end::Int64))))

तथा

julia> f(a, b) = a + b
f (generic function with 1 method)

julia> g(args...) = f(args...)
g (generic function with 1 method)

julia> g(1, 2)
3

julia> f(a::Int, b::Int) = a - b
f (generic function with 2 methods)

julia> g(1, 2)
-1

julia> <strong i="12">@code_typed</strong> g(1, 2)
1-element Array{Any,1}:
 :($(Expr(:lambda, Any[:(args::(top(apply_type))(Vararg,Any)::Any::Any)], Any[Any[],Any[Any[:args,(Int64,Int64),0]],Any[]], :(begin  # none, line 1:
        return (top(box))(Int64,(top(sub_int))((top(tupleref))(args::(Int64,Int64),1)::Int64,(top(tupleref))(args::(Int64,Int64),2)::Int64))
    end::Int64))))

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

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

मुझे नहीं पता कि इस मसले का हल आसानी से मैक्रोज़ के लिए सामान्य हो जाएगा, लेकिन अगर ऐसा होता तो अच्छा होता।

इसलिए एक को दूसरे तरीके से जाना चाहिए और सभी तरीकों को स्टोर करना चाहिए जो फ़ंक्शन को इनलाइन करते हैं और परिवर्तन पर उन्हें फिर से जोड़ते हैं। (वर्तमान निष्पादन आदि के लिए निश्चित रूप से जाँच)

यहाँ मुश्किल समस्याएं हैं:

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

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

उत्तर में इसे हिट करना अब और भी आसान है और इस व्यवहार को शायद मानचित्र के लिए प्रलेखित किया जाना चाहिए?

julia> function f(x)
         1
       end 
f (generic function with 1 method)

julia> map(f, 1:10)
10-element Array{Int64,1}:
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1

julia> function f(x)
         2
       end
WARNING: Method definition f(Any) in module Main at REPL[9]:2 overwritten at REPL[11]:2.
f (generic function with 1 method)

julia> map(f, 1:10)
10-element Array{Int64,1}:
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1

वह अभी भी सिर्फ # 265 वेनिला है। मुझे लगता है कि आप सराहना करेंगे कि यह जल्द ही v0.6-dev में तय हो जाएगा :)

@vtjnash कोई रनटाइम प्रदर्शन या मेमोरी ट्रेडऑफ़ है?

इसके लिए थोड़ी मेमोरी (140 एमबी -> 170 एमबी) की आवश्यकता होती है, लेकिन प्रदर्शन (संकलन या रनटाइम) पर अधिक प्रभाव नहीं होना चाहिए। और मैंने वास्तव में अभी तक बहुत अनुकूलन का प्रयास नहीं किया है।

अब तक के डेमो मजेदार हैं:

julia> f() = 1
f (generic function with 1 method)

julia> function g(x)
    <strong i="7">@eval</strong> f() = $x # this is the correct way to write `global f() = x` (which should be a syntax error, but isn't currently)
    return @eval(f)() # use `eval` to hide the value from optimization / inlining, but the call is not inside eval
end
g (generic function with 1 method)

julia> g(2)
WARNING: Method definition f() in module Main at REPL[1]:1 overwritten at REPL[2]:2.
1

julia> g(3)
WARNING: Method definition f() in module Main at REPL[2]:2 overwritten at REPL[2]:2.
2

julia> g(4)
WARNING: Method definition f() in module Main at REPL[2]:2 overwritten at REPL[2]:2.
3

कारण यह है कि वापस नहीं करता है 2, 3, आदेश के कारण 4, जिसमें का संकलन है g बनाम निष्पादन कि Redefines f होता है?

यह लगभग सही है। ध्यान दें कि भाषा शब्दार्थ संकलन को परिभाषित नहीं करता है, इसलिए यह कहना अधिक सही है कि जिस क्रम में g की व्याख्या की जाती है, उस समय f का पुनर्निरीक्षण दुभाषिया को दिखाई देता है

ठीक है, यहाँ + आदिम को फिर से परिभाषित करने के लिए एक और मज़ेदार थोड़ा डेमो है जो इस बात का ध्यान रखता है:

julia> add_ctr = UInt(0)
0x0000000000000000

julia> Base.:+(a::Int, b::Int) = (global add_ctr += 1; Core.Intrinsics.add_int(a, b))

julia> add_ctr
0x0000000000000016

julia> last = 0;

julia> println(Int(add_ctr - last)); last = add_ctr;
287

julia> println(Int(add_ctr - last)); last = add_ctr;
17

यह एक धोखा है: मुझे नहीं लगता कि + उपयोग बेस द्वारा किया जाता है, इसलिए इसमें कुछ भी नहीं था। svd तरह एक वास्तविक फ़ंक्शन को फिर से परिभाषित करें, जिसे आप जानते हैं कि REPL को दिखाने से पहले कम से कम 100 बार कॉल करना होगा। तब हम प्रभावित होंगे।

प्रोफाइलिंग / ट्रेसिंग के लिए कोड के लाइव री-इंस्ट्रूमेंटेशन के अवसर मुझे उड़ा रहे हैं।

वास्तव में। और यहाँ मैं एक नया कीबोर्ड खरीदने वाला था, क्योंकि अनुक्रम Ctrl-D; julia<Enter> केवल पहना जाने वाला था। लगता है मुझे नहीं हो सकता है।

यह जारी किए गए नोटों में डालने के लिए थोड़ा सा रहस्यमय हो सकता है, लेकिन कहीं न कहीं यह ध्यान दिया जाना चाहिए कि समझ अब collect Generator लिए वाक्यविन्यास के रूप में है (पार्स स्तर पर शायद किसी चीज़ के विपरीत) 0.4 में? - @which वहाँ काम नहीं करता है)? यह उदाहरण, vchuravy के उपरोक्त के समान है, यह मानते हुए भी एक गोत्र का एक सा है कि प्रत्येक फ़ंक्शन अब 0.5 में एक प्रकार है:

               _
   _       _ _(_)_     |  A fresh approach to technical computing
  (_)     | (_) (_)    |  Documentation: http://docs.julialang.org
   _ _   _| |_  __ _   |  Type "?help" for help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 0.5.0-rc3+0 (2016-08-22 23:43 UTC)
 _/ |\__'_|_|_|\__'_|  |
|__/                   |  x86_64-linux-gnu

julia> f(x) = 1
f (generic function with 1 method)

julia> [f(x) for x in 1:5]
5-element Array{Int64,1}:
 1
 1
 1
 1
 1

julia> f(x) = 2
WARNING: Method definition f(Any) in module Main at REPL[1]:1 overwritten at REPL[3]:1.
f (generic function with 1 method)

julia> [f(x) for x in 1:5]
5-element Array{Int64,1}:
 1
 1
 1
 1
 1

julia> <strong i="9">@which</strong> [f(x) for x in 1:5]
collect(itr::Base.Generator) at array.jl:295

बिलकुल ठीक नहीं?

फिक्स # 265 के लिए उपयोगी है

क्या यह वास्तव में तय है 😲

क्या इस समाधान को अभी भी 0.5.x पर वापस लाने की योजना है?

नहीं।

@ rapus95 , यह एक बहुत ही आक्रामक परिवर्तन है, और इसे गलत होने से बहुत सारे उपयोगकर्ताओं के लिए जूलिया को अस्थिर किया जा सकता है। चूँकि संपूर्ण विमोचन गुरु की तुलना में अधिक स्थिरता प्रदान करना है, इसलिए इसे 0.6 में रखना कहीं अधिक बेहतर है। (आप हमेशा मास्टर का पालन कर सकते हैं यदि आप इसे 0.6 की रिहाई से पहले चाहते हैं।)

मैं इस मुद्दे पर प्रगति देखकर बहुत खुश हूँ! यह आश्चर्यजनक होगा यदि यह कंपाइलर को https://groups.google.com/forum/#/topic/julia -users / OBs0fmNmjCU में वर्णित मामले को अनुकूलित करने की अनुमति देता है।

वाह। क्या शानदार पल है!

हाय दोस्तों!

क्या इस फिक्स को 0.5 सेरी तक वापस करने की कोई संभावना है? या यह केवल 0.6 में क्या काम करेगा?

यह एक ब्रेकिंग परिवर्तन है और केवल 0.6 में उपलब्ध होगा

यह तय करना मुश्किल है कि यह कितना बढ़िया है। पुरानी आदतें मुश्किल से मरती हैं इसलिए मैं कभी-कभी जूलिया को अनावश्यक रूप से पुनः आरंभ और / या फिर से बनाता हूं, लेकिन जब मुझे याद आता है कि यह समस्याओं को ठीक करने के लिए एक पूर्ण गेम-चेंजर है।