함수가 정의 될 때 d2() 대한 코드가 생성되어 d() 메서드가 이때 해결되기 때문이라고 생각합니다. 앞서 언급했듯이 d2() 는 원래 예상대로 작동하도록 정의 된대로 재정의 할 수 있습니다. 이상적으로는 d() 에 의존하는 모든 항목이 이와 같이 변경 될 때 자동으로 다시 정의하지만이를 허용하는 메타 데이터가 없습니다. 이 동작에 대한 경고를 매뉴얼에 넣을 수 있다고 생각합니다. 여전히 그것을 고치는 것이 더 좋지만, 조금 까다로운 일이라고 생각합니다 :-/

아무도 이것을 눈치 채지 못하기를 바랐지만 그것은 현실적이지 않은 것 같습니다 :)

그것보다 더 재미 있습니다. 실행될 때까지 해결되지 않기 때문에 실제로 작업중인 JIT를 볼 수 있습니다.

julia> function f2()
       a
       end

julia> function f1()
       f2()
       end

julia> function f2()
       2
       end

julia> f1()
2

그러나 나는 이것이 REPL에서 예상치 못한 결과를 초래할 수 있다는 것을 두려워합니다. 비록 내가 그것을 처리하는 가장 좋은 방법을 실제로는 모르지만. 극적인 방식의 차이를 보여주기 위해 오류를 사용했지만 내부 방정식이나 상수를 변경하는 효과를 보려고 할 때도 발생할 수 있습니다!

메소드가 변경 될 때 업데이트해야 할 수있는 두 가지 유형의 위치가 있습니다.

• 메서드가 함수로 명시 적으로 호출되는 위치 (call / ret)
• 메서드가 인라인 된 장소

전자는 함수 본문을 변경하여 업데이트 할 수 있습니다. 제자리에서 변경하거나 호출 사이트를 적극적으로 업데이트하여 새 위치를 호출하거나 이전 함수 본문을 새 버전으로 점프하는 스텁으로 대체 할 수 있습니다. , 선택적으로 호출 사이트를 패치합니다. 인라인의 경우 함수를 인라인 한 호출자를 추적하고 다시 JIT해야합니다.

실제로 우리가 할 수있는 일은 코드를 버리는 것입니다. 왜냐하면 메서드가 호출하는 함수가 인라인되지 않았더라도 메서드가 변경되면 변경 될 수있는 유형 동작에 따라 달라질 수 있기 때문입니다. 이것은 대부분 대화 형 케이스를위한 것이므로 코드를 다시 컴파일하는 것은 큰 문제가 아닙니다.
47 번 문제와 동일한 작업이 필요합니다.

Bummer. 음, 영향을받는 것은 주로 repl이기 때문에 옳은 일을 천천히하는 것이 좋습니다. 런타임에 이것은 거의 시작되지 않아야합니다. 왜 누군가가 무언가를 정의한 다음 대화식을 제외하고 다시 정의할까요? 솔루션이 결국 많은 오버 헤드를 유발하는 경우 선택 사항이며 자동으로 repl에서 수행되어야합니까?

이것이 현재 정의되어 있지 않다는 것을 문서화해야합니다.

기술적으로 이것은 버그가 아니라 정의되지 않은 동작입니다. 메서드를 재정의하면 결과 동작이 정의되지 않습니다. 따라서 Julia는 현재하는 일을 포함하여 원하는대로 할 수 있습니다. 메서드 재정의시 잘 정의 된 동작을 제공하는 것은 버그 수정이 아니라 기능입니다. 또한 정의되지 않은 동작에서 잘 정의 된 동작을 제공하는 것이 주요 변경 사항이 아니기 때문에 이것이 v1.0 문제라고 확신하지 않습니다. 이것은 유효한 v1.0 코드를 손상시키지 않고 v1.1에서 구현 될 수 있습니다.

Apple의 LLVM / LLDB 직원의 Greg Clayton은 포함 된 기호 정보 (기호 가져 오기)에서 바이너리의 종속성을 결정하는 데 필요한 정보를 도출하는 방법 (lldb 라이브러리, llvm의 하위 프로젝트 사용)을 문서화하기에 충분히 친절했습니다. 바이너리로 내 보낸 심볼 (전체 종속성 그래프를 구성하는 데 필요함)도 마찬가지입니다.

• 제이슨

2012 년 3 월 31 일 오후 11:02에 Jason E. Aten은 다음과 같이 썼습니다.

LLDB 애호가 여러분,

lldb 라이브러리 / 라이브러리를 사용하여 이제 두 개의 기호 목록을 반환하는 OSX에서 실행중인 특정 코드를 대체 할 수 있는지 궁금합니다. (dyldinfo -lazy_bind -exports); 즉, 바이너리 공유 객체 또는 번들에서 가져오고 내 보낸 심볼을 나열해야합니다.

내 희망은 lldb 라이브러리를 사용하여 OSX에서 Linux와 동일한 클라이언트 코드를 사용할 수 있다는 것이 었습니다. (리눅스 버전의 코드는 현재 libbfd와 libdld를 사용하여 동일한 작업을 수행하지만 나중에는 거의 사랑 / 유지 관리가 이루어지지 않습니다.)

lldb가 작동하려면 동일한 정보 (가져온 심볼 목록 및 Mach-O 파일에 대한 내 보낸 심볼 목록)가 필요한 것처럼 보이므로 include / lldb /를 살펴보고 있지만 어떤 API를 사용할지 명확하지 않습니다. 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

2012 년 4 월 2 일 월요일 오후 3:13에 Greg Clayton [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

2012 년 4 월 2 일 월요일 오후 4:05에 Greg Clayton [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.

이것은 놀랍도록 오래된 스레드를 준비하고 있지만 코드 속도 벤치마킹 코드 로이 문제의 가장자리를 유혹하고 있음을 깨달았습니다. listTests() 및 runTests() 두 개의 함수가 포함 된 Core.include() 파일을 반복해서 사용했습니다. 그런 다음 listTests() 및 runTests() 를 호출하여 새 벤치 마크 파일을로드 할 때마다 재정의 한 다음 호출합니다. 2 단계 함수를 재정의하지 않기 때문에 여기에 나열된 문제가 발생하지 않을 것이라고 생각하지만 이와 같은 것을 재정의하는 것은 동일한 "API"를 사용하여 여러 파일을로드하는 데 나쁜 방법입니까?

모듈에 반복적으로 포함하는 것이 더 나을 수도 있지만 개발자 목록에서도 제기 된 익명 모듈 문제와 충돌한다는 것을 알고 있습니다. 이 경우에는 괜찮을 수 있지만 동일한 모듈을 여러 번 정의하고 발생하는 경고를 무시할 수 있기 때문입니다.

아마도 오래된 스레드이지만 그 어느 때보 다 관련이 있습니다.
또 다른 접근 방식은 evalfile 를 사용하고 파일에 함수 튜플을 "반환"하는 것입니다. 익명 모듈 문제는 무엇입니까?

나는 이것을 언급하고 있었다 : https://github.com/JuliaLang/julia/issues/3661.

누구든지 구현 전략에 대한 추가 생각이 있습니까? 나는 (최적화되지 않은 AST를 기반으로) 새로운 메서드가 생성 될 때마다 업데이트되는 반전 된 호출 그래프를 유지하는 간단한 체계를 코딩하려고 생각하고있었습니다. 그런 다음 메서드가 재정의 될 때 해당 그래프를 살펴보고 재정의 된 각 함수의 하위 항목의 컴파일 된 버전을 제거합니다.

그것은 시도할만한 합리적인 접근 방식입니다. 그렇게 할 의욕이 있다면, 계속해서 무슨 일이 일어나는지 봅시다!

수신자의 _execution_이 호출자의 재 컴파일을 트리거하면 어떻게됩니까?

나는이 문제를 해결하는 것이 REPL의 사용자 경험을 넘어서는 흥미로운 결과를 가져올 수 있다는 것을 뒤늦게 깨달았 기 때문에 묻습니다. 메타 프로그래밍 문제에 대한 궁극적 인 대답, 즉 효율적인 "단계적"기능을 생성 할 수있게 해줄 수 있습니다. 모르는 사람들을위한 배경 : 일부 기능은 현재 메타 프로그래밍에 의해 구현되며, 특히 알고리즘의 일부 측면이 사소하지 않은 방식으로 입력 유형에 의존하는 기능 ---- 표준 예는 숫자가 함수 본문의 루프 수는 배열의 차원과 같습니다. 일반적으로이를 처리하는 방법은 예를 들어 차원 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 는 Julia 자신의 내부 메서드 테이블과 병행하여이 특정 함수에만 사용되는 일종의 "그림자 메서드 테이블"입니다. (비공개로 유지하기 위해 일반적으로 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 를 실행하면 이러한 특정 입력 유형에 대해

현재 이것은 한 가지 중요한 이유 때문에 작동하지 않습니다. 방금 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 입니다. f(::A) 대한 유형 추론이 더 이상 유효하지 않기 때문에 g 대한 코드를 버려야합니다.

네, 아주 분명합니다. 교체 방법은 특별한 경우 일뿐입니다. 그러나 항상 새로운 메서드 정의가 포함됩니다.

현재 상황은 왠지 모호 할 수 있습니다.

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

준다

1

동안

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

준다

2

나중의 경우는 호출자 재 컴파일을 에뮬레이트하기위한 해결 방법으로 사용할 수있는 것 같습니다 (실제로 재 컴파일이 아님을 알고 있습니다).

어리석은 말을 할 것 같은 느낌이 들지만,이 문제는 한 단계의 간접적 인 방법으로 해결할 수 없을까요? 함수 주소를 하드 코딩하는 대신 고정 된 위치에서 찾아서 호출하십시오. 이것은 C ++ 또는 Java 가상 기능과 유사한 성능을 갖지 않습니까? 그런 다음 정적 또는 동적 주소를 갖도록 함수에 주석을 달 수 있으며 정적 주소로 함수를 재정의하려고하면 경고 / 오류가 발생합니다. 기본 기능 동작을 설정하는 스위치가있을 수도 있습니다. 나는 언어에 익숙하지 않고 코드베이스에 완전히 익숙하지 않지만 이것이 가능하게 들리면 잽을 줄 수 있다고 생각합니다.

@ omer4d 그 아이디어의 한 가지 문제는 Julia가 많은 작은 함수를 인라인하기 때문에 특정 함수에 대한 모든 "종속 항목"을 찾는 방법이 필요하다는 것입니다.

C ++처럼 정적 주소로만 인라인 할 수 있습니다. 이것은 불편을 야기해서는 안됩니다.
기본 동작은 모든 기능에 정적 주소를 사용하는 것이기 때문에 대화 형 개발에 관심이없는 사람들은 전혀 영향을받지 않습니다.
성능에 관심이 없지만 대화 형 개발을 원하는 사람들은 스위치를 사용하여 기본적으로 기능 주소를 동적으로 만들 수 있습니다.
상호 작용과 성능을 모두 원하는 사람들은 관련 함수에 주석을 달 수 있는데, 이는 많은 작업이 아니어야합니다. 인라인은 많이 호출되는 짧은 저수준 함수에만 관련이 있기 때문입니다.
아마도 기본 동작은 모듈별로 설정할 수도 있습니다.

접근이 불가능한 데에는 몇 가지 이유가 있다고 생각합니다. 먼저,
주석은 정말 귀찮은 일입니다. 특히 해킹이 필요할 때
이와 같은 구현 세부 사항에 대해. 주석을 사용하여 2를 해결하는 경우
또는 3 가지 문제가 발생하면 크게 쌓이기 시작합니다. 둘째,
함수에 적합한 주석을 선택하는 좋은 방법입니다. 없다
인라인을 원하는지 여부와
대화식으로 개발합니다. 셋째, 다른 기능의 유형 공제
변경해야 할 수도 있으므로 단지 호출 사이트가 아닙니다. 사실 우리는 현재
우리가 만들 수있는 것보다 더 적은 유형 정보를 가져옵니다.
이 문제에 직면하여 안전합니다.

글쎄요, 수십 개의 한정어 키워드와 반복적 인 수동 재 컴파일을 사용하여 대부분의 작업을 언어로 수행하는 사람으로서, 때때로 함수를 한두 개 한정하고 몇주기의 대화 형 개발 후에 재 컴파일해야하는 것은 그렇게 나쁘게 들리지는 않습니다. . 그래도 세 번째 요점을 다룰 수는 없으니 물러나겠습니다. 재 컴파일은 수정 된 함수의 호출 트리의 루트에 게임이나 애니메이션 루프가 포함되어 있으면 종료하고 다시 시작해야한다는 것을 의미하기 때문에 그러한 솔루션이 실행 가능하지 않다는 것은 불행한 일이라고 생각합니다. = (

@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

편집 : 실제로 이것은 Vararg 입력에 대한 특별한 경우처럼 보입니다 ..... 이것은 vararg 함수가 호출 될 때마다 재 컴파일된다는 것을 의미합니까? 아니면 필요할 때만 재 컴파일 할만큼 똑똑합니까? 그리고 다른 기능을 같은 방식으로 처리 할 수 ​​있습니까?

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))))

어떤 것이 할당 될 때마다 변경되는 숫자로 함수의 메소드 (또는 함수 유형 / 객체 자체 만)를 색인화하여 컴파일 된 (호출자) 함수로 저장된 숫자 (즉, 새로운 구조 사용) 여부를 확인할 수있게됩니다. 함수,이 숫자를 필드로 저장하는 등) 여전히 인라인 된 (호출 된) 함수에서 "현재"인 것과 일치합니까?
(물론 큰 성능 저하없이)
그리고 변경된 경우 새 버전을 컴파일하거나 명시 적 호출로 완료하는 것을 고려하십시오.

이는 성능에 미치는 영향을 런타임으로 이동시킬 수 있으며 (모든 곳에서) 바람직하지 않습니다. 필요한 것은 종속성의 웹을 추적하고 메서드가 부분적으로 재정의 될 때 영향을받을 수있는 모든 것을 다시 컴파일하는 것입니다. 그것은 아마도 가능할 것입니다. 그것은 단지 _ 거대한 _ 고통 일뿐입니다.

이 문제에 대한 해결책이 매크로로 쉽게 일반화되는지는 모르겠지만, 그렇다면 그것이 있으면 좋을 것입니다.

따라서 다른 방법으로 이동하여 함수를 인라인 한 모든 메서드를 저장하고 변경시 다시 컴파일해야합니다. (물론 현재 실행 확인 등)

여기서 어려운 문제는 다음과 같습니다.

• 당신이 말했듯이 코드 무효화, (생성 된 코드에서) 이전 기능을 사용하는 모든 장소를 찾으십시오. 이는 변경되었지만 호출 규칙 및 반환 유형이 변경되지 않은 함수를 호출하는 코드를 재배치 할 수 있음을 의미합니다.
• 더 어렵습니다 : 새 메서드를 정의하는 동안 다른 작업이 실행 중이면 어떻게됩니까? 어떤 상태가 보입니까? 효율적으로 구현하기가 매우 어렵 기 때문에 스택 교체없이 해결하고 싶습니다. 우리는 성능을 저하시키지 않는 해결책이 있다고 생각 하며 @vtjnash 가 적절한 모양이되면 약간의 글을 올릴 것이라고 생각합니다.

문제에 대한 해결책에서 작업하는 동안 주어진 함수가 위의 방법 중 하나에서 사용 된 경우 (및 경우에만) 설정된 모든 함수에 플래그를 추가하는 것이 가능하고 좋은 생각인지 궁금합니다. inlining 등) 인라인 메서드가 재정의되었다는 경고를 생성하기 위해. (모호한 경고 작동 방식과 유사)
플래그를 저장하는 더 좋은 방법이 없다면 줄리아 0.5의 새로운 메소드 / 함수 구조를 다시 사용할 수 있습니다.

이제 repl에서 이것을 치는 것이 훨씬 더 쉬워졌으며이 동작은 맵에 대해 문서화되어야합니까?

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 런타임 성능이나 메모리

약간의 메모리 (140MB-> 170MB)가 필요하지만 성능 (컴파일 또는 런타임)에 큰 영향을주지 않아야합니다. 그리고 저는 아직 많은 최적화를 시도하지 않았습니다.

지금까지의 데모는 재미 있습니다.

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

g 컴파일 순서와 f 재정의 실행 순서로 인해 2, 3, 4가 반환되지 않는 이유는 무엇입니까?

대충 맞습니다. 이 순서가하는 말을 더 정확한 그래서 주 언어는 컴파일을 정의하지 의미하는 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

속임수입니다. + 이 Base에서 전혀 사용되지 않는다고 생각하므로 재 컴파일 할 것이 없습니다. REPL이 나타나기 전에 최소한 100 번 호출되어야한다는 것을 알고있는 svd 와 같은 실제 함수를 재정의하십시오. 그러면 우리는 감동 할 것입니다.

프로파일 링 / 추적을 위해 코드를 실시간으로 다시 계측 할 수있는 기회가 날아가고 있습니다.

과연. Ctrl-D; julia<Enter> 시퀀스가 거의 닳 았기 때문에 여기에서 새 키보드를 구입하려고했습니다. 그럴 필요가없는 것 같습니다.

릴리스 노트를 작성하는 것은 다소 비현실적 일 수 있지만, 이해는 이제 collect -ing a 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 릴리스 이전에 원하는 경우 언제든지 master를 팔로우 할 수 있습니다.)

이 문제에 대한 진전을 보게되어 정말 기쁩니다! 이렇게하면 컴파일러가 https://groups.google.com/forum/#!topic/julia -users / OBs0fmNmjCU에 설명 된 사례를 최적화 할 수 있다면 놀라 울 것입니다.

와. 정말 멋진 순간입니다!

안녕하세요!

이 수정 사항을 0.5 시리즈로 백 포트 할 가능성이 있습니까? 아니면 0.6이 될 때만 작동합니까?

이는 주요 변경 사항이며 0.6에서만 사용할 수 있습니다.

이 문제를 해결하는 것이 얼마나 멋진 지 과장하기 어렵습니다. 오래된 습관은 심하게 죽기 때문에 때때로 줄리아를 불필요하게 다시 시작하거나 재 구축하지만, 기억하면 문제를 해결하는 데있어 완전한 게임 체인저입니다.